mrz-genius 2.0.0

package/src/parser/mrzParser.js

@@ -0,0 +1,487 @@
+/**
+ * MRZ Parser
+ * Parses MRZ strings for TD1, TD2, TD3, MRVA, MRVB document types
+ * Inspired by MRZParser Swift library
+ */
+
+'use strict';
+
+const { MRZ_FORMATS, getFieldPositions } = require('./fieldPositions');
+const { calculateCheckDigit, isCheckDigitValid, isCompositeValid } = require('./checkDigit');
+const { correctOCR, findMatchingStrings, repairFieldWithCheckDigit, repairIvorianDocumentNumber } = require('./ocrCorrector');
+
+// ──────────────────────────────────────────────────────────
+// Format detection
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Detect MRZ format from lines
+ * @param {string[]} lines - MRZ lines
+ * @returns {string|null} Format name or null
+ */
+function detectFormat(lines) {
+  if (!lines || lines.length === 0) return null;
+
+  const lineCount = lines.length;
+  const lineLength = lines[0].length;
+
+  // All lines must have equal length
+  if (!lines.every(l => l.length === lineLength)) return null;
+
+  const firstChar = lines[0][0];
+  const isVisa = firstChar === 'V';
+
+  if (lineCount === 3 && lineLength === 30) return 'TD1';
+  if (lineCount === 2 && lineLength === 36) return isVisa ? 'MRVB' : 'TD2';
+  if (lineCount === 2 && lineLength === 44) return isVisa ? 'MRVA' : 'TD3';
+
+  return null;
+}
+
+/**
+ * Try to auto-split a single MRZ string (concatenated lines) into proper lines
+ * Handles cases where MRZ is provided as a single string without line breaks
+ * @param {string} mrzString - Single MRZ string (possibly concatenated)
+ * @returns {string[]|null} Array of lines or null if cannot determine format
+ */
+function autoSplitMRZ(mrzString) {
+  const cleaned = mrzString.replace(/\s+/g, '').toUpperCase();
+  const len = cleaned.length;
+
+  // TD1: 3 lines × 30 = 90 characters
+  if (len === 90) {
+    return [
+      cleaned.substring(0, 30),
+      cleaned.substring(30, 60),
+      cleaned.substring(60, 90),
+    ];
+  }
+
+  // TD2/MRVB: 2 lines × 36 = 72 characters
+  if (len === 72) {
+    return [
+      cleaned.substring(0, 36),
+      cleaned.substring(36, 72),
+    ];
+  }
+
+  // TD3/MRVA: 2 lines × 44 = 88 characters
+  if (len === 88) {
+    return [
+      cleaned.substring(0, 44),
+      cleaned.substring(44, 88),
+    ];
+  }
+
+  // Try fuzzy matching with tolerance ±2 chars (OCR sometimes adds/drops chars)
+  if (len >= 88 && len <= 92) {
+    // Likely TD1 (90)
+    return [
+      cleaned.substring(0, 30),
+      cleaned.substring(30, 60),
+      cleaned.substring(60),
+    ].map(l => l.substring(0, 30).padEnd(30, '<'));
+  }
+
+  if (len >= 70 && len <= 74) {
+    // Likely TD2/MRVB (72)
+    return [
+      cleaned.substring(0, 36),
+      cleaned.substring(36),
+    ].map(l => l.substring(0, 36).padEnd(36, '<'));
+  }
+
+  if (len >= 86 && len <= 90 && len !== 90) {
+    // Likely TD3/MRVA (88) — avoid conflicting with TD1 (90)
+    return [
+      cleaned.substring(0, 44),
+      cleaned.substring(44),
+    ].map(l => l.substring(0, 44).padEnd(44, '<'));
+  }
+
+  return null;
+}
+
+// ──────────────────────────────────────────────────────────
+// Field extraction
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Extract raw field value from MRZ lines
+ * @param {string[]} lines - MRZ lines
+ * @param {Object} position - Field position definition
+ * @returns {string} Raw field value
+ */
+function extractRawField(lines, position) {
+  const line = lines[position.line];
+  if (!line) return '';
+  return line.substring(position.start, position.end);
+}
+
+/**
+ * Extract check digit following a field
+ * In MRZ, '<' is treated as 0 for check digit positions
+ * @param {string[]} lines - MRZ lines
+ * @param {Object} position - Field position
+ * @returns {number|null} Check digit or null
+ */
+function extractCheckDigit(lines, position) {
+  if (!position.hasCheckDigit) return null;
+  const line = lines[position.line];
+  if (!line) return null;
+  const char = line[position.end];
+  if (char === undefined) return null;
+
+  // '<' in check digit position = 0
+  if (char === '<') return 0;
+
+  const digit = parseInt(char, 10);
+  return isNaN(digit) ? null : digit;
+}
+
+/**
+ * Clean filler characters from a field value
+ * @param {string} value - Raw value
+ * @returns {string|null} Clean value or null if empty
+ */
+function cleanFieldValue(value) {
+  if (value === null || value === undefined) return null;
+  const cleaned = value.replace(/^<+|<+$/g, '').replace(/</g, ' ');
+  return cleaned.length > 0 ? cleaned : null;
+}
+
+// ──────────────────────────────────────────────────────────
+// Name parsing
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Parse name field into surname and given names
+ * @param {string} rawName - Raw name field value
+ * @returns {{ surname: string, givenNames: string|null }}
+ */
+function parseName(rawName) {
+  if (!rawName) return { surname: null, givenNames: null };
+  const trimmed = rawName.replace(/^<+|<+$/g, '');
+  const parts = trimmed.split('<<');
+  const surname = (parts[0] || '').replace(/</g, ' ').trim();
+  const givenNames = parts.length > 1 ? parts[1].replace(/</g, ' ').trim() : null;
+  return {
+    surname: surname || null,
+    givenNames: givenNames || null,
+  };
+}
+
+// ──────────────────────────────────────────────────────────
+// Date parsing
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Parse a 6-digit MRZ date (YYMMDD) into a Date object
+ * @param {string} raw - Raw 6-digit string
+ * @param {'birth'|'expiry'} type - Date type for century determination
+ * @returns {Date|null} Parsed date or null
+ */
+function parseDate(raw, type) {
+  if (!raw || raw.length !== 6) return null;
+  if (raw === '<<<<<<') return null;
+
+  const yy = parseInt(raw.substring(0, 2), 10);
+  const mm = parseInt(raw.substring(2, 4), 10);
+  const dd = parseInt(raw.substring(4, 6), 10);
+
+  if (isNaN(yy) || isNaN(mm) || isNaN(dd)) return null;
+  if (mm < 1 || mm > 12 || dd < 1 || dd > 31) return null;
+
+  const currentYear = new Date().getFullYear();
+  const currentYY = currentYear % 100;
+
+  let century;
+  if (type === 'birth') {
+    century = yy > currentYY ? 1900 : 2000;
+  } else {
+    // Expiry: if >= currentYY + 50, assume previous century
+    century = yy >= (currentYY + 50) ? 1900 : 2000;
+  }
+
+  const year = century + yy;
+  return new Date(Date.UTC(year, mm - 1, dd));
+}
+
+/**
+ * Format date as YYYY-MM-DD string
+ * @param {Date} date 
+ * @returns {string}
+ */
+function formatDate(date) {
+  if (!date) return null;
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(date.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+// ──────────────────────────────────────────────────────────
+// Sex parsing
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Parse sex field
+ * @param {string} rawSex 
+ * @returns {string}
+ */
+function parseSex(rawSex) {
+  const char = (rawSex || '').replace(/</g, '').trim();
+  switch (char) {
+    case 'M': return 'MALE';
+    case 'F': return 'FEMALE';
+    case 'X': return 'NON_BINARY';
+    default: return 'UNSPECIFIED';
+  }
+}
+
+// ──────────────────────────────────────────────────────────
+// Document type parsing
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Parse document type from the first character
+ * @param {string} rawType  
+ * @returns {string}
+ */
+function parseDocumentType(rawType) {
+  const char = (rawType || '').replace(/</g, '').trim();
+  switch (char) {
+    case 'P': return 'PASSPORT';
+    case 'V': return 'VISA';
+    case 'I':
+    case 'A':
+    case 'C': return 'ID_CARD';
+    default: return char || 'UNKNOWN';
+  }
+}
+
+// ──────────────────────────────────────────────────────────
+// Main parser
+// ──────────────────────────────────────────────────────────
+
+/**
+ * Parse MRZ string or lines
+ * @param {string|string[]} input - MRZ string (multi-line) or array of lines
+ * @param {Object} [options] - Parser options
+ * @param {boolean} [options.ocrCorrection=false] - Enable OCR error correction
+ * @returns {MRZResult|null} Parsed result or null if format unrecognized
+ */
+function parse(input, options = {}) {
+  const { ocrCorrection = false } = options;
+
+  // Normalize input
+  let lines;
+  if (typeof input === 'string') {
+    lines = input.trim().split(/[\n\r]+/).map(l => l.trim().toUpperCase());
+  } else if (Array.isArray(input)) {
+    lines = input.map(l => l.trim().toUpperCase());
+  } else {
+    return null;
+  }
+
+  // Remove empty lines and spaces
+  lines = lines.filter(l => l.length > 0)
+               .map(l => l.replace(/\s+/g, ''));
+
+  // If the total length matches a known MRZ size, join them and auto-split.
+  // This gracefully handles arrays where lines were clumped together (e.g. [30, 60] -> [30, 30, 30])
+  const totalLength = lines.reduce((sum, l) => sum + l.length, 0);
+  if ([72, 88, 90].includes(totalLength)) {
+    const autoSplit = autoSplitMRZ(lines.join(''));
+    if (autoSplit) {
+      lines = autoSplit;
+    }
+  } else if (lines.length === 1 && lines[0].length > 44) {
+    const autoSplit = autoSplitMRZ(lines[0]);
+    if (autoSplit) {
+      lines = autoSplit;
+    }
+  }
+
+  // Also try removing spaces from lines (OCR artifact)
+  lines = lines.map(l => l.replace(/\s+/g, ''));
+
+  // Detect format
+  let format = detectFormat(lines);
+
+  // If format not detected, try normalizing line lengths
+  if (!format && lines.length >= 2) {
+    const maxLen = Math.max(...lines.map(l => l.length));
+    // Try padding shorter lines
+    const padded = lines.map(l => l.padEnd(maxLen, '<'));
+    format = detectFormat(padded);
+    if (format) lines = padded;
+  }
+
+  if (!format) return null;
+
+  // Get field positions
+  const positions = getFieldPositions(format);
+  if (!positions) return null;
+
+  // ─── Extract fields ───
+  const rawDocType = extractRawField(lines, positions.documentType);
+  const rawIssuingCountry = extractRawField(lines, positions.issuingCountry);
+  const rawName = extractRawField(lines, positions.name);
+  const rawDocNumber = extractRawField(lines, positions.documentNumber);
+  const rawNationality = extractRawField(lines, positions.nationality);
+  const rawBirthDate = extractRawField(lines, positions.birthDate);
+  const rawSex = extractRawField(lines, positions.sex);
+  const rawExpiryDate = extractRawField(lines, positions.expiryDate);
+
+  // Optional data
+  const rawOptionalData1 = positions.optionalData1 ? extractRawField(lines, positions.optionalData1) : null;
+  const rawOptionalData2 = positions.optionalData2 ? extractRawField(lines, positions.optionalData2) : null;
+
+  // ─── OCR correction on individual fields ───
+  const correctedIssuingCountry = ocrCorrection ? correctOCR(rawIssuingCountry, 'letters') : rawIssuingCountry;
+  const correctedNationality = ocrCorrection ? correctOCR(rawNationality, 'letters') : rawNationality;
+
+  let correctedDocNumber = ocrCorrection ? repairIvorianDocumentNumber(rawDocNumber, correctedIssuingCountry) : rawDocNumber;
+  let correctedBirthDate = ocrCorrection ? correctOCR(rawBirthDate, 'digits') : rawBirthDate;
+  let correctedExpiryDate = ocrCorrection ? correctOCR(rawExpiryDate, 'digits') : rawExpiryDate;
+  const correctedSex = ocrCorrection ? correctOCR(rawSex, 'sex') : rawSex;
+
+  // ─── Check digits ───
+  let docNumberCheckDigit = extractCheckDigit(lines, positions.documentNumber);
+  let birthDateCheckDigit = extractCheckDigit(lines, positions.birthDate);
+  let expiryDateCheckDigit = extractCheckDigit(lines, positions.expiryDate);
+
+  let docNumberValid = docNumberCheckDigit !== null ? isCheckDigitValid(correctedDocNumber, docNumberCheckDigit) : true;
+  let birthDateValid = birthDateCheckDigit !== null ? isCheckDigitValid(correctedBirthDate, birthDateCheckDigit) : true;
+  let expiryDateValid = expiryDateCheckDigit !== null ? isCheckDigitValid(correctedExpiryDate, expiryDateCheckDigit) : true;
+
+  if (ocrCorrection) {
+    if (!docNumberValid && docNumberCheckDigit !== null) {
+      const rep = repairFieldWithCheckDigit(correctedDocNumber, docNumberCheckDigit);
+      correctedDocNumber = rep.value; docNumberCheckDigit = rep.checkDigit; docNumberValid = rep.valid;
+    }
+    if (!birthDateValid && birthDateCheckDigit !== null) {
+      const rep = repairFieldWithCheckDigit(correctedBirthDate, birthDateCheckDigit);
+      correctedBirthDate = rep.value; birthDateCheckDigit = rep.checkDigit; birthDateValid = rep.valid;
+    }
+    if (!expiryDateValid && expiryDateCheckDigit !== null) {
+      const rep = repairFieldWithCheckDigit(correctedExpiryDate, expiryDateCheckDigit);
+      correctedExpiryDate = rep.value; expiryDateCheckDigit = rep.checkDigit; expiryDateValid = rep.valid;
+    }
+
+    // specific hack for Côte d'Ivoire where check digit equals 0 (filler `<`) incorrectly marked invalid due to standard check
+    if (correctedIssuingCountry === 'CIV' && docNumberCheckDigit === 0 && !docNumberValid) {
+      docNumberValid = true;
+    }
+  }
+
+  // Optional data 1 check digit (TD3 only)
+  let optionalData1CheckDigit = null;
+  let optionalData1Valid = true;
+  if (positions.optionalData1 && positions.optionalData1.hasCheckDigit) {
+    optionalData1CheckDigit = extractCheckDigit(lines, positions.optionalData1);
+    if (optionalData1CheckDigit !== null) {
+      optionalData1Valid = isCheckDigitValid(rawOptionalData1, optionalData1CheckDigit);
+    }
+  }
+
+  // Final composite check digit
+  let finalCheckDigitValid = true;
+  let finalCheckDigitValue = null;
+  if (positions.finalCheckDigit) {
+    const rawFinal = extractRawField(lines, positions.finalCheckDigit);
+    finalCheckDigitValue = rawFinal === '<' ? 0 : parseInt(rawFinal, 10);
+
+    if (finalCheckDigitValue !== null && !isNaN(finalCheckDigitValue)) {
+      // Build composite fields based on format
+      let compositeFields;
+      if (format === 'TD1') {
+        compositeFields = [
+          { rawValue: correctedDocNumber, checkDigit: docNumberCheckDigit },
+          { rawValue: rawOptionalData1 || '', checkDigit: null },
+          { rawValue: correctedBirthDate, checkDigit: birthDateCheckDigit },
+          { rawValue: correctedExpiryDate, checkDigit: expiryDateCheckDigit },
+          { rawValue: rawOptionalData2 || '', checkDigit: null },
+        ];
+      } else {
+        // TD2, TD3
+        compositeFields = [
+          { rawValue: correctedDocNumber, checkDigit: docNumberCheckDigit },
+          { rawValue: correctedBirthDate, checkDigit: birthDateCheckDigit },
+          { rawValue: correctedExpiryDate, checkDigit: expiryDateCheckDigit },
+        ];
+        if (format === 'TD3' && rawOptionalData1) {
+          compositeFields.push({
+            rawValue: rawOptionalData1,
+            checkDigit: optionalData1CheckDigit,
+          });
+        }
+      }
+
+      finalCheckDigitValid = isCompositeValid(compositeFields, finalCheckDigitValue);
+    }
+  }
+
+  // ─── Parse values ───
+  const documentType = parseDocumentType(rawDocType);
+  const name = parseName(rawName);
+  const birthDate = parseDate(correctedBirthDate, 'birth');
+  const expiryDate = parseDate(correctedExpiryDate, 'expiry');
+  const sex = parseSex(correctedSex);
+
+  const allChecksValid = docNumberValid && birthDateValid && expiryDateValid && optionalData1Valid && finalCheckDigitValid;
+
+  return {
+    valid: allChecksValid,
+    format,
+    documentType,
+    issuingCountry: cleanFieldValue(correctedIssuingCountry),
+    surname: name.surname,
+    givenNames: name.givenNames,
+    documentNumber: cleanFieldValue(correctedDocNumber),
+    nationality: cleanFieldValue(correctedNationality),
+    birthDate,
+    birthDateFormatted: formatDate(birthDate),
+    sex,
+    expiryDate,
+    expiryDateFormatted: formatDate(expiryDate),
+    optionalData1: cleanFieldValue(rawOptionalData1),
+    optionalData2: cleanFieldValue(rawOptionalData2),
+    mrzKey: buildMrzKey(correctedDocNumber, docNumberCheckDigit, correctedBirthDate, birthDateCheckDigit, correctedExpiryDate, expiryDateCheckDigit),
+    rawMRZ: lines.join('\n'),
+    details: {
+      fields: {
+        documentNumber: { raw: rawDocNumber, checkDigit: docNumberCheckDigit, valid: docNumberValid },
+        birthDate: { raw: rawBirthDate, checkDigit: birthDateCheckDigit, valid: birthDateValid },
+        expiryDate: { raw: rawExpiryDate, checkDigit: expiryDateCheckDigit, valid: expiryDateValid },
+        optionalData1: { raw: rawOptionalData1, checkDigit: optionalData1CheckDigit, valid: optionalData1Valid },
+      },
+      finalCheckDigitValid,
+    },
+  };
+}
+
+/**
+ * Build MRZ key (used for BAC in e-Passports)
+ */
+function buildMrzKey(docNum, docCheckDigit, birthDate, birthCheckDigit, expiryDate, expiryCheckDigit) {
+  let key = docNum;
+  if (docCheckDigit !== null && docCheckDigit !== undefined) key += String(docCheckDigit);
+  key += birthDate;
+  if (birthCheckDigit !== null && birthCheckDigit !== undefined) key += String(birthCheckDigit);
+  key += expiryDate;
+  if (expiryCheckDigit !== null && expiryCheckDigit !== undefined) key += String(expiryCheckDigit);
+  return key;
+}
+
+module.exports = {
+  parse,
+  detectFormat,
+  autoSplitMRZ,
+  parseName,
+  parseDate,
+  formatDate,
+  parseSex,
+  parseDocumentType,
+};

package/src/parser/ocrCorrector.js

@@ -0,0 +1,172 @@
+/**
+ * OCR Error Corrector
+ * Handles common OCR misreadings in MRZ strings
+ * Inspired by MRZParser's OCRCorrector.swift
+ */
+
+'use strict';
+
+/**
+ * Common OCR character replacements based on content type
+ */
+const CORRECTIONS = {
+  digits: {
+    'O': '0', 'Q': '0', 'U': '0', 'D': '0',
+    'I': '1', 'L': '1',
+    'Z': '2',
+    'S': '5',
+    'G': '6',
+    'B': '8',
+  },
+  letters: {
+    '0': 'O',
+    '1': 'I',
+    '2': 'Z',
+    '8': 'B',
+    '5': 'S',
+    '6': 'G',
+  },
+  sex: {
+    'P': 'F',
+  },
+};
+
+/**
+ * Correct OCR errors based on the expected content type
+ * @param {string} str - String to correct
+ * @param {'digits'|'letters'|'sex'|'mixed'} contentType - Expected content type
+ * @returns {string} Corrected string
+ */
+function correctOCR(str, contentType) {
+  if (contentType === 'mixed') return str;
+  
+  const corrections = CORRECTIONS[contentType];
+  if (!corrections) return str;
+  
+  let result = '';
+  for (const char of str) {
+    result += corrections[char] || char;
+  }
+  return result;
+}
+
+/**
+ * Get all possible character transformations for a character
+ * @param {string} char - Character to transform
+ * @returns {string[]} Array of possible characters
+ */
+function getTransformedChars(char) {
+  const digitsReplaced = CORRECTIONS.digits[char] || char;
+  const lettersReplaced = CORRECTIONS.letters[char] || char;
+  const results = new Set([char, digitsReplaced, lettersReplaced]);
+  return [...results];
+}
+
+/**
+ * Brute-force OCR correction: try all possible character combinations
+ * to find a combination that satisfies a given validation function.
+ * @param {string[]} strings - Array of strings to correct
+ * @param {function(string[]): boolean} isCorrectCombination - Validation function
+ * @returns {string[]|null} Corrected strings or null if no valid combination found
+ */
+function findMatchingStrings(strings, isCorrectCombination) {
+  const stringsArray = strings.map(s => [...s]);
+  let result = null;
+
+  function dfs(stringIndex) {
+    if (stringIndex === stringsArray.length) {
+      const currentCombination = stringsArray.map(arr => arr.join(''));
+      if (isCorrectCombination(currentCombination)) {
+        result = currentCombination;
+        return true;
+      }
+      return false;
+    }
+
+    for (let charIndex = 0; charIndex < stringsArray[stringIndex].length; charIndex++) {
+      const originalChar = stringsArray[stringIndex][charIndex];
+      const replacements = getTransformedChars(originalChar);
+
+      for (const replacement of replacements) {
+        stringsArray[stringIndex][charIndex] = replacement;
+        if (dfs(stringIndex + 1)) return true;
+      }
+
+      stringsArray[stringIndex][charIndex] = originalChar;
+    }
+
+    return false;
+  }
+
+  return dfs(0) ? result : null;
+}
+
+function repairIvorianDocumentNumber(docNum, issuingCountry) {
+  if (issuingCountry !== 'CIV') return docNum;
+  if (!docNum || docNum.length < 9) return docNum;
+  
+  // Format is CI followed by 7 digits
+  if (docNum.startsWith('CI')) {
+    const prefix = 'CI';
+    const numPart = docNum.substring(2);
+    // Force correct digits in numPart
+    return prefix + correctOCR(numPart, 'digits');
+  }
+  
+  // If it starts with C. (e.g., C1)
+  if (docNum[0] === 'C') {
+    const numPart = docNum.substring(2);
+    return 'CI' + correctOCR(numPart, 'digits');
+  }
+
+  return docNum;
+}
+
+/**
+ * Brute force repair a field and its check digit.
+ * Assumes either the field has ONE mistyped char OR the check digit is mistyped.
+ */
+function repairFieldWithCheckDigit(rawValue, rawCheckDigit) {
+  if (!rawValue || rawCheckDigit === null) return { value: rawValue, checkDigit: rawCheckDigit, valid: false };
+
+  // First check if already valid
+  const { calculateCheckDigit } = require('./checkDigit'); // dynamic require to avoid circular dep if any
+  if (calculateCheckDigit(rawValue) === parseInt(rawCheckDigit, 10)) {
+    return { value: rawValue, checkDigit: rawCheckDigit, valid: true };
+  }
+
+  // Try modifying the value
+  const valArr = [...rawValue];
+  for (let i = 0; i < valArr.length; i++) {
+    const original = valArr[i];
+    const alts = getTransformedChars(original);
+    for (const alt of alts) {
+      if (alt === original) continue;
+      valArr[i] = alt;
+      const testVal = valArr.join('');
+      if (calculateCheckDigit(testVal) === parseInt(rawCheckDigit, 10)) {
+        return { value: testVal, checkDigit: rawCheckDigit, valid: true };
+      }
+    }
+    valArr[i] = original; // backtrack
+  }
+
+  // Try modifying the check digit
+  const cdAlts = getTransformedChars(String(rawCheckDigit));
+  const baseCalc = calculateCheckDigit(rawValue);
+  for (const alt of cdAlts) {
+    if (alt !== String(rawCheckDigit) && parseInt(alt, 10) === baseCalc) {
+      return { value: rawValue, checkDigit: parseInt(alt, 10), valid: true };
+    }
+  }
+
+  return { value: rawValue, checkDigit: rawCheckDigit, valid: false };
+}
+
+module.exports = {
+  correctOCR,
+  getTransformedChars,
+  findMatchingStrings,
+  repairFieldWithCheckDigit,
+  repairIvorianDocumentNumber
+};