mrz-genius 2.0.0

package/src/ocr/mrzOCR.js

@@ -0,0 +1,489 @@
+/**
+ * MRZ OCR Engine
+ * Uses Tesseract.js to perform OCR on MRZ regions
+ * Applies MRZ-specific post-processing for better accuracy
+ */
+
+'use strict';
+
+const Tesseract = require('tesseract.js');
+const sharp = require('sharp');
+const { detectMRZRegion, optimizeForOCR } = require('../detector/mrzDetector');
+
+/**
+ * MRZ-specific character whitelist
+ */
+const MRZ_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<';
+
+/**
+ * Characters commonly misread by OCR as '<' filler
+ * K, L, |, [, ], {, }, (, ) are often mistaken for '<'
+ */
+const FILLER_MISREADS = /[KL\|\[\]\{\}\(\)\\\/_\-\.,:;!]/g;
+
+/**
+ * Clean a single MRZ line by fixing common OCR mistakes
+ * @param {string} line - Raw OCR line
+ * @returns {string} Cleaned line
+ */
+function cleanMRZLine(line) {
+  let cleaned = line
+    .toUpperCase()
+    .replace(/\s+/g, '')
+    .trim();
+
+  // Step 1: Fix obvious non-MRZ characters → '<'
+  cleaned = cleaned.replace(/[^A-Z0-9<]/g, '<');
+
+  // Step 2: Fix trailing K/L sequences → '<' (filler misreads)
+  // e.g. "472<<K<<<K<K<LLKKLKLE" → "472<<<<<<<<<<<<<<<<<"
+  // Strategy: If a character is K or L and surrounded by '<' or other K/L, it's a filler
+  cleaned = fixFillerMisreads(cleaned);
+
+  return cleaned;
+}
+
+/**
+ * Fix K/L/similar chars that are actually '<' fillers
+ * Works by detecting patterns: if K or L appears in a sequence with '<', replace with '<'
+ * @param {string} line 
+ * @returns {string}
+ */
+function fixFillerMisreads(line) {
+  const chars = [...line];
+  const result = [...chars];
+
+  for (let i = 0; i < chars.length; i++) {
+    const c = chars[i];
+    if (c === 'K' || c === 'L') {
+      // Check neighborhood: is this char surrounded by fillers or other K/L?
+      const prev = i > 0 ? chars[i - 1] : '<';
+      const next = i < chars.length - 1 ? chars[i + 1] : '<';
+      const isFillerNeighbor = (ch) => ch === '<' || ch === 'K' || ch === 'L';
+
+      if (isFillerNeighbor(prev) || isFillerNeighbor(next)) {
+        result[i] = '<';
+      }
+
+      // Also check: if we're near the end of the line (last 40%), K/L in MRZ are rare
+      // Filler typically fills the right side of lines
+      if (i > line.length * 0.6) {
+        // In the tail of a line, K/L are very likely fillers
+        const remainingChars = chars.slice(i);
+        const alphaCount = remainingChars.filter(ch => /[A-Z]/.test(ch) && ch !== 'K' && ch !== 'L').length;
+        if (alphaCount < 3) {
+          result[i] = '<';
+        }
+      }
+    }
+  }
+
+  return result.join('');
+}
+
+/**
+ * Post-process OCR output for MRZ
+ * @param {string} text - Raw OCR text
+ * @returns {string[]} Cleaned MRZ lines
+ */
+function postProcessOCR(text) {
+  let lines = text.split('\n')
+    .map(line => cleanMRZLine(line))
+    .filter(line => line.length > 0);
+
+  // Find lines that look like MRZ (right length range)
+  const mrzLines = lines.filter(line => {
+    const len = line.length;
+    return (len >= 28 && len <= 32) ||  // TD1: 30
+           (len >= 34 && len <= 38) ||  // TD2/MRVB: 36
+           (len >= 42 && len <= 46);    // TD3/MRVA: 44
+  });
+
+  if (mrzLines.length >= 2) {
+    lines = mrzLines;
+  }
+
+  // Normalize line lengths
+  if (lines.length >= 2) {
+    const expectedLength = determineExpectedLineLength(lines);
+    if (expectedLength) {
+      lines = lines.map(line => {
+        if (line.length < expectedLength) {
+          return line + '<'.repeat(expectedLength - line.length);
+        } else if (line.length > expectedLength) {
+          return line.substring(0, expectedLength);
+        }
+        return line;
+      });
+    }
+  }
+
+  return lines;
+}
+
+/**
+ * Determine the expected line length from scanned lines
+ * @param {string[]} lines 
+ * @returns {number|null}
+ */
+function determineExpectedLineLength(lines) {
+  // Use the most common line length closest to a standard
+  const lengths = lines.map(l => l.length);
+
+  // Find closest standard length for each line
+  const standards = [30, 36, 44];
+  const closestLengths = lengths.map(len => {
+    let closest = standards[0];
+    let minDist = Math.abs(len - closest);
+    for (const std of standards) {
+      const dist = Math.abs(len - std);
+      if (dist < minDist) {
+        closest = std;
+        minDist = dist;
+      }
+    }
+    return closest;
+  });
+
+  // Most common closest standard
+  const counts = {};
+  closestLengths.forEach(l => { counts[l] = (counts[l] || 0) + 1; });
+  let best = null, bestCount = 0;
+  for (const [len, count] of Object.entries(counts)) {
+    if (count > bestCount) {
+      best = parseInt(len);
+      bestCount = count;
+    }
+  }
+
+  return best;
+}
+
+/**
+ * Score a line for MRZ-likeness
+ * @param {string} line - Cleaned line
+ * @returns {number} Score (higher = more likely MRZ)
+ */
+function scoreMRZLine(line) {
+  let score = 0;
+  const len = line.length;
+
+  // Length matching
+  if ([30, 36, 44].includes(len)) score += 50;
+  else if (Math.abs(len - 30) <= 2 || Math.abs(len - 36) <= 2 || Math.abs(len - 44) <= 2) score += 25;
+  else if (len < 20) return -100; // Too short, definitely not MRZ
+
+  // MRZ starts with specific document type indicators
+  if (/^[PIACV][<A-Z]/.test(line)) score += 20;
+
+  // Contains << separator (name fields)
+  if (line.includes('<<')) score += 20;
+
+  // Has a mix of digits AND letters (most MRZ lines do)
+  const digitCount = [...line].filter(c => c >= '0' && c <= '9').length;
+  const letterCount = [...line].filter(c => c >= 'A' && c <= 'Z').length;
+  const fillerCount = [...line].filter(c => c === '<').length;
+
+  if (digitCount > 0 && letterCount > 0) score += 15;
+  if (digitCount > 3) score += 10; // MRZ has plenty of digits
+
+  // Has fillers but not 100% fillers
+  const fillerRatio = fillerCount / Math.max(len, 1);
+  if (fillerRatio > 0.05 && fillerRatio < 0.7) score += 10;
+  if (fillerRatio > 0.9) score -= 20; // Almost all fillers = probably noise
+
+  // Contains country code pattern (3 uppercase letters)
+  if (/[A-Z]{3}/.test(line)) score += 5;
+
+  // Penalty: if it looks like readable text words (not MRZ)
+  // MRZ doesn't have lowercase or long words without fillers
+  const words = line.replace(/</g, ' ').trim().split(/\s+/);
+  const longWords = words.filter(w => w.length > 8 && /^[A-Z]+$/.test(w));
+  if (longWords.length > 0 && fillerCount < 3) score -= 30; // Looks like regular text
+
+  return score;
+}
+
+/**
+ * Extract MRZ lines from full OCR text using pattern scoring
+ * @param {string} fullText - Full OCR text
+ * @returns {string[]|null} MRZ lines or null
+ */
+function extractMRZFromFullText(fullText) {
+  const allLines = fullText.split('\n')
+    .map(l => cleanMRZLine(l))
+    .filter(l => l.length > 15);
+
+  // Score each line
+  const scoredLines = allLines.map(line => ({
+    line,
+    score: scoreMRZLine(line),
+    length: line.length,
+  }));
+
+  // Sort by score descending
+  const sorted = [...scoredLines].sort((a, b) => b.score - a.score);
+
+  // Keep lines with decent scores
+  const threshold = 20;
+  const candidates = sorted.filter(s => s.score >= threshold);
+
+  if (candidates.length < 2) return null;
+
+  // Preserve original document order
+  const candidateLines = candidates.map(c => c.line);
+  const orderedCandidates = allLines.filter(l => candidateLines.includes(l));
+
+  // Try TD1: 3 lines close to 30 chars
+  const td1Candidates = orderedCandidates.filter(l => Math.abs(l.length - 30) <= 15);
+  if (td1Candidates.length >= 3) {
+    return td1Candidates.slice(-3).map(l => (l + '<'.repeat(30)).substring(0, 30));
+  }
+
+  // Try TD2/MRVB: 2 lines close to 36 chars
+  const td2Candidates = orderedCandidates.filter(l => Math.abs(l.length - 36) <= 18);
+  if (td2Candidates.length >= 2) {
+    return td2Candidates.slice(-2).map(l => (l + '<'.repeat(36)).substring(0, 36));
+  }
+
+  // Try TD3/MRVA: 2 lines close to 44 chars
+  const td3Candidates = orderedCandidates.filter(l => Math.abs(l.length - 44) <= 22);
+  if (td3Candidates.length >= 2) {
+    return td3Candidates.slice(-2).map(l => (l + '<'.repeat(44)).substring(0, 44));
+  }
+
+  // Fallback: take the best scored lines
+  if (orderedCandidates.length >= 3) {
+    return orderedCandidates.slice(-3);
+  }
+  if (orderedCandidates.length >= 2) {
+    return orderedCandidates.slice(-2);
+  }
+
+  return null;
+}
+
+/**
+ * Prepare multiple image variants for OCR
+ * @param {Buffer} imageBuffer - Source image
+ * @returns {Promise<{buffer: Buffer, name: string}[]>}
+ */
+async function prepareImageVariants(imageBuffer) {
+  const meta = await sharp(imageBuffer).metadata();
+  const w = meta.width;
+  const h = meta.height;
+  const variants = [];
+
+  // Variant 1: Upscale + high contrast threshold
+  try {
+    const v1 = await sharp(imageBuffer)
+      .grayscale()
+      .normalize()
+      .sharpen({ sigma: 2 })
+      .threshold(140)
+      .resize(w * 3, h * 3, { kernel: sharp.kernel.lanczos3 })
+      .toBuffer();
+    variants.push({ buffer: v1, name: 'threshold_140_3x' });
+  } catch (e) { /* skip */ }
+
+  // Variant 2: Lower threshold (for lighter prints)
+  try {
+    const v2 = await sharp(imageBuffer)
+      .grayscale()
+      .normalize()
+      .threshold(100)
+      .resize(w * 3, h * 3, { kernel: sharp.kernel.lanczos3 })
+      .toBuffer();
+    variants.push({ buffer: v2, name: 'threshold_100_3x' });
+  } catch (e) { /* skip */ }
+
+  // Variant 3: Higher threshold (for heavy prints)
+  try {
+    const v3 = await sharp(imageBuffer)
+      .grayscale()
+      .normalize()
+      .threshold(170)
+      .resize(w * 3, h * 3, { kernel: sharp.kernel.lanczos3 })
+      .toBuffer();
+    variants.push({ buffer: v3, name: 'threshold_170_3x' });
+  } catch (e) { /* skip */ }
+
+  // Variant 4: Adaptive - just grayscale + normalize + big upscale
+  try {
+    const v4 = await sharp(imageBuffer)
+      .grayscale()
+      .normalize()
+      .sharpen({ sigma: 3 })
+      .resize(w * 4, h * 4, { kernel: sharp.kernel.lanczos3 })
+      .toBuffer();
+    variants.push({ buffer: v4, name: 'sharp_4x' });
+  } catch (e) { /* skip */ }
+
+  // Variant 5: Inverted (white text on dark)
+  try {
+    const v5 = await sharp(imageBuffer)
+      .grayscale()
+      .negate()
+      .normalize()
+      .threshold(140)
+      .resize(w * 3, h * 3, { kernel: sharp.kernel.lanczos3 })
+      .toBuffer();
+    variants.push({ buffer: v5, name: 'inverted_140_3x' });
+  } catch (e) { /* skip */ }
+
+  return variants;
+}
+
+/**
+ * Score OCR result quality for MRZ
+ * @param {string[]} lines - Post-processed MRZ lines
+ * @param {number} confidence - Tesseract confidence
+ * @returns {number}
+ */
+function scoreOCRResult(lines, confidence) {
+  let score = confidence;
+
+  // Bonus for having the right number of lines
+  if (lines.length === 3) score += 30;  // TD1
+  else if (lines.length === 2) score += 20;
+
+  // Bonus for correct line lengths
+  lines.forEach(line => {
+    if ([30, 36, 44].includes(line.length)) score += 15;
+  });
+
+  // Bonus for lines that score well as MRZ
+  lines.forEach(line => {
+    score += scoreMRZLine(line) * 0.5;
+  });
+
+  return score;
+}
+
+/**
+ * Perform OCR on an image to extract MRZ text
+ * @param {Buffer|string} input - Image buffer or file path
+ * @param {Object} [options] - OCR options
+ * @param {string} [options.lang='eng'] - Tesseract language
+ * @param {boolean} [options.detectRegion=true] - Auto-detect MRZ region
+ * @returns {Promise<Object>} OCR result with MRZ lines
+ */
+async function performOCR(input, options = {}) {
+  const {
+    lang = 'eng',
+    detectRegion = true,
+  } = options;
+
+  // Step 1: Create Tesseract worker
+  const worker = await Tesseract.createWorker(lang, 1);
+  await worker.setParameters({
+    tessedit_char_whitelist: MRZ_CHARSET,
+    tessedit_pageseg_mode: Tesseract.PSM.SINGLE_BLOCK,
+    preserve_interword_spaces: '0',
+  });
+
+  let bestResult = { lines: [], rawText: '', confidence: 0, method: 'none' };
+  let bestScore = -Infinity;
+
+  try {
+    // Step 2: Try MRZ region crops at different bottom percentages
+    const bottomPercents = [30, 40, 25, 50];
+
+    for (const pct of bottomPercents) {
+      try {
+        const region = await detectMRZRegion(input, { bottomPercent: pct });
+        if (!region) continue;
+
+        // Prepare image variants from the cropped region
+        const variants = await prepareImageVariants(region.imageBuffer);
+
+        for (const variant of variants) {
+          try {
+            const result = await worker.recognize(variant.buffer);
+            const lines = postProcessOCR(result.data.text);
+            const score = scoreOCRResult(lines, result.data.confidence);
+
+            if (score > bestScore && lines.length >= 2) {
+              bestScore = score;
+              bestResult = {
+                lines,
+                rawText: result.data.text,
+                confidence: result.data.confidence,
+                method: `region_${pct}pct_${variant.name}`,
+              };
+            }
+          } catch (e) { /* skip variant */ }
+        }
+
+        // Early exit if we have a great result
+        if (bestScore > 150) break;
+      } catch (e) { /* try next crop */ }
+    }
+
+    // Step 3: If no good result from region crops, try full image
+    if (bestResult.lines.length < 2) {
+      const variants = await prepareImageVariants(
+        typeof input === 'string' ? await sharp(input).toBuffer() : input
+      );
+
+      for (const variant of variants) {
+        try {
+          const result = await worker.recognize(variant.buffer);
+          
+          let extracted = extractMRZFromFullText(result.data.text);
+          if (!extracted || extracted.length < 2) {
+             const lines = postProcessOCR(result.data.text);
+             extracted = lines;
+          }
+
+          const score = scoreOCRResult(extracted, result.data.confidence);
+          if (score > bestScore && extracted.length >= 2) {
+            bestScore = score;
+            bestResult = {
+              lines: extracted,
+              rawText: result.data.text,
+              confidence: result.data.confidence,
+              method: `full_image_${variant.name}`,
+            };
+          }
+        } catch (e) { /* skip */ }
+      }
+    }
+
+    // Step 4: Last resort
+    if (bestResult.lines.length < 2 && bestResult.rawText) {
+      const extracted = extractMRZFromFullText(bestResult.rawText);
+      if (extracted && extracted.length >= 2) {
+        bestResult.lines = extracted;
+        bestResult.method += '+pattern_extraction';
+      }
+    }
+
+    return bestResult;
+  } finally {
+    await worker.terminate();
+  }
+}
+
+/**
+ * Quick check if an image contains an MRZ
+ * @param {Buffer|string} input - Image buffer or file path
+ * @returns {Promise<boolean>} True if MRZ is likely present
+ */
+async function hasMRZ(input) {
+  try {
+    const result = await performOCR(input, { detectRegion: true });
+    return result.lines.length >= 2;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  performOCR,
+  postProcessOCR,
+  extractMRZFromFullText,
+  cleanMRZLine,
+  hasMRZ,
+  MRZ_CHARSET,
+};

package/src/parser/checkDigit.js

@@ -0,0 +1,84 @@
+/**
+ * MRZ Check Digit Calculator & Validator
+ * Based on ICAO 9303 standard
+ * 
+ * Weight pattern: 7, 3, 1 (repeating)
+ * Character values:
+ *   0-9 → 0-9
+ *   A-Z → 10-35
+ *   <   → 0
+ */
+
+'use strict';
+
+/**
+ * Get numeric value for an MRZ character
+ * @param {string} char - Single character
+ * @returns {number|null} Numeric value or null if invalid
+ */
+function getCharValue(char) {
+  if (char === '<') return 0;
+  
+  const code = char.charCodeAt(0);
+  
+  // 0-9
+  if (code >= 48 && code <= 57) return code - 48;
+  
+  // A-Z
+  if (code >= 65 && code <= 90) return code - 55;
+  
+  // a-z (uppercase tolerance)
+  if (code >= 97 && code <= 122) return code - 87;
+  
+  return null;
+}
+
+/**
+ * Calculate the check digit for a given MRZ string
+ * @param {string} value - MRZ string to calculate check digit for
+ * @returns {number|null} Check digit (0-9) or null if invalid
+ */
+function calculateCheckDigit(value) {
+  const weights = [7, 3, 1];
+  let sum = 0;
+  
+  for (let i = 0; i < value.length; i++) {
+    const charVal = getCharValue(value[i]);
+    if (charVal === null) return null;
+    sum += charVal * weights[i % 3];
+  }
+  
+  return sum % 10;
+}
+
+/**
+ * Validate an MRZ field value against its check digit
+ * @param {string} rawValue - MRZ string to validate
+ * @param {number} checkDigit - Expected check digit
+ * @returns {boolean} True if valid
+ */
+function isCheckDigitValid(rawValue, checkDigit) {
+  const calculated = calculateCheckDigit(rawValue);
+  return calculated === checkDigit;
+}
+
+/**
+ * Validate composite check digit (used for final line validation)
+ * @param {Array<{rawValue: string, checkDigit: number|null}>} fields - Fields to composite
+ * @param {number} finalCheckDigit - Final check digit to validate against
+ * @returns {boolean} True if valid
+ */
+function isCompositeValid(fields, finalCheckDigit) {
+  const compositedValue = fields.reduce((acc, field) => {
+    return acc + field.rawValue + (field.checkDigit !== null && field.checkDigit !== undefined ? String(field.checkDigit) : '');
+  }, '');
+  
+  return isCheckDigitValid(compositedValue, finalCheckDigit);
+}
+
+module.exports = {
+  getCharValue,
+  calculateCheckDigit,
+  isCheckDigitValid,
+  isCompositeValid
+};

package/src/parser/fieldPositions.js

@@ -0,0 +1,122 @@
+/**
+ * MRZ Field Positions
+ * Defines the position of each field for each MRZ format (TD1, TD2, TD3, MRVA, MRVB)
+ * Based on ICAO 9303 standard
+ */
+
+'use strict';
+
+/**
+ * MRZ Format specifications
+ */
+const MRZ_FORMATS = {
+  TD1: { lineLength: 30, linesCount: 3 },
+  TD2: { lineLength: 36, linesCount: 2 },
+  TD3: { lineLength: 44, linesCount: 2 },
+  // MRVA and MRVB use the same line lengths as TD3 and TD2
+  MRVA: { lineLength: 44, linesCount: 2 },
+  MRVB: { lineLength: 36, linesCount: 2 },
+};
+
+/**
+ * Field position definition
+ * @typedef {Object} FieldPosition
+ * @property {number} line - Line index (0-based)
+ * @property {number} start - Start position (inclusive)
+ * @property {number} end - End position (exclusive)
+ * @property {boolean} hasCheckDigit - Whether the field is followed by a check digit
+ * @property {'digits'|'letters'|'mixed'|'sex'} contentType - Expected content type
+ */
+
+/**
+ * Get field positions for a given MRZ format
+ * @param {string} format - MRZ format ('TD1', 'TD2', 'TD3', 'MRVA', 'MRVB')
+ * @returns {Object} Field positions
+ */
+function getFieldPositions(format) {
+  switch (format) {
+    case 'TD1':
+      return {
+        documentType:        { line: 0, start: 0,  end: 1,  hasCheckDigit: false, contentType: 'letters' },
+        documentSubtype:     { line: 0, start: 1,  end: 2,  hasCheckDigit: false, contentType: 'letters' },
+        issuingCountry:      { line: 0, start: 2,  end: 5,  hasCheckDigit: false, contentType: 'letters' },
+        documentNumber:      { line: 0, start: 5,  end: 14, hasCheckDigit: true,  contentType: 'mixed' },
+        optionalData1:       { line: 0, start: 15, end: 30, hasCheckDigit: false, contentType: 'mixed' },
+        birthDate:           { line: 1, start: 0,  end: 6,  hasCheckDigit: true,  contentType: 'digits' },
+        sex:                 { line: 1, start: 7,  end: 8,  hasCheckDigit: false, contentType: 'sex' },
+        expiryDate:          { line: 1, start: 8,  end: 14, hasCheckDigit: true,  contentType: 'digits' },
+        nationality:         { line: 1, start: 15, end: 18, hasCheckDigit: false, contentType: 'letters' },
+        optionalData2:       { line: 1, start: 18, end: 29, hasCheckDigit: false, contentType: 'mixed' },
+        finalCheckDigit:     { line: 1, start: 29, end: 30, hasCheckDigit: false, contentType: 'digits' },
+        name:                { line: 2, start: 0,  end: 30, hasCheckDigit: false, contentType: 'letters' },
+      };
+
+    case 'TD2':
+      return {
+        documentType:        { line: 0, start: 0,  end: 1,  hasCheckDigit: false, contentType: 'letters' },
+        documentSubtype:     { line: 0, start: 1,  end: 2,  hasCheckDigit: false, contentType: 'letters' },
+        issuingCountry:      { line: 0, start: 2,  end: 5,  hasCheckDigit: false, contentType: 'letters' },
+        name:                { line: 0, start: 5,  end: 36, hasCheckDigit: false, contentType: 'letters' },
+        documentNumber:      { line: 1, start: 0,  end: 9,  hasCheckDigit: true,  contentType: 'mixed' },
+        nationality:         { line: 1, start: 10, end: 13, hasCheckDigit: false, contentType: 'letters' },
+        birthDate:           { line: 1, start: 13, end: 19, hasCheckDigit: true,  contentType: 'digits' },
+        sex:                 { line: 1, start: 20, end: 21, hasCheckDigit: false, contentType: 'sex' },
+        expiryDate:          { line: 1, start: 21, end: 27, hasCheckDigit: true,  contentType: 'digits' },
+        optionalData1:       { line: 1, start: 28, end: 35, hasCheckDigit: false, contentType: 'mixed' },
+        finalCheckDigit:     { line: 1, start: 35, end: 36, hasCheckDigit: false, contentType: 'digits' },
+      };
+
+    case 'TD3':
+      return {
+        documentType:        { line: 0, start: 0,  end: 1,  hasCheckDigit: false, contentType: 'letters' },
+        documentSubtype:     { line: 0, start: 1,  end: 2,  hasCheckDigit: false, contentType: 'letters' },
+        issuingCountry:      { line: 0, start: 2,  end: 5,  hasCheckDigit: false, contentType: 'letters' },
+        name:                { line: 0, start: 5,  end: 44, hasCheckDigit: false, contentType: 'letters' },
+        documentNumber:      { line: 1, start: 0,  end: 9,  hasCheckDigit: true,  contentType: 'mixed' },
+        nationality:         { line: 1, start: 10, end: 13, hasCheckDigit: false, contentType: 'letters' },
+        birthDate:           { line: 1, start: 13, end: 19, hasCheckDigit: true,  contentType: 'digits' },
+        sex:                 { line: 1, start: 20, end: 21, hasCheckDigit: false, contentType: 'sex' },
+        expiryDate:          { line: 1, start: 21, end: 27, hasCheckDigit: true,  contentType: 'digits' },
+        optionalData1:       { line: 1, start: 28, end: 42, hasCheckDigit: true,  contentType: 'mixed' },
+        finalCheckDigit:     { line: 1, start: 43, end: 44, hasCheckDigit: false, contentType: 'digits' },
+      };
+
+    case 'MRVA':
+      return {
+        documentType:        { line: 0, start: 0,  end: 1,  hasCheckDigit: false, contentType: 'letters' },
+        documentSubtype:     { line: 0, start: 1,  end: 2,  hasCheckDigit: false, contentType: 'letters' },
+        issuingCountry:      { line: 0, start: 2,  end: 5,  hasCheckDigit: false, contentType: 'letters' },
+        name:                { line: 0, start: 5,  end: 44, hasCheckDigit: false, contentType: 'letters' },
+        documentNumber:      { line: 1, start: 0,  end: 9,  hasCheckDigit: true,  contentType: 'mixed' },
+        nationality:         { line: 1, start: 10, end: 13, hasCheckDigit: false, contentType: 'letters' },
+        birthDate:           { line: 1, start: 13, end: 19, hasCheckDigit: true,  contentType: 'digits' },
+        sex:                 { line: 1, start: 20, end: 21, hasCheckDigit: false, contentType: 'sex' },
+        expiryDate:          { line: 1, start: 21, end: 27, hasCheckDigit: true,  contentType: 'digits' },
+        optionalData1:       { line: 1, start: 28, end: 44, hasCheckDigit: false, contentType: 'mixed' },
+        // MRVA has NO final check digit
+      };
+
+    case 'MRVB':
+      return {
+        documentType:        { line: 0, start: 0,  end: 1,  hasCheckDigit: false, contentType: 'letters' },
+        documentSubtype:     { line: 0, start: 1,  end: 2,  hasCheckDigit: false, contentType: 'letters' },
+        issuingCountry:      { line: 0, start: 2,  end: 5,  hasCheckDigit: false, contentType: 'letters' },
+        name:                { line: 0, start: 5,  end: 36, hasCheckDigit: false, contentType: 'letters' },
+        documentNumber:      { line: 1, start: 0,  end: 9,  hasCheckDigit: true,  contentType: 'mixed' },
+        nationality:         { line: 1, start: 10, end: 13, hasCheckDigit: false, contentType: 'letters' },
+        birthDate:           { line: 1, start: 13, end: 19, hasCheckDigit: true,  contentType: 'digits' },
+        sex:                 { line: 1, start: 20, end: 21, hasCheckDigit: false, contentType: 'sex' },
+        expiryDate:          { line: 1, start: 21, end: 27, hasCheckDigit: true,  contentType: 'digits' },
+        optionalData1:       { line: 1, start: 28, end: 36, hasCheckDigit: false, contentType: 'mixed' },
+        // MRVB has NO final check digit
+      };
+
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  MRZ_FORMATS,
+  getFieldPositions
+};