nf-key-extractor 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1546 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors.ts
+function messageFromUnknown(error) {
+  return error instanceof Error ? error.message : "Unknown processing error.";
+}
+var ExtractionFailure;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    ExtractionFailure = class extends Error {
+      code;
+      constructor(code, message, options) {
+        super(message, options);
+        this.name = "ExtractionFailure";
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/pdf/render-page.ts
+var render_page_exports = {};
+__export(render_page_exports, {
+  renderPage: () => renderPage
+});
+async function renderPage(page, recipe, maxPixels) {
+  const { createCanvas } = await import("@napi-rs/canvas");
+  const rotation = ((page.rotate + recipe.rotation) % 360 + 360) % 360;
+  let scale = recipe.scale;
+  let viewport = page.getViewport({ scale, rotation });
+  let width = 0;
+  let height = 0;
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    if (!Number.isFinite(viewport.width) || !Number.isFinite(viewport.height) || viewport.width <= 0 || viewport.height <= 0) {
+      throw new ExtractionFailure("INVALID_PDF", "A PDF page has invalid dimensions.");
+    }
+    width = Math.max(1, Math.ceil(viewport.width));
+    height = Math.max(1, Math.ceil(viewport.height));
+    const allocatedPixels = width * height;
+    if (width <= MAX_CANVAS_DIMENSION && height <= MAX_CANVAS_DIMENSION && allocatedPixels <= maxPixels) {
+      break;
+    }
+    const hasSubpixelAxis = viewport.width < 1 || viewport.height < 1;
+    const pixelFactor = hasSubpixelAxis ? maxPixels / allocatedPixels : Math.sqrt(maxPixels / allocatedPixels);
+    const reduction = Math.min(pixelFactor, MAX_CANVAS_DIMENSION / width, MAX_CANVAS_DIMENSION / height) * 0.999;
+    if (!Number.isFinite(reduction) || reduction <= 0 || reduction >= 1) {
+      throw new ExtractionFailure("INVALID_PDF", "A PDF page exceeds the supported render dimensions.");
+    }
+    scale *= reduction;
+    viewport = page.getViewport({ scale, rotation });
+  }
+  if (width > MAX_CANVAS_DIMENSION || height > MAX_CANVAS_DIMENSION || width * height > maxPixels) {
+    throw new ExtractionFailure("INVALID_PDF", "A PDF page exceeds the supported render dimensions.");
+  }
+  const canvas = createCanvas(width, height);
+  const context = canvas.getContext("2d");
+  context.fillStyle = "#ffffff";
+  context.fillRect(0, 0, width, height);
+  await page.render({
+    canvas,
+    canvasContext: context,
+    viewport,
+    intent: "display",
+    background: "#ffffff"
+  }).promise;
+  let pixels = null;
+  return {
+    width,
+    height,
+    appliedScale: scale,
+    rotation,
+    getPixels() {
+      pixels ??= context.getImageData(0, 0, width, height).data;
+      return pixels;
+    },
+    toPng() {
+      return canvas.toBuffer("image/png");
+    }
+  };
+}
+var MAX_CANVAS_DIMENSION;
+var init_render_page = __esm({
+  "src/pdf/render-page.ts"() {
+    "use strict";
+    init_errors();
+    MAX_CANVAS_DIMENSION = 32767;
+  }
+});
+
+// src/recognition/barcode-reader.ts
+var barcode_reader_exports = {};
+__export(barcode_reader_exports, {
+  readBarcodes: () => readBarcodes
+});
+function scanRegions(source, width, height) {
+  const regions = [source];
+  const lowerRegionTop = Math.floor(height * 0.45);
+  const rightRegionLeft = Math.floor(width * 0.45);
+  const crops = [
+    [0, 0, width, Math.min(height, Math.ceil(height * 0.55))],
+    [0, lowerRegionTop, width, height - lowerRegionTop],
+    [0, 0, Math.min(width, Math.ceil(width * 0.55)), height],
+    [rightRegionLeft, 0, width - rightRegionLeft, height]
+  ];
+  for (const [left, top, cropWidth, cropHeight] of crops) {
+    if (cropWidth >= 32 && cropHeight >= 32) {
+      regions.push(source.crop(left, top, cropWidth, cropHeight));
+    }
+  }
+  return regions;
+}
+function decodeBitmap(reader, bitmap, hints, source) {
+  try {
+    const result = reader.decode(bitmap, hints);
+    return {
+      text: result.getText(),
+      source
+    };
+  } catch {
+    return null;
+  } finally {
+    reader.reset();
+  }
+}
+async function readBarcodes(rendered) {
+  const { BarcodeFormat, BinaryBitmap, Code128Reader, DecodeHintType, HybridBinarizer, InvertedLuminanceSource, QRCodeReader, RGBLuminanceSource } = await import("@zxing/library");
+  const hints = /* @__PURE__ */ new Map();
+  hints.set(DecodeHintType.POSSIBLE_FORMATS, [BarcodeFormat.CODE_128, BarcodeFormat.QR_CODE]);
+  hints.set(DecodeHintType.TRY_HARDER, true);
+  const pixels = rendered.getPixels();
+  const luminance = new Uint8ClampedArray(rendered.width * rendered.height);
+  for (let pixel = 0, rgba = 0; pixel < luminance.length; pixel += 1, rgba += 4) {
+    const red = pixels[rgba] ?? 255;
+    const green = pixels[rgba + 1] ?? 255;
+    const blue = pixels[rgba + 2] ?? 255;
+    luminance[pixel] = (red + green * 2 + blue) / 4;
+  }
+  const source = new RGBLuminanceSource(luminance, rendered.width, rendered.height);
+  const attempts = [
+    { reader: new Code128Reader(), source: "code128" },
+    { reader: new QRCodeReader(), source: "qr-code" }
+  ];
+  const unique = /* @__PURE__ */ new Map();
+  const regions = scanRegions(source, rendered.width, rendered.height);
+  for (const [regionIndex, region] of regions.entries()) {
+    const candidateSources = [region];
+    if (regionIndex === 0) {
+      candidateSources.push(new InvertedLuminanceSource(region));
+    }
+    for (const attempt of attempts) {
+      for (const candidateSource of candidateSources) {
+        const result = decodeBitmap(attempt.reader, new BinaryBitmap(new HybridBinarizer(candidateSource)), hints, attempt.source);
+        if (result !== null) {
+          unique.set(`${result.source}:${result.text}`, result);
+        }
+      }
+    }
+  }
+  return [...unique.values()];
+}
+var init_barcode_reader = __esm({
+  "src/recognition/barcode-reader.ts"() {
+    "use strict";
+  }
+});
+
+// src/recognition/ocr-reader.ts
+var ocr_reader_exports = {};
+__export(ocr_reader_exports, {
+  createOcrSession: () => createOcrSession
+});
+async function createOcrSession() {
+  const [{ createWorker, OEM, PSM }, languageData] = await Promise.all([import("tesseract.js"), import("@tesseract.js-data/eng")]);
+  const worker = await createWorker("eng", OEM.LSTM_ONLY, {
+    langPath: languageData.default.langPath,
+    cacheMethod: "none",
+    gzip: true
+  });
+  try {
+    await worker.setParameters({
+      tessedit_char_whitelist: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
+      tessedit_pageseg_mode: PSM.SPARSE_TEXT,
+      preserve_interword_spaces: "1"
+    });
+  } catch (error) {
+    await worker.terminate().catch(() => void 0);
+    throw error;
+  }
+  return {
+    async recognize(image) {
+      const result = await worker.recognize(image);
+      return {
+        text: result.data.text,
+        confidence: result.data.confidence
+      };
+    },
+    async terminate() {
+      await worker.terminate();
+    }
+  };
+}
+var init_ocr_reader = __esm({
+  "src/recognition/ocr-reader.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACCESS_KEY_ISSUE_CODES: () => ACCESS_KEY_ISSUE_CODES,
+  calculateAccessKeyCheckDigit: () => calculateAccessKeyCheckDigit,
+  extractNFeAccessKeys: () => extractNFeAccessKeys,
+  parseAccessKey: () => parseAccessKey,
+  validateAccessKey: () => validateAccessKey,
+  validateIssuerIdentifier: () => validateIssuerIdentifier
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/extractor.ts
+var import_node_perf_hooks2 = require("perf_hooks");
+
+// src/validation/access-key.ts
+var NUMERIC_ACCESS_KEY_PATTERN = /^[0-9]{44}$/;
+var CURRENT_ACCESS_KEY_PATTERN = /^[0-9]{6}[A-Z0-9]{12}[0-9]{26}$/;
+var ACCESS_KEY_BODY_PATTERN = /^[0-9]{6}[A-Z0-9]{12}[0-9]{25}$/;
+var ISSUER_IDENTIFIER_PATTERN = /^[A-Z0-9]{12}[0-9]{2}$/;
+var ZERO_PADDED_CPF_PATTERN = /^000[0-9]{11}$/;
+var VALID_STATE_CODES = /* @__PURE__ */ new Set(["11", "12", "13", "14", "15", "16", "17", "21", "22", "23", "24", "25", "26", "27", "28", "29", "31", "32", "33", "35", "41", "42", "43", "50", "51", "52", "53"]);
+var VALID_MODELS = /* @__PURE__ */ new Set(["55", "65"]);
+var ACCESS_KEY_ISSUE_CODES = {
+  INVALID_FORMAT: "INVALID_FORMAT",
+  INVALID_CHECK_DIGIT: "INVALID_CHECK_DIGIT",
+  INVALID_MODEL: "INVALID_MODEL",
+  INVALID_STATE_CODE: "INVALID_STATE_CODE",
+  INVALID_MONTH: "INVALID_MONTH",
+  INVALID_ISSUER_IDENTIFIER: "INVALID_ISSUER_IDENTIFIER",
+  INVALID_INVOICE_NUMBER: "INVALID_INVOICE_NUMBER"
+};
+function normalizeAccessKey(value) {
+  return typeof value === "string" ? value.toUpperCase() : "";
+}
+function getAccessKeyFormat(value) {
+  if (NUMERIC_ACCESS_KEY_PATTERN.test(value)) {
+    return "numeric";
+  }
+  if (CURRENT_ACCESS_KEY_PATTERN.test(value)) {
+    return "alphanumeric";
+  }
+  return null;
+}
+function getDocumentType(model) {
+  if (model === "55") {
+    return "NFe";
+  }
+  if (model === "65") {
+    return "NFCe";
+  }
+  return null;
+}
+function calculateAsciiModulo11Digit(body) {
+  let sum = 0;
+  let weight = 2;
+  for (let index = body.length - 1; index >= 0; index -= 1) {
+    sum += (body.charCodeAt(index) - 48) * weight;
+    weight = weight === 9 ? 2 : weight + 1;
+  }
+  const remainder = sum % 11;
+  return remainder === 0 || remainder === 1 ? 0 : 11 - remainder;
+}
+function hasRepeatedCharacters(value) {
+  return value.length > 0 && new Set(value).size === 1;
+}
+function validateCnpj(value) {
+  const base = value.slice(0, 12);
+  if (hasRepeatedCharacters(base)) {
+    return false;
+  }
+  const firstCheckDigit = calculateAsciiModulo11Digit(base);
+  const secondCheckDigit = calculateAsciiModulo11Digit(`${base}${firstCheckDigit}`);
+  return value.slice(12) === `${firstCheckDigit}${secondCheckDigit}`;
+}
+function calculateCpfCheckDigit(body) {
+  let sum = 0;
+  for (let index = 0; index < body.length; index += 1) {
+    sum += (body.charCodeAt(index) - 48) * (body.length + 1 - index);
+  }
+  const remainder = sum % 11;
+  return remainder === 0 || remainder === 1 ? 0 : 11 - remainder;
+}
+function validateZeroPaddedCpf(value) {
+  if (!ZERO_PADDED_CPF_PATTERN.test(value)) {
+    return false;
+  }
+  const cpf = value.slice(3);
+  const base = cpf.slice(0, 9);
+  if (hasRepeatedCharacters(cpf) || hasRepeatedCharacters(base)) {
+    return false;
+  }
+  const firstCheckDigit = calculateCpfCheckDigit(base);
+  const secondCheckDigit = calculateCpfCheckDigit(`${base}${firstCheckDigit}`);
+  return cpf.slice(9) === `${firstCheckDigit}${secondCheckDigit}`;
+}
+function validateIssuerIdentifier(value) {
+  const normalizedValue = normalizeAccessKey(value);
+  if (!ISSUER_IDENTIFIER_PATTERN.test(normalizedValue)) {
+    return false;
+  }
+  return validateCnpj(normalizedValue) || validateZeroPaddedCpf(normalizedValue);
+}
+function calculateAccessKeyCheckDigit(body) {
+  const normalizedBody = normalizeAccessKey(body);
+  if (!ACCESS_KEY_BODY_PATTERN.test(normalizedBody)) {
+    throw new TypeError("Access key body must have 43 characters and match the supported access key format.");
+  }
+  return calculateAsciiModulo11Digit(normalizedBody);
+}
+function parseAccessKey(value) {
+  const normalizedValue = normalizeAccessKey(value);
+  const format = getAccessKeyFormat(normalizedValue);
+  if (format === null) {
+    throw new TypeError("Access key does not match a supported 44-character format.");
+  }
+  const model = normalizedValue.slice(20, 22);
+  const yearMonth = normalizedValue.slice(2, 6);
+  return {
+    accessKey: normalizedValue,
+    format,
+    stateCode: normalizedValue.slice(0, 2),
+    yearMonth,
+    year: yearMonth.slice(0, 2),
+    month: yearMonth.slice(2, 4),
+    issuerId: normalizedValue.slice(6, 20),
+    model,
+    documentType: getDocumentType(model),
+    series: normalizedValue.slice(22, 25),
+    invoiceNumber: normalizedValue.slice(25, 34),
+    emissionType: normalizedValue.slice(34, 35),
+    numericCode: normalizedValue.slice(35, 43),
+    checkDigit: Number(normalizedValue[43])
+  };
+}
+function validateAccessKey(value) {
+  const normalizedValue = normalizeAccessKey(value);
+  const format = getAccessKeyFormat(normalizedValue);
+  if (format === null) {
+    return {
+      isValid: false,
+      normalizedValue,
+      format: null,
+      components: null,
+      expectedCheckDigit: null,
+      issues: [
+        {
+          code: ACCESS_KEY_ISSUE_CODES.INVALID_FORMAT,
+          message: "Access key does not match a supported 44-character format."
+        }
+      ]
+    };
+  }
+  const components = parseAccessKey(normalizedValue);
+  const expectedCheckDigit = calculateAccessKeyCheckDigit(normalizedValue.slice(0, 43));
+  const issues = [];
+  if (!VALID_STATE_CODES.has(components.stateCode)) {
+    issues.push({
+      code: ACCESS_KEY_ISSUE_CODES.INVALID_STATE_CODE,
+      message: `State code ${components.stateCode} is not an official IBGE UF code.`
+    });
+  }
+  const month = Number(components.month);
+  if (month < 1 || month > 12) {
+    issues.push({
+      code: ACCESS_KEY_ISSUE_CODES.INVALID_MONTH,
+      message: `Month ${components.month} must be between 01 and 12.`
+    });
+  }
+  if (!VALID_MODELS.has(components.model)) {
+    issues.push({
+      code: ACCESS_KEY_ISSUE_CODES.INVALID_MODEL,
+      message: `Model ${components.model} is not supported; expected 55 or 65.`
+    });
+  }
+  if (components.invoiceNumber === "000000000") {
+    issues.push({
+      code: ACCESS_KEY_ISSUE_CODES.INVALID_INVOICE_NUMBER,
+      message: "Invoice number must be between 000000001 and 999999999."
+    });
+  }
+  if (!validateIssuerIdentifier(components.issuerId)) {
+    issues.push({
+      code: ACCESS_KEY_ISSUE_CODES.INVALID_ISSUER_IDENTIFIER,
+      message: `Issuer identifier ${components.issuerId} is not a valid CNPJ or zero-padded CPF.`
+    });
+  }
+  if (components.checkDigit !== expectedCheckDigit) {
+    issues.push({
+      code: ACCESS_KEY_ISSUE_CODES.INVALID_CHECK_DIGIT,
+      message: `Check digit ${components.checkDigit} does not match expected digit ${expectedCheckDigit}.`
+    });
+  }
+  return {
+    isValid: issues.length === 0,
+    normalizedValue,
+    format,
+    components,
+    expectedCheckDigit,
+    issues
+  };
+}
+
+// src/candidates/from-text.ts
+var ACCESS_KEY_PATTERN = /[0-9]{6}[A-Z0-9]{12}[0-9]{26}/g;
+var SEPARATOR_PATTERN = /[\s.\-_/]/;
+var ALPHANUMERIC_PATTERN = /[A-Z0-9]/;
+var LABEL_PATTERN = /CHAVE\s+DE\s+ACESSO|ACCESS\s+KEY/;
+function normalizedText(value) {
+  return value.normalize("NFKC").replace(/\u00a0/g, " ").toUpperCase();
+}
+function isNearLabel(text, start) {
+  const context = text.slice(Math.max(0, start - 120), start + 12);
+  return LABEL_PATTERN.test(context);
+}
+function addIfValid(output, seen, accessKey, page, source, pass, nearLabel) {
+  const validation = validateAccessKey(accessKey);
+  const signature = `${accessKey}:${source}:${pass}:${nearLabel}`;
+  if (!validation.isValid || seen.has(signature)) {
+    return;
+  }
+  seen.add(signature);
+  output.push({ accessKey, page, source, pass, nearLabel });
+}
+function findCandidatesInText(text, page) {
+  const normalized = normalizedText(text);
+  const output = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of normalized.matchAll(ACCESS_KEY_PATTERN)) {
+    const accessKey = match[0];
+    const start = match.index;
+    const before = start > 0 ? normalized[start - 1] : void 0;
+    const after = normalized[start + accessKey.length];
+    if (before !== void 0 && ALPHANUMERIC_PATTERN.test(before) || after !== void 0 && ALPHANUMERIC_PATTERN.test(after)) {
+      continue;
+    }
+    addIfValid(output, seen, accessKey, page, "pdf-text", 0, isNearLabel(normalized, start));
+  }
+  for (let start = 0; start < normalized.length; start += 1) {
+    const first = normalized[start];
+    if (first === void 0 || !/[0-9]/.test(first)) {
+      continue;
+    }
+    let accessKey = "";
+    let cursor = start;
+    let hadSeparator = false;
+    while (cursor < normalized.length && cursor - start <= 100) {
+      const character = normalized[cursor];
+      if (character === void 0) {
+        break;
+      }
+      if (ALPHANUMERIC_PATTERN.test(character)) {
+        accessKey += character;
+      } else if (SEPARATOR_PATTERN.test(character)) {
+        hadSeparator = true;
+      } else {
+        break;
+      }
+      cursor += 1;
+      if (accessKey.length === 44) {
+        const nearLabel = isNearLabel(normalized, start);
+        const rawSpan = normalized.slice(start, cursor);
+        let lookahead = cursor;
+        while (SEPARATOR_PATTERN.test(normalized[lookahead] ?? "")) {
+          lookahead += 1;
+        }
+        const likelyLongerNumericCluster = /[0-9]/.test(normalized[lookahead] ?? "") && !nearLabel;
+        const crossesLinesWithoutContext = rawSpan.includes("\n") && !nearLabel;
+        if (hadSeparator && !likelyLongerNumericCluster && !crossesLinesWithoutContext) {
+          addIfValid(output, seen, accessKey, page, "pdf-text-reconstructed", 0, nearLabel);
+        }
+        break;
+      }
+      if (accessKey.length > 44) {
+        break;
+      }
+    }
+  }
+  return output;
+}
+function findCandidatesInDecodedValue(value, page, source, pass) {
+  let decoded = normalizedText(value);
+  try {
+    decoded = decodeURIComponent(decoded);
+  } catch {
+  }
+  const output = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const match of decoded.matchAll(ACCESS_KEY_PATTERN)) {
+    addIfValid(output, seen, match[0], page, source, pass, true);
+  }
+  return output;
+}
+
+// src/candidates/from-ocr.ts
+var OCR_CLUSTER = /[A-Z0-9](?:[\s.\-_/]*[A-Z0-9]){43}/g;
+var OCR_TO_DIGIT = {
+  O: "0",
+  Q: "0",
+  D: "0",
+  I: "1",
+  L: "1",
+  Z: "2",
+  S: "5",
+  G: "6",
+  B: "8"
+};
+var DIGIT_TO_OCR_LETTERS = {
+  "0": ["O", "Q", "D"],
+  "1": ["I", "L"],
+  "2": ["Z"],
+  "5": ["S"],
+  "6": ["G"],
+  "8": ["B"]
+};
+function correctedAlternatives(raw) {
+  const characters = raw.match(/[A-Z0-9]/g);
+  if (characters === null || characters.length !== 44) {
+    return [];
+  }
+  let corrections = 0;
+  const issuerAlternatives = [];
+  for (let index = 0; index < characters.length; index += 1) {
+    const character = characters[index];
+    if (character === void 0) {
+      continue;
+    }
+    const isAlphanumericIssuerPosition = index >= 6 && index < 18;
+    if (/[0-9]/.test(character)) {
+      if (isAlphanumericIssuerPosition) {
+        for (const letter of DIGIT_TO_OCR_LETTERS[character] ?? []) {
+          issuerAlternatives.push({ index, replacement: letter });
+        }
+      }
+      continue;
+    }
+    if (isAlphanumericIssuerPosition) {
+      const digit = OCR_TO_DIGIT[character];
+      if (digit !== void 0) {
+        issuerAlternatives.push({ index, replacement: digit });
+      }
+      continue;
+    }
+    const corrected = OCR_TO_DIGIT[character];
+    if (corrected === void 0) {
+      return [];
+    }
+    characters[index] = corrected;
+    corrections += 1;
+  }
+  if (corrections > 1) {
+    return [];
+  }
+  const uncorrectedValue = characters.join("");
+  const alternatives = [{ value: uncorrectedValue, corrections }];
+  if (corrections === 0 && !validateAccessKey(uncorrectedValue).isValid) {
+    for (const { index, replacement } of issuerAlternatives) {
+      const corrected = [...characters];
+      corrected[index] = replacement;
+      alternatives.push({ value: corrected.join(""), corrections: 1 });
+    }
+  }
+  return alternatives;
+}
+function findCandidatesInOcrText(text, page, pass, confidence) {
+  const normalized = text.normalize("NFKC").toUpperCase();
+  const exact = findCandidatesInText(normalized, page).map((candidate) => ({
+    ...candidate,
+    source: "ocr",
+    pass,
+    ocrConfidence: confidence
+  }));
+  const output = [...exact];
+  const seen = new Set(exact.map((candidate) => candidate.accessKey));
+  for (const match of normalized.matchAll(OCR_CLUSTER)) {
+    for (const corrected of correctedAlternatives(match[0])) {
+      if (corrected.corrections === 0 || seen.has(corrected.value) || !validateAccessKey(corrected.value).isValid) {
+        continue;
+      }
+      seen.add(corrected.value);
+      output.push({
+        accessKey: corrected.value,
+        page,
+        source: "ocr",
+        pass,
+        nearLabel: false,
+        ocrConfidence: confidence,
+        corrections: corrected.corrections
+      });
+    }
+  }
+  return output;
+}
+
+// src/deadline.ts
+var import_node_perf_hooks = require("perf_hooks");
+init_errors();
+var WorkGuard = class {
+  #startedAt;
+  #options;
+  #controller = new AbortController();
+  #abortListener;
+  #timeout;
+  #stopReason = null;
+  constructor(options, startedAt = import_node_perf_hooks.performance.now()) {
+    this.#options = options;
+    this.#startedAt = startedAt;
+    if (options.signal?.aborted === true) {
+      this.#stop("aborted");
+    } else if (options.signal !== void 0) {
+      this.#abortListener = () => {
+        this.#stop("aborted");
+      };
+      options.signal.addEventListener("abort", this.#abortListener, { once: true });
+    }
+    if (options.timeoutMs > 0 && this.#stopReason === null) {
+      const elapsed = import_node_perf_hooks.performance.now() - this.#startedAt;
+      this.#timeout = setTimeout(
+        () => {
+          this.#stop("timeout");
+        },
+        Math.max(0, options.timeoutMs - elapsed)
+      );
+      this.#timeout.unref();
+    }
+  }
+  get signal() {
+    return this.#controller.signal;
+  }
+  check() {
+    if (this.#options.signal?.aborted === true || this.#stopReason === "aborted") {
+      this.#stop("aborted");
+      throw new ExtractionFailure("ABORTED", "Extraction was aborted.");
+    }
+    if (this.#stopReason === "timeout" || this.#options.timeoutMs > 0 && import_node_perf_hooks.performance.now() - this.#startedAt >= this.#options.timeoutMs) {
+      this.#stop("timeout");
+      throw new ExtractionFailure("TIMEOUT", "Extraction exceeded its configured deadline.");
+    }
+  }
+  dispose() {
+    if (this.#timeout !== void 0) {
+      clearTimeout(this.#timeout);
+    }
+    if (this.#abortListener !== void 0 && this.#options.signal !== void 0) {
+      this.#options.signal.removeEventListener("abort", this.#abortListener);
+    }
+  }
+  #stop(reason) {
+    if (this.#stopReason !== null) {
+      return;
+    }
+    this.#stopReason = reason;
+    this.#controller.abort();
+  }
+};
+
+// src/extractor.ts
+init_errors();
+
+// src/options.ts
+var import_node_http = require("http");
+var MEBIBYTE = 1024 * 1024;
+var BLOCKED_REQUEST_HEADERS = /* @__PURE__ */ new Set(["accept-encoding", "connection", "content-length", "expect", "host", "if-range", "keep-alive", "proxy-connection", "range", "te", "trailer", "transfer-encoding", "upgrade"]);
+var PROFILE_DEFAULTS = {
+  fast: {
+    passes: 1,
+    ocr: "never",
+    maxPages: 10,
+    maxPixelsPerPage: 8e6,
+    maxSourceImagePixels: 4e7,
+    timeoutMs: 3e4
+  },
+  balanced: {
+    passes: 2,
+    ocr: "fallback",
+    maxPages: 30,
+    maxPixelsPerPage: 12e6,
+    maxSourceImagePixels: 6e7,
+    timeoutMs: 12e4
+  },
+  accurate: {
+    passes: 3,
+    ocr: "fallback",
+    maxPages: 50,
+    maxPixelsPerPage: 2e7,
+    maxSourceImagePixels: 1e8,
+    timeoutMs: 3e5
+  }
+};
+var InvalidOptionsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidOptionsError";
+  }
+};
+function integerInRange(name, value, fallback, minimum, maximum) {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved < minimum || resolved > maximum) {
+    throw new InvalidOptionsError(`${name} must be an integer between ${minimum} and ${maximum}.`);
+  }
+  return resolved;
+}
+function normalizeRequestHeaders(requestHeaders) {
+  if (requestHeaders === void 0) {
+    return void 0;
+  }
+  if (typeof requestHeaders !== "object" || requestHeaders === null || Array.isArray(requestHeaders)) {
+    throw new InvalidOptionsError("requestHeaders must be a record of strings.");
+  }
+  let prototype;
+  try {
+    prototype = Object.getPrototypeOf(requestHeaders);
+  } catch {
+    throw new InvalidOptionsError("requestHeaders could not be read.");
+  }
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new InvalidOptionsError("requestHeaders must be a record of strings.");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  let entries;
+  try {
+    entries = Object.entries(requestHeaders);
+  } catch {
+    throw new InvalidOptionsError("requestHeaders could not be read.");
+  }
+  for (const [name, value] of entries) {
+    const normalizedName = name.toLowerCase();
+    if (typeof value !== "string") {
+      throw new InvalidOptionsError("Every requestHeaders value must be a string.");
+    }
+    try {
+      (0, import_node_http.validateHeaderName)(name);
+      (0, import_node_http.validateHeaderValue)(name, value);
+    } catch {
+      throw new InvalidOptionsError("requestHeaders contains an invalid header.");
+    }
+    if (BLOCKED_REQUEST_HEADERS.has(normalizedName)) {
+      throw new InvalidOptionsError("requestHeaders contains a header that cannot be overridden.");
+    }
+    if (Object.hasOwn(normalized, normalizedName)) {
+      throw new InvalidOptionsError("requestHeaders contains duplicate case-insensitive names.");
+    }
+    normalized[normalizedName] = value;
+  }
+  return Object.freeze(normalized);
+}
+function resolveOptions(options = {}) {
+  const performance3 = options.performance ?? "balanced";
+  if (!Object.hasOwn(PROFILE_DEFAULTS, performance3)) {
+    throw new InvalidOptionsError("performance must be fast, balanced, or accurate.");
+  }
+  const profile = PROFILE_DEFAULTS[performance3];
+  const ocr = options.ocr ?? profile.ocr;
+  if (!["never", "fallback", "always"].includes(ocr)) {
+    throw new InvalidOptionsError("ocr must be never, fallback, or always.");
+  }
+  const requestHeaders = normalizeRequestHeaders(options.requestHeaders);
+  return {
+    performance: performance3,
+    passes: integerInRange("passes", options.passes, profile.passes, 1, 5),
+    ocr,
+    maxPages: integerInRange("maxPages", options.maxPages, profile.maxPages, 1, 1e4),
+    maxFileSizeBytes: integerInRange("maxFileSizeBytes", options.maxFileSizeBytes, 30 * MEBIBYTE, 1, 1024 * MEBIBYTE),
+    maxPixelsPerPage: integerInRange("maxPixelsPerPage", options.maxPixelsPerPage, profile.maxPixelsPerPage, 25e4, 1e8),
+    maxSourceImagePixels: integerInRange("maxSourceImagePixels", options.maxSourceImagePixels, profile.maxSourceImagePixels, 25e4, 2e8),
+    timeoutMs: integerInRange("timeoutMs", options.timeoutMs, profile.timeoutMs, 0, 36e5),
+    stopAfterFirst: options.stopAfterFirst ?? false,
+    ...requestHeaders === void 0 ? {} : { requestHeaders },
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  };
+}
+var RECIPES = {
+  fast: [
+    { scale: 1.25, rotation: 0 },
+    { scale: 1.6, rotation: 0 },
+    { scale: 2, rotation: 0 },
+    { scale: 1.6, rotation: 90 },
+    { scale: 1.6, rotation: 270 }
+  ],
+  balanced: [
+    { scale: 1.5, rotation: 0 },
+    { scale: 2, rotation: 0 },
+    { scale: 2.5, rotation: 0 },
+    { scale: 2, rotation: 90 },
+    { scale: 2, rotation: 270 }
+  ],
+  accurate: [
+    { scale: 1.75, rotation: 0 },
+    { scale: 2.25, rotation: 0 },
+    { scale: 3, rotation: 0 },
+    { scale: 2.25, rotation: 90 },
+    { scale: 2.25, rotation: 270 }
+  ]
+};
+function getRenderRecipes(options) {
+  return RECIPES[options.performance].slice(0, options.passes);
+}
+
+// src/pdf/extract-text.ts
+init_errors();
+var MAX_TEXT_ITEMS_PER_PAGE = 5e4;
+var MAX_TEXT_CHARACTERS_PER_PAGE = 25e4;
+function isTextItem(value) {
+  return typeof value === "object" && value !== null && "str" in value && typeof value.str === "string";
+}
+function positionedItem(item) {
+  const transform = item.transform ?? [];
+  return {
+    str: item.str,
+    x: transform[4] ?? 0,
+    y: transform[5] ?? 0,
+    width: item.width ?? 0,
+    height: Math.abs(item.height ?? transform[3] ?? 10),
+    hasEOL: item.hasEOL ?? false
+  };
+}
+function reconstructLines(items) {
+  const sorted = [...items].sort((left, right) => right.y - left.y || left.x - right.x);
+  const lines = [];
+  for (const item of sorted) {
+    const line = lines.at(-1);
+    if (line === void 0 || Math.abs(line.y - item.y) > Math.max(2, item.height * 0.45)) {
+      lines.push({ y: item.y, height: item.height, items: [item] });
+    } else {
+      line.items.push(item);
+      line.height = Math.max(line.height, item.height);
+    }
+  }
+  return lines.sort((left, right) => right.y - left.y).map((line) => {
+    const lineItems = line.items.sort((left, right) => left.x - right.x);
+    let text = "";
+    let rightEdge = null;
+    for (const item of lineItems) {
+      if (rightEdge !== null && item.x - rightEdge > Math.max(0.75, line.height * 0.08)) {
+        text += " ";
+      }
+      text += item.str;
+      rightEdge = item.x + item.width;
+    }
+    return text.trim();
+  }).filter((line) => line.length > 0);
+}
+async function extractPageText(page) {
+  const content = await page.getTextContent();
+  if (content.items.length > MAX_TEXT_ITEMS_PER_PAGE) {
+    throw new ExtractionFailure("RESOURCE_LIMIT", "A PDF page contains too many text items to process safely.");
+  }
+  const items = [];
+  let characterCount = 0;
+  for (const value of content.items) {
+    if (!isTextItem(value)) {
+      continue;
+    }
+    characterCount += value.str.length;
+    if (characterCount > MAX_TEXT_CHARACTERS_PER_PAGE) {
+      throw new ExtractionFailure("RESOURCE_LIMIT", "A PDF page contains too much text to process safely.");
+    }
+    items.push(positionedItem(value));
+  }
+  const orderedText = items.map((item) => `${item.str}${item.hasEOL ? "\n" : " "}`).join("").trim();
+  const visualLines = reconstructLines(items);
+  return {
+    orderedText,
+    visualLines,
+    hasText: items.some((item) => item.str.trim().length > 0)
+  };
+}
+
+// src/pdf/load-input.ts
+var import_promises = require("fs/promises");
+init_errors();
+var MAX_REDIRECTS = 5;
+var INITIAL_DOWNLOAD_BUFFER_BYTES = 64 * 1024;
+var MAX_INITIAL_CONTENT_LENGTH_ALLOCATION = 1024 * 1024;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var CREDENTIAL_HEADERS = ["authorization", "cookie", "proxy-authorization"];
+var WINDOWS_DRIVE_PATH = /^[a-z]:/i;
+var HTTP_URL = /^https?:\/\//i;
+var URI_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+function hasPdfSignature(data) {
+  const prefix = Buffer.from(data.buffer, data.byteOffset, Math.min(data.byteLength, 1024));
+  return prefix.indexOf("%PDF-") >= 0;
+}
+function validatePdfBytes(data, maxFileSizeBytes) {
+  if (data.byteLength === 0) {
+    throw new ExtractionFailure("INVALID_INPUT", "The PDF input is empty.");
+  }
+  if (data.byteLength > maxFileSizeBytes) {
+    throw new ExtractionFailure("FILE_TOO_LARGE", `The PDF exceeds the configured ${maxFileSizeBytes}-byte limit.`);
+  }
+  if (!hasPdfSignature(data)) {
+    throw new ExtractionFailure("INVALID_PDF", "The input does not contain a PDF signature.");
+  }
+}
+function checkedBytes(data, maxFileSizeBytes) {
+  validatePdfBytes(data, maxFileSizeBytes);
+  const bytes = new Uint8Array(data.byteLength);
+  bytes.set(data);
+  return { data: bytes, size: data.byteLength };
+}
+function checkedRemoteUrl(url) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new ExtractionFailure("INVALID_INPUT", "Only HTTP and HTTPS remote URLs are accepted.");
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new ExtractionFailure("INVALID_INPUT", "URL credentials are not accepted; use requestHeaders instead.");
+  }
+  return url;
+}
+function remoteUrlFromInput(input) {
+  const value = input.trim();
+  if (value === "") {
+    throw new ExtractionFailure("INVALID_INPUT", "A non-empty PDF path or HTTP(S) URL is required.");
+  }
+  if (WINDOWS_DRIVE_PATH.test(value)) {
+    return null;
+  }
+  if (!HTTP_URL.test(value)) {
+    if (URI_SCHEME.test(value)) {
+      throw new ExtractionFailure("INVALID_INPUT", "Only complete HTTP and HTTPS remote URLs are accepted.");
+    }
+    return null;
+  }
+  try {
+    return checkedRemoteUrl(new URL(value));
+  } catch (error) {
+    if (error instanceof ExtractionFailure) {
+      throw error;
+    }
+    throw new ExtractionFailure("INVALID_INPUT", "The remote URL is invalid.", {
+      cause: error
+    });
+  }
+}
+function remoteHeaders(requestHeaders) {
+  try {
+    const headers = new Headers(requestHeaders === void 0 ? void 0 : Object.entries(requestHeaders));
+    headers.set("accept-encoding", "identity");
+    return headers;
+  } catch (error) {
+    throw new ExtractionFailure("INVALID_OPTIONS", "requestHeaders contains an invalid header.", { cause: error });
+  }
+}
+function stripRedirectCredentials(headers) {
+  for (const name of CREDENTIAL_HEADERS) {
+    headers.delete(name);
+  }
+}
+function cancelResponse(response) {
+  void response.body?.cancel().catch(() => void 0);
+}
+function cancelReader(reader) {
+  void reader.cancel().catch(() => void 0);
+}
+function advertisedSize(response) {
+  const value = response.headers.get("content-length")?.trim();
+  if (value === void 0 || !/^\d+$/.test(value)) {
+    return null;
+  }
+  try {
+    return BigInt(value);
+  } catch {
+    return null;
+  }
+}
+async function readRemoteBody(response, maxFileSizeBytes, signal) {
+  const size = advertisedSize(response);
+  if (size !== null && size > BigInt(maxFileSizeBytes)) {
+    cancelResponse(response);
+    throw new ExtractionFailure("FILE_TOO_LARGE", `The PDF exceeds the configured ${maxFileSizeBytes}-byte limit.`);
+  }
+  if (response.body === null) {
+    throw new ExtractionFailure("DOWNLOAD_ERROR", "The remote PDF response did not contain a body.");
+  }
+  const advertisedInitialSize = size === null ? INITIAL_DOWNLOAD_BUFFER_BYTES : Math.min(Number(size), MAX_INITIAL_CONTENT_LENGTH_ALLOCATION);
+  let data;
+  try {
+    data = new Uint8Array(Math.min(maxFileSizeBytes, advertisedInitialSize));
+  } catch (error) {
+    await cancelResponse(response);
+    throw new ExtractionFailure("RESOURCE_LIMIT", "The remote PDF could not be buffered within available memory.", { cause: error });
+  }
+  let reader;
+  try {
+    reader = response.body.getReader();
+  } catch (error) {
+    throw new ExtractionFailure("DOWNLOAD_ERROR", "The remote PDF response could not be read.", { cause: error });
+  }
+  let total = 0;
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        break;
+      }
+      if (chunk.value === void 0) {
+        continue;
+      }
+      const requiredSize = total + chunk.value.byteLength;
+      if (requiredSize > maxFileSizeBytes) {
+        cancelReader(reader);
+        throw new ExtractionFailure("FILE_TOO_LARGE", `The PDF exceeds the configured ${maxFileSizeBytes}-byte limit.`);
+      }
+      if (requiredSize > data.byteLength) {
+        const doubledSize = data.byteLength === 0 ? INITIAL_DOWNLOAD_BUFFER_BYTES : data.byteLength * 2;
+        const expanded = new Uint8Array(Math.min(maxFileSizeBytes, Math.max(requiredSize, doubledSize)));
+        expanded.set(data.subarray(0, total));
+        data = expanded;
+      }
+      data.set(chunk.value, total);
+      total = requiredSize;
+    }
+  } catch (error) {
+    if (error instanceof ExtractionFailure || signal?.aborted === true) {
+      throw error;
+    }
+    if (error instanceof RangeError) {
+      cancelReader(reader);
+      throw new ExtractionFailure("RESOURCE_LIMIT", "The remote PDF could not be buffered within available memory.", { cause: error });
+    }
+    throw new ExtractionFailure("DOWNLOAD_ERROR", "The remote PDF response could not be read.", { cause: error });
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+  const bytes = data.subarray(0, total);
+  validatePdfBytes(bytes, maxFileSizeBytes);
+  return { data: bytes, size: total };
+}
+async function downloadPdf(initialUrl, maxFileSizeBytes, controls) {
+  let currentUrl = initialUrl;
+  const headers = remoteHeaders(controls.requestHeaders);
+  let redirects = 0;
+  while (true) {
+    let response;
+    try {
+      response = await fetch(currentUrl, {
+        method: "GET",
+        headers,
+        redirect: "manual",
+        ...controls.signal === void 0 ? {} : { signal: controls.signal }
+      });
+    } catch (error) {
+      if (controls.signal?.aborted === true) {
+        throw error;
+      }
+      throw new ExtractionFailure("DOWNLOAD_ERROR", "The remote PDF could not be downloaded.", { cause: error });
+    }
+    if (REDIRECT_STATUSES.has(response.status)) {
+      const location = response.headers.get("location");
+      cancelResponse(response);
+      if (redirects >= MAX_REDIRECTS) {
+        throw new ExtractionFailure("DOWNLOAD_ERROR", `The remote PDF exceeded the ${MAX_REDIRECTS}-redirect limit.`);
+      }
+      if (location === null) {
+        throw new ExtractionFailure("DOWNLOAD_ERROR", "The remote PDF returned a redirect without a destination.");
+      }
+      let nextUrl;
+      try {
+        nextUrl = checkedRemoteUrl(new URL(location, currentUrl));
+      } catch (error) {
+        throw new ExtractionFailure("DOWNLOAD_ERROR", "The remote PDF returned an invalid redirect destination.", { cause: error });
+      }
+      if (nextUrl.origin !== currentUrl.origin || currentUrl.protocol === "https:" && nextUrl.protocol === "http:") {
+        stripRedirectCredentials(headers);
+      }
+      currentUrl = nextUrl;
+      redirects += 1;
+      continue;
+    }
+    if (!response.ok) {
+      const status = response.status;
+      cancelResponse(response);
+      throw new ExtractionFailure("DOWNLOAD_ERROR", `The remote PDF request returned HTTP status ${status}.`);
+    }
+    return readRemoteBody(response, maxFileSizeBytes, controls.signal);
+  }
+}
+async function loadPdfInput(input, maxFileSizeBytes, controls = {}) {
+  if (typeof input === "string") {
+    const remoteUrl = remoteUrlFromInput(input);
+    if (remoteUrl !== null) {
+      return downloadPdf(remoteUrl, maxFileSizeBytes, controls);
+    }
+    if (controls.requestHeaders !== void 0) {
+      throw new ExtractionFailure("INVALID_OPTIONS", "requestHeaders can only be used with an HTTP(S) URL input.");
+    }
+    try {
+      const file = await (0, import_promises.stat)(input);
+      if (!file.isFile()) {
+        throw new ExtractionFailure("INVALID_INPUT", "The supplied path is not a file.");
+      }
+      if (file.size > maxFileSizeBytes) {
+        throw new ExtractionFailure("FILE_TOO_LARGE", `The PDF exceeds the configured ${maxFileSizeBytes}-byte limit.`);
+      }
+      return checkedBytes(await (0, import_promises.readFile)(input), maxFileSizeBytes);
+    } catch (error) {
+      if (error instanceof ExtractionFailure) {
+        throw error;
+      }
+      const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+      if (code === "ENOENT") {
+        throw new ExtractionFailure("FILE_NOT_FOUND", "The PDF file was not found.", {
+          cause: error
+        });
+      }
+      throw new ExtractionFailure("INVALID_INPUT", "The PDF file could not be read.", {
+        cause: error
+      });
+    }
+  }
+  if (controls.requestHeaders !== void 0) {
+    throw new ExtractionFailure("INVALID_OPTIONS", "requestHeaders can only be used with an HTTP(S) URL input.");
+  }
+  if (input instanceof Uint8Array) {
+    return checkedBytes(input, maxFileSizeBytes);
+  }
+  if (input instanceof ArrayBuffer) {
+    return checkedBytes(new Uint8Array(input), maxFileSizeBytes);
+  }
+  throw new ExtractionFailure("INVALID_INPUT", "Input must be a local path, HTTP(S) URL, ArrayBuffer, Buffer, or Uint8Array.");
+}
+
+// src/pdf/open-document.ts
+init_errors();
+async function installCanvasGlobals() {
+  const canvas = await import("@napi-rs/canvas");
+  const target = globalThis;
+  target["DOMMatrix"] ??= canvas.DOMMatrix;
+  target["ImageData"] ??= canvas.ImageData;
+  target["Path2D"] ??= canvas.Path2D;
+}
+async function openPdfDocument(data, maxSourceImagePixels, maxCanvasPixels) {
+  await installCanvasGlobals();
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const loadingTask = pdfjs.getDocument({
+    data,
+    isEvalSupported: false,
+    maxImageSize: maxSourceImagePixels,
+    canvasMaxAreaInBytes: maxCanvasPixels * 4,
+    useSystemFonts: true,
+    stopAtErrors: false,
+    verbosity: 0
+  });
+  try {
+    const document = await loadingTask.promise;
+    return {
+      document,
+      async close() {
+        await loadingTask.destroy();
+      }
+    };
+  } catch (error) {
+    await loadingTask.destroy().catch(() => void 0);
+    const name = error instanceof Error ? error.name : "";
+    const message = messageFromUnknown(error);
+    if (name === "PasswordException" || /password/i.test(message)) {
+      throw new ExtractionFailure("PASSWORD_REQUIRED", "The PDF is encrypted and requires a password.", { cause: error });
+    }
+    throw new ExtractionFailure("INVALID_PDF", "The PDF could not be parsed.", {
+      cause: error
+    });
+  }
+}
+
+// src/scoring/merge-results.ts
+var SOURCE_BASE_SCORE = {
+  "qr-code": 0.995,
+  code128: 0.995,
+  "pdf-text": 0.985,
+  "pdf-text-reconstructed": 0.97,
+  ocr: 0.82
+};
+var SOURCE_ORDER = ["qr-code", "code128", "pdf-text", "pdf-text-reconstructed", "ocr"];
+function evidenceScore(evidence) {
+  let score = SOURCE_BASE_SCORE[evidence.source];
+  if (evidence.source === "ocr") {
+    const ocrConfidence = Math.max(0, Math.min(100, evidence.ocrConfidence ?? 0));
+    score = Math.max(0.75, 0.72 + ocrConfidence / 100 * 0.2);
+    if (evidence.nearLabel) {
+      score += 0.04;
+    }
+    score -= (evidence.corrections ?? 0) * 0.1;
+  }
+  if (evidence.nearLabel && evidence.source.startsWith("pdf-text")) {
+    score += 5e-3;
+  }
+  return Math.max(0, Math.min(0.995, score));
+}
+function independentFamilies(sources) {
+  let families = 0;
+  if ([...sources].some((source) => source.startsWith("pdf-text"))) {
+    families += 1;
+  }
+  if (sources.has("code128") || sources.has("qr-code")) {
+    families += 1;
+  }
+  if (sources.has("ocr")) {
+    families += 1;
+  }
+  return families;
+}
+function mergeEvidence(evidence) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    const current = grouped.get(item.accessKey) ?? [];
+    current.push(item);
+    grouped.set(item.accessKey, current);
+  }
+  const results = [];
+  for (const [accessKey, items] of grouped) {
+    const validation = validateAccessKey(accessKey);
+    const components = validation.components;
+    if (!validation.isValid || components?.documentType === null || components === null) {
+      continue;
+    }
+    const sources = new Set(items.map((item) => item.source));
+    const pages = [...new Set(items.map((item) => item.page))].sort((a, b) => a - b);
+    let precisionScore = Math.max(...items.map(evidenceScore));
+    if (independentFamilies(sources) > 1) {
+      precisionScore = Math.min(0.999, precisionScore + 4e-3);
+    }
+    results.push({
+      accessKey,
+      documentType: components.documentType,
+      model: components.model,
+      format: components.format,
+      isValid: true,
+      precisionScore: Number(precisionScore.toFixed(3)),
+      pages,
+      sources: SOURCE_ORDER.filter((source) => sources.has(source)),
+      occurrences: items.length,
+      components
+    });
+  }
+  return results.sort((left, right) => {
+    if (right.precisionScore !== left.precisionScore) {
+      return right.precisionScore - left.precisionScore;
+    }
+    return left.pages[0] - right.pages[0];
+  });
+}
+
+// src/extractor.ts
+function emptyState() {
+  return {
+    evidence: [],
+    warnings: [],
+    pagesTotal: 0,
+    pagesProcessed: 0,
+    renderedPages: /* @__PURE__ */ new Set(),
+    ocrPages: /* @__PURE__ */ new Set(),
+    passesUsed: 0,
+    fileSizeBytes: 0,
+    complete: true
+  };
+}
+function textEvidence(pageText, page) {
+  const candidates = [...findCandidatesInText(pageText.orderedText, page), ...findCandidatesInText(pageText.visualLines.join("\n"), page)];
+  const unique = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const signature = `${candidate.accessKey}:${candidate.source}`;
+    const current = unique.get(signature);
+    if (current === void 0 || !current.nearLabel && candidate.nearLabel) {
+      unique.set(signature, candidate);
+    }
+  }
+  return [...unique.values()];
+}
+function hasPageEvidence(evidence, page) {
+  return evidence.some((candidate) => candidate.page === page);
+}
+function metadata(options, state, startedAt) {
+  return {
+    performance: options.performance,
+    ocrMode: options.ocr,
+    passesRequested: options.passes,
+    passesUsed: state.passesUsed,
+    pagesTotal: state.pagesTotal,
+    pagesProcessed: state.pagesProcessed,
+    pagesRendered: state.renderedPages.size,
+    ocrPages: state.ocrPages.size,
+    fileSizeBytes: state.fileSizeBytes,
+    maxPixelsPerPage: options.maxPixelsPerPage,
+    maxSourceImagePixels: options.maxSourceImagePixels,
+    durationMs: Number((import_node_perf_hooks2.performance.now() - startedAt).toFixed(2)),
+    complete: state.complete,
+    confidenceVersion: "1.0.0"
+  };
+}
+function resultFromState(options, state, startedAt, error = null) {
+  const results = mergeEvidence(state.evidence);
+  let status;
+  if (error !== null) {
+    status = results.length > 0 ? "partial" : "error";
+  } else if (!state.complete) {
+    status = "partial";
+  } else {
+    status = results.length > 0 ? "success" : "not_found";
+  }
+  const precisionScore = results.length === 0 ? 0 : Math.min(...results.map((candidate) => candidate.precisionScore));
+  return {
+    status,
+    success: results.length > 0,
+    precisionScore: Number(precisionScore.toFixed(3)),
+    bestMatch: results[0] ?? null,
+    results,
+    metadata: metadata(options, state, startedAt),
+    warnings: state.warnings,
+    error
+  };
+}
+function invalidOptionsResult(error, startedAt) {
+  const options = resolveOptions();
+  const state = emptyState();
+  state.complete = false;
+  return resultFromState(options, state, startedAt, {
+    code: "INVALID_OPTIONS",
+    message: error.message
+  });
+}
+async function withPage(handle, pageNumber, work) {
+  const page = await handle.document.getPage(pageNumber);
+  try {
+    return await work(page);
+  } finally {
+    page.cleanup();
+  }
+}
+function ocrRecipes(recipes, options) {
+  const unrotated = recipes.filter((recipe) => recipe.rotation === 0).sort((left, right) => right.scale - left.scale)[0];
+  const selected = unrotated === void 0 ? [] : [unrotated];
+  if (options.performance === "accurate") {
+    selected.push(...recipes.filter((recipe) => recipe.rotation !== 0));
+  }
+  return selected;
+}
+async function collectTextEvidence(handle, state, pageLimit, options, guard) {
+  const processedPages = [];
+  for (let pageNumber = 1; pageNumber <= pageLimit; pageNumber += 1) {
+    guard.check();
+    const candidates = await withPage(handle, pageNumber, async (page) => textEvidence(await extractPageText(page), pageNumber));
+    guard.check();
+    state.evidence.push(...candidates);
+    state.pagesProcessed += 1;
+    processedPages.push(pageNumber);
+    if (options.stopAfterFirst && candidates.length > 0) {
+      break;
+    }
+  }
+  return processedPages;
+}
+async function collectBarcodeEvidence(handle, state, pages, recipes, options, guard) {
+  const exhaustive = options.ocr === "always" || options.performance === "accurate";
+  let pending = exhaustive ? [...pages] : pages.filter((page) => !hasPageEvidence(state.evidence, page));
+  if (pending.length === 0) {
+    return;
+  }
+  const [{ renderPage: renderPage2 }, { readBarcodes: readBarcodes2 }] = await Promise.all([Promise.resolve().then(() => (init_render_page(), render_page_exports)), Promise.resolve().then(() => (init_barcode_reader(), barcode_reader_exports))]);
+  for (let passIndex = 0; passIndex < recipes.length && pending.length > 0; passIndex += 1) {
+    const recipe = recipes[passIndex];
+    if (recipe === void 0) {
+      break;
+    }
+    state.passesUsed = Math.max(state.passesUsed, passIndex + 1);
+    const unresolved = [];
+    for (const pageNumber of pending) {
+      guard.check();
+      const candidates = await withPage(handle, pageNumber, async (page) => {
+        const rendered = await renderPage2(page, recipe, options.maxPixelsPerPage);
+        state.renderedPages.add(pageNumber);
+        return (await readBarcodes2(rendered)).flatMap((barcode) => findCandidatesInDecodedValue(barcode.text, pageNumber, barcode.source, passIndex + 1));
+      });
+      guard.check();
+      state.evidence.push(...candidates);
+      if (candidates.length === 0 || exhaustive) {
+        unresolved.push(pageNumber);
+      }
+      if (options.stopAfterFirst && candidates.length > 0) {
+        return;
+      }
+    }
+    pending = unresolved;
+  }
+}
+async function collectOcrEvidence(handle, state, pages, recipes, options, guard) {
+  if (options.ocr === "never") {
+    return null;
+  }
+  const pending = options.ocr === "always" ? pages : pages.filter((page) => !hasPageEvidence(state.evidence, page));
+  if (pending.length === 0) {
+    return null;
+  }
+  const selectedRecipes = ocrRecipes(recipes, options);
+  if (selectedRecipes.length === 0) {
+    return null;
+  }
+  const [{ renderPage: renderPage2 }, { createOcrSession: createOcrSession2 }] = await Promise.all([Promise.resolve().then(() => (init_render_page(), render_page_exports)), Promise.resolve().then(() => (init_ocr_reader(), ocr_reader_exports))]);
+  const session = await createOcrSession2();
+  try {
+    for (const pageNumber of pending) {
+      for (const recipe of selectedRecipes) {
+        guard.check();
+        const candidates = await withPage(handle, pageNumber, async (page) => {
+          const rendered = await renderPage2(page, recipe, options.maxPixelsPerPage);
+          state.renderedPages.add(pageNumber);
+          state.ocrPages.add(pageNumber);
+          const recognized = await session.recognize(rendered.toPng());
+          return findCandidatesInOcrText(recognized.text, pageNumber, recipes.indexOf(recipe) + 1, recognized.confidence);
+        });
+        guard.check();
+        state.evidence.push(...candidates);
+        if (options.stopAfterFirst && candidates.length > 0) {
+          return session;
+        }
+      }
+    }
+    return session;
+  } catch (error) {
+    await session.terminate().catch(() => void 0);
+    throw error;
+  }
+}
+async function extractNFeAccessKeys(input, optionsInput = {}) {
+  const startedAt = import_node_perf_hooks2.performance.now();
+  let options;
+  try {
+    options = resolveOptions(optionsInput);
+  } catch (error) {
+    if (error instanceof InvalidOptionsError) {
+      return invalidOptionsResult(error, startedAt);
+    }
+    return invalidOptionsResult(new InvalidOptionsError("Extraction options are invalid."), startedAt);
+  }
+  const state = emptyState();
+  const guard = new WorkGuard(options, startedAt);
+  let handle = null;
+  let ocrSession = null;
+  try {
+    guard.check();
+    const loaded = await loadPdfInput(input, options.maxFileSizeBytes, {
+      ...options.requestHeaders === void 0 ? {} : { requestHeaders: options.requestHeaders },
+      signal: guard.signal
+    });
+    guard.check();
+    state.fileSizeBytes = loaded.size;
+    handle = await openPdfDocument(loaded.data, options.maxSourceImagePixels, options.maxPixelsPerPage);
+    guard.check();
+    state.pagesTotal = handle.document.numPages;
+    const pageLimit = Math.min(state.pagesTotal, options.maxPages);
+    if (pageLimit < state.pagesTotal) {
+      state.complete = false;
+      state.warnings.push(`Only the first ${pageLimit} of ${state.pagesTotal} pages were processed because of maxPages.`);
+    }
+    const processedPages = await collectTextEvidence(handle, state, pageLimit, options, guard);
+    if (!(options.stopAfterFirst && state.evidence.length > 0)) {
+      const recipes = getRenderRecipes(options);
+      await collectBarcodeEvidence(handle, state, processedPages, recipes, options, guard);
+      if (!(options.stopAfterFirst && state.evidence.length > 0)) {
+        ocrSession = await collectOcrEvidence(handle, state, processedPages, recipes, options, guard);
+      }
+    }
+    guard.check();
+    if (options.stopAfterFirst && state.evidence.length > 0) {
+      state.complete = true;
+    }
+    return resultFromState(options, state, startedAt);
+  } catch (error) {
+    state.complete = false;
+    let resolvedError = error;
+    try {
+      guard.check();
+    } catch (guardError) {
+      resolvedError = guardError;
+    }
+    const failure = resolvedError instanceof ExtractionFailure ? resolvedError : new ExtractionFailure("PROCESSING_ERROR", "The PDF could not be processed.", {
+      cause: resolvedError
+    });
+    if (!(resolvedError instanceof ExtractionFailure)) {
+      state.warnings.push(`Internal detail: ${messageFromUnknown(resolvedError)}`);
+    }
+    return resultFromState(options, state, startedAt, {
+      code: failure.code,
+      message: failure.message
+    });
+  } finally {
+    guard.dispose();
+    await ocrSession?.terminate().catch(() => void 0);
+    await handle?.close().catch(() => void 0);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCESS_KEY_ISSUE_CODES,
+  calculateAccessKeyCheckDigit,
+  extractNFeAccessKeys,
+  parseAccessKey,
+  validateAccessKey,
+  validateIssuerIdentifier
+});
+//# sourceMappingURL=index.cjs.map