@asteby/storefront 0.10.0 → 0.11.0

package/dist/fiscal-document.cjs

@@ -0,0 +1,659 @@
+'use strict';
+
+// src/fiscal-document/registry.ts
+var extractors = /* @__PURE__ */ new Map();
+function registerIdentityExtractor(key, fn) {
+  if (!key || typeof fn !== "function") throw new TypeError("registerIdentityExtractor: key and fn are required");
+  extractors.set(key, fn);
+  return () => {
+    if (extractors.get(key) === fn) extractors.delete(key);
+  };
+}
+function getIdentityExtractor(key) {
+  return extractors.get(key);
+}
+
+// src/fiscal-document/text.ts
+var FOLD = {};
+for (const [from, to] of [
+  ["\xE1\xE0\xE2\xE3\xE4", "a"],
+  ["\xE9\xE8\xEA\xEB", "e"],
+  ["\xED\xEC\xEE\xEF", "i"],
+  ["\xF3\xF2\xF4\xF5\xF6", "o"],
+  ["\xFA\xF9\xFB\xFC", "u"],
+  ["\xF1", "n"],
+  ["\xE7", "c"]
+]) for (const ch of from) FOLD[ch] = to;
+function foldText(s) {
+  let out = "";
+  for (const ch of s.toLowerCase()) out += FOLD[ch] ?? ch;
+  return out.split(/\s+/).filter(Boolean).join(" ");
+}
+function ageInDays(isoDate, now) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDate);
+  if (!m) return null;
+  const then = Date.UTC(+m[1], +m[2] - 1, +m[3]);
+  const today = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+  return Math.floor((today - then) / 864e5);
+}
+async function sha256Hex(data) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new TypeError("sha256Hex: Web Crypto (crypto.subtle) is not available");
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  const digest = await subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/fiscal-document/engine.ts
+var MAX_TEXT_LENGTH = 4e5;
+var MAX_FIELDS = 32;
+var MAX_STRATEGIES = 8;
+var MAX_PATTERN = 1024;
+var STRATEGIES = /* @__PURE__ */ new Set(["regex", "labeled_lines", "concat_labeled", "catalog_phrases", "date", "qr_param"]);
+var STRATEGY_KEYS = /* @__PURE__ */ new Set([
+  "strategy",
+  "pattern",
+  "flags",
+  "group",
+  "label",
+  "labels",
+  "separator",
+  "catalog",
+  "start",
+  "end",
+  "order",
+  "months",
+  "param",
+  "split",
+  "parts",
+  "match",
+  "upper",
+  "capture",
+  "scan"
+]);
+var RULES_KEYS = /* @__PURE__ */ new Set(["version", "normalize", "labels", "qr_canonical", "fields"]);
+var PLACEHOLDER = /\{([a-z0-9_]+)\}/g;
+var IdentityRulesError = class extends Error {
+  name = "IdentityRulesError";
+};
+var cache = /* @__PURE__ */ new Map();
+function checkPattern(what, p, flags = "") {
+  if (!p) throw new IdentityRulesError(`rules: ${what}: empty pattern`);
+  if (p.length > MAX_PATTERN) throw new IdentityRulesError(`rules: ${what}: pattern longer than ${MAX_PATTERN}`);
+  for (const f of flags) if (f !== "i" && f !== "s" && f !== "m") throw new IdentityRulesError(`rules: ${what}: unknown flag "${f}"`);
+  if (p.replaceAll("(?:", "").includes("(?")) throw new IdentityRulesError(`rules: ${what}: only (?: groups are portable`);
+  for (const bad of ["[[:", "\\p", "\\P", "\\z", "\\A", "\\Q", "\\E", "\\C"]) {
+    if (p.includes(bad)) throw new IdentityRulesError(`rules: ${what}: ${bad} is not portable`);
+  }
+  try {
+    compiled(p, flags);
+  } catch (err) {
+    throw err instanceof IdentityRulesError ? err : new IdentityRulesError(`rules: ${what}: invalid pattern`);
+  }
+}
+function compiled(p, flags = "", global = false) {
+  const k = `${global ? "g" : ""}${flags}/${p}`;
+  let re = cache.get(k);
+  if (!re) {
+    re = new RegExp(p, flags + (global ? "g" : ""));
+    cache.set(k, re);
+  }
+  re.lastIndex = 0;
+  return re;
+}
+function validateStrategy(s, haveLabels) {
+  for (const k of Object.keys(s)) if (!STRATEGY_KEYS.has(k)) throw new IdentityRulesError(`rules: unknown member "${k}"`);
+  if (s.capture) {
+    checkPattern("capture", s.capture.pattern, s.capture.flags);
+    const groups = new RegExp(s.capture.pattern + "|").exec("").length - 1;
+    if ((s.capture.group ?? 0) < 0 || (s.capture.group ?? 0) > groups) throw new IdentityRulesError("rules: capture group does not exist");
+  }
+  switch (s.strategy) {
+    case "regex": {
+      checkPattern("pattern", s.pattern, s.flags);
+      const groups = new RegExp(s.pattern + "|").exec("").length - 1;
+      if ((s.group ?? 0) < 0 || (s.group ?? 0) > groups) throw new IdentityRulesError("rules: regex group does not exist");
+      return;
+    }
+    case "labeled_lines":
+      if (!haveLabels) throw new IdentityRulesError("rules: labeled_lines needs the top-level labels list");
+      return checkPattern("label", s.label);
+    case "concat_labeled":
+      if (!haveLabels || !s.labels?.length) throw new IdentityRulesError("rules: concat_labeled needs labels");
+      return s.labels.forEach((l) => checkPattern("labels", l));
+    case "catalog_phrases":
+      if (!s.catalog) throw new IdentityRulesError("rules: catalog_phrases needs a catalog");
+      return [s.start, s.end].forEach((p) => p && checkPattern("section", p, "i"));
+    case "date": {
+      checkPattern("pattern", s.pattern, s.flags);
+      const order = s.order ?? "";
+      if (order.length !== 3 || ![..."dmy"].every((c) => order.split(c).length === 2)) throw new IdentityRulesError(`rules: date order "${order}" must be a permutation of d, m, y`);
+      if (new RegExp(s.pattern + "|").exec("").length - 1 < 3) throw new IdentityRulesError("rules: date pattern needs three groups");
+      if (s.months && s.months.length !== 0 && s.months.length !== 12) throw new IdentityRulesError("rules: date months wants 12 names");
+      return;
+    }
+    case "qr_param": {
+      if (!s.param && !s.scan) throw new IdentityRulesError("rules: qr_param needs a param or a scan");
+      if ((s.parts ?? 0) < 0) throw new IdentityRulesError("rules: qr_param parts must not be negative");
+      if (s.scan) {
+        checkPattern("scan", s.scan, s.flags);
+        const groups = new RegExp(s.scan + "|").exec("").length - 1;
+        if ((s.group ?? 0) < 1 || (s.group ?? 0) > groups) throw new IdentityRulesError("rules: scan group does not exist");
+      }
+      if (s.param) checkPattern("match", s.match);
+      return;
+    }
+    default:
+      throw new IdentityRulesError(`rules: unknown strategy "${String(s.strategy)}"`);
+  }
+}
+function validateRules(rules, discard = []) {
+  for (const k of Object.keys(rules ?? {})) if (!RULES_KEYS.has(k)) throw new IdentityRulesError(`rules: unknown member "${k}"`);
+  if (rules?.version !== 1) throw new IdentityRulesError(`rules: version ${String(rules?.version)} is not 1`);
+  for (const n of rules.normalize ?? []) if (n !== "nbsp" && n !== "collapse_ws") throw new IdentityRulesError(`rules: unknown normalize step "${String(n)}"`);
+  for (const l of rules.labels ?? []) checkPattern("labels", l);
+  if (!Array.isArray(rules.fields) || rules.fields.length === 0 || rules.fields.length > MAX_FIELDS) throw new IdentityRulesError(`rules: want 1..${MAX_FIELDS} fields`);
+  if (rules.qr_canonical) {
+    const keys = new Set(rules.fields.map((f) => f.key));
+    for (const m of rules.qr_canonical.matchAll(PLACEHOLDER)) if (!keys.has(m[1])) throw new IdentityRulesError(`rules: qr_canonical names unknown field "${m[1]}"`);
+  }
+  const drop = new Set(discard.map((d) => d.trim().toLowerCase()));
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of rules.fields) {
+    if (!f.key || seen.has(f.key)) throw new IdentityRulesError(`rules: field key "${f.key}" is empty or repeated`);
+    seen.add(f.key);
+    if (drop.has(f.key.toLowerCase())) throw new IdentityRulesError(`rules: field "${f.key}" is in discard_fields`);
+    if (!Array.isArray(f.strategies) || f.strategies.length === 0 || f.strategies.length > MAX_STRATEGIES) throw new IdentityRulesError(`rules: field "${f.key}" wants 1..${MAX_STRATEGIES} strategies`);
+    for (const s of f.strategies) {
+      if (!STRATEGIES.has(s.strategy)) throw new IdentityRulesError(`rules: unknown strategy "${String(s.strategy)}"`);
+      validateStrategy(s, (rules.labels?.length ?? 0) > 0);
+    }
+  }
+}
+function parseRules(spec) {
+  let rules = spec.rules;
+  if (typeof rules === "string") {
+    try {
+      rules = JSON.parse(rules);
+    } catch {
+      throw new IdentityRulesError(`${spec.kind}: rules is not valid JSON`);
+    }
+  }
+  if (!rules || typeof rules !== "object") throw new IdentityRulesError(`${spec.kind}: rules@1 needs rules`);
+  validateRules(rules);
+  return rules;
+}
+function normalizeText(s, steps = []) {
+  let t = s.length > MAX_TEXT_LENGTH ? s.slice(0, MAX_TEXT_LENGTH) : s;
+  for (const st of steps) {
+    if (st === "nbsp") t = t.replaceAll("\xA0", " ");
+    else if (st === "collapse_ws") t = t.split(/\s+/).filter(Boolean).join(" ");
+  }
+  return t;
+}
+var LabelIndex = class {
+  constructor(labels, text) {
+    this.text = text;
+    if (labels.length === 0) return;
+    for (const m of text.matchAll(new RegExp(`(?:^|\\s)(${labels.join("|")})\\s*:`, "gi"))) {
+      this.hits.push({ caption: m[1] ?? "", start: m.index, from: m.index + m[0].length });
+    }
+  }
+  text;
+  hits = [];
+  value(label) {
+    const full = compiled(`^(?:${label})$`, "i");
+    for (let i = 0; i < this.hits.length; i++) {
+      const h = this.hits[i];
+      if (!full.test(h.caption)) continue;
+      const end = i + 1 < this.hits.length ? this.hits[i + 1].start : this.text.length;
+      return this.text.slice(h.from, end).trim();
+    }
+    return "";
+  }
+};
+function section(text, start, end) {
+  let from = 0;
+  if (start) {
+    const m = compiled(start, "is").exec(text);
+    if (!m) return "";
+    from = m.index + m[0].length;
+  }
+  let to = text.length;
+  if (end) {
+    const m = compiled(end, "is").exec(text.slice(from));
+    if (m) to = from + m.index;
+  }
+  return text.slice(from, to);
+}
+function phrasesOf(e) {
+  const src = e.match_phrases?.length ? e.match_phrases : [e.label, e.label_en ?? ""];
+  return [...new Set(src.map(foldText).filter(Boolean))];
+}
+function catalogHits(sec, entries = []) {
+  const hay = foldText(sec);
+  const hits = [];
+  for (const e of entries) {
+    let best = -1;
+    for (const p of phrasesOf(e)) {
+      const at = hay.indexOf(p);
+      if (at >= 0 && (best < 0 || at < best)) best = at;
+    }
+    if (best >= 0) hits.push({ code: e.code, at: best });
+  }
+  return hits.sort((a, b) => a.at - b.at).map((h) => h.code);
+}
+function parseDate(text, s) {
+  const m = compiled(s.pattern, s.flags ?? "").exec(text);
+  if (!m) return "";
+  let d = 0;
+  let mo = 0;
+  let y = 0;
+  for (let i = 0; i < 3; i++) {
+    const c = s.order[i];
+    const g = (m[i + 1] ?? "").trim();
+    let n = /^[+-]?\d+$/.test(g) ? Number(g) : NaN;
+    if (Number.isNaN(n) && c === "m" && s.months?.length === 12) {
+      n = 0;
+      s.months.forEach((name, j) => {
+        if (foldText(name) === foldText(g)) n = j + 1;
+      });
+    }
+    if (Number.isNaN(n) || n === 0) return "";
+    if (c === "d") d = n;
+    else if (c === "m") mo = n;
+    else y = n;
+  }
+  const t = new Date(Date.UTC(y, mo - 1, d));
+  if (y < 1e3 || t.getUTCFullYear() !== y || t.getUTCMonth() + 1 !== mo || t.getUTCDate() !== d) return "";
+  return `${String(y).padStart(4, "0")}-${String(mo).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+function qrScan(qr, s) {
+  if (!s.scan) return "";
+  const m = compiled(s.scan, s.flags ?? "").exec(qr);
+  return m ? (m[s.group ?? 0] ?? "").trim().toUpperCase() : "";
+}
+function qrPart(qr, s) {
+  const url = qr.trim();
+  if (!url) return "";
+  if (!s.param) return qrScan(url, s);
+  const m = new RegExp(`[?&]${s.param.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}=([^&\\s#]+)`, "i").exec(url);
+  if (!m) return qrScan(url, s);
+  let val;
+  try {
+    val = decodeURIComponent(m[1].replaceAll("+", " "));
+  } catch {
+    return "";
+  }
+  const parts = s.split ? val.split(s.split) : [val];
+  if ((s.parts ?? 0) > 0 && parts.length !== s.parts) return qrScan(url, s);
+  const re = compiled(s.match);
+  for (const raw of parts) {
+    const p = raw.trim().toUpperCase();
+    if (re.test(p)) return p;
+  }
+  return qrScan(url, s);
+}
+function queryEscape(v) {
+  return encodeURIComponent(v).replace(/[!'()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase()).replaceAll("%20", "+");
+}
+function post(s, value) {
+  let v = value.trim();
+  if (!v) return "";
+  if (s.upper) v = v.toUpperCase();
+  if (s.capture) {
+    const m = compiled(s.capture.pattern, s.capture.flags ?? "").exec(v);
+    if (!m) return "";
+    v = (m[s.capture.group ?? 0] ?? "").trim();
+  }
+  return v;
+}
+function run(s, text, labels, catalogs) {
+  switch (s.strategy) {
+    case "regex": {
+      const m = compiled(s.pattern, s.flags ?? "").exec(text);
+      return m ? [m[s.group ?? 0] ?? ""] : [];
+    }
+    case "labeled_lines":
+      return [labels.value(s.label)];
+    case "concat_labeled": {
+      const parts = (s.labels ?? []).map((l) => labels.value(l).trim()).filter(Boolean);
+      return [parts.join(s.separator || " ")];
+    }
+    case "catalog_phrases":
+      return catalogHits(section(text, s.start, s.end), catalogs[s.catalog]);
+    case "date":
+      return [parseDate(text, s)];
+    default:
+      return [];
+  }
+}
+var nonEmpty = (vals) => vals.map((v) => v.trim()).filter(Boolean);
+function extractIdentityDocument(text, spec, options = {}) {
+  const discard = (spec.discard_fields ?? []).map((d) => d.trim().toLowerCase());
+  const out = {
+    kind: spec.kind,
+    extractor: spec.engine,
+    fields: {},
+    sources: {},
+    missing: [],
+    discarded: [...spec.discard_fields ?? []],
+    qr: { match: null, canonical: "" },
+    stale: null,
+    age_days: null
+  };
+  if (spec.engine === "rules@1") {
+    const rules = parseRules(spec);
+    const body = normalizeText(text, rules.normalize);
+    const labels = new LabelIndex(rules.labels ?? [], body);
+    const catalogs = options.catalogs ?? {};
+    let compared = 0;
+    let equal = 0;
+    const qrBest = {};
+    for (const f of rules.fields) {
+      let textVals = [];
+      const qrVals = [];
+      for (const s of f.strategies) {
+        if (s.strategy === "qr_param") {
+          const v = post(s, qrPart(options.qr ?? "", s));
+          if (v) qrVals.push(v);
+          continue;
+        }
+        if (textVals.length > 0) continue;
+        textVals = nonEmpty(run(s, body, labels, catalogs).map((v) => post(s, v)));
+      }
+      let got = [];
+      if (textVals.length > 0) {
+        got = textVals;
+        out.sources[f.key] = "text";
+      } else if (qrVals.length > 0) {
+        got = qrVals.slice(0, 1);
+        out.sources[f.key] = "qr";
+      }
+      if (qrVals.length > 0) qrBest[f.key] = qrVals[0];
+      if (textVals.length > 0 && qrVals.length > 0) {
+        compared++;
+        if (textVals[0].toUpperCase() === qrVals[0].toUpperCase()) equal++;
+      }
+      if (got.length === 0) {
+        if (f.required) out.missing.push(f.key);
+      } else out.fields[f.key] = f.multiple ? got : got[0];
+    }
+    if (compared > 0) out.qr.match = compared === equal;
+    if (rules.qr_canonical && (options.qr ?? "").trim()) {
+      let ok = true;
+      const canon = rules.qr_canonical.replace(PLACEHOLDER, (_p, key) => {
+        const v = qrBest[key];
+        if (!v) ok = false;
+        return queryEscape(v ?? "");
+      });
+      if (ok) out.qr.canonical = canon;
+    }
+  } else {
+    const id = spec.engine.startsWith("plugin:") ? spec.engine.slice("plugin:".length) : spec.engine;
+    const fn = getIdentityExtractor(id) ?? getIdentityExtractor(spec.kind);
+    if (!fn) throw new IdentityRulesError(`${spec.kind}: no extractor registered for engine "${spec.engine}"`);
+    const res = fn(text, spec, options);
+    out.fields = { ...res.fields };
+    out.sources = { ...res.sources ?? {} };
+    out.missing = [...res.missing ?? []];
+    out.qr.match = res.qr_match ?? null;
+  }
+  for (const k of Object.keys(out.fields)) {
+    if (discard.includes(k.toLowerCase())) {
+      delete out.fields[k];
+      delete out.sources[k];
+    }
+  }
+  const issued = out.fields.issued_on;
+  if (typeof issued === "string") {
+    out.age_days = ageInDays(issued, options.now ?? /* @__PURE__ */ new Date());
+    if (spec.freshness_days && out.age_days !== null) out.stale = out.age_days > spec.freshness_days;
+  }
+  return out;
+}
+function catalogsFromRegion(fiscalId) {
+  return { fiscal_regime: fiscalId.regimes, invoice_use: fiscalId.invoice_uses };
+}
+function buildDocumentEvidence(extraction, input) {
+  const id = extraction.fields.document_id;
+  const issued = extraction.fields.issued_on;
+  return {
+    kind: extraction.kind,
+    document_id: typeof id === "string" ? id : null,
+    issued_on: typeof issued === "string" ? issued : null,
+    sha256: input.sha256 ?? null,
+    extractor: extraction.extractor,
+    source: input.source,
+    qr_match: extraction.qr.match
+  };
+}
+
+// src/fiscal-document/errors.ts
+var IdentityDocumentError = class extends Error {
+  name = "IdentityDocumentError";
+  code;
+  /** Finer cause: `bytes`, `pages`, `timeout`, `aborted`... */
+  reason;
+  constructor(code, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.code = code;
+    this.reason = options?.reason;
+  }
+};
+function isIdentityDocumentError(err) {
+  return err instanceof IdentityDocumentError || typeof err === "object" && err !== null && err.name === "IdentityDocumentError";
+}
+
+// src/fiscal-document/pdf.ts
+var DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_PAGES = 6;
+var DEFAULT_TIMEOUT_MS = 3e3;
+var custom;
+function setPdfjsLoader(loader) {
+  custom = loader;
+}
+async function loadPdfjs(workerSrc) {
+  const mod = custom ? await custom() : await import('pdfjs-dist/legacy/build/pdf.mjs');
+  if (workerSrc && mod.GlobalWorkerOptions) mod.GlobalWorkerOptions.workerSrc = workerSrc;
+  const inBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  if (inBrowser && !mod.GlobalWorkerOptions?.workerSrc) {
+    throw new TypeError("readPdfText: set `workerSrc` to a pdf.worker.mjs your site serves (there is no default and no CDN)");
+  }
+  return mod;
+}
+async function toBytes(source) {
+  if (typeof Blob !== "undefined" && source instanceof Blob) return new Uint8Array(await source.arrayBuffer());
+  if (source instanceof ArrayBuffer) return new Uint8Array(source);
+  if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+  throw new TypeError("readPdfText: expected a File, Blob, ArrayBuffer or Uint8Array");
+}
+function sizeOf(source) {
+  if (typeof Blob !== "undefined" && source instanceof Blob) return source.size;
+  return source.byteLength;
+}
+function hasPdfSignature(bytes) {
+  return bytes.length >= 5 && bytes[0] === 37 && bytes[1] === 80 && bytes[2] === 68 && bytes[3] === 70 && bytes[4] === 45;
+}
+function mapPdfjsError(err) {
+  const name = err?.name ?? "";
+  if (name === "PasswordException") return new IdentityDocumentError("password", "The PDF is password protected", { cause: err });
+  if (name === "InvalidPDFException") return new IdentityDocumentError("unreadable", "The PDF is corrupt or unsupported", { cause: err, reason: "invalid" });
+  return new IdentityDocumentError("unreadable", "The PDF could not be read", { cause: err });
+}
+async function openPdf(source, options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (sizeOf(source) > maxBytes) throw new IdentityDocumentError("too_large", `The file is larger than ${maxBytes} bytes`, { reason: "bytes" });
+  const bytes = await toBytes(source);
+  if (bytes.byteLength > maxBytes) throw new IdentityDocumentError("too_large", `The file is larger than ${maxBytes} bytes`, { reason: "bytes" });
+  if (!hasPdfSignature(bytes)) throw new IdentityDocumentError("not_pdf", "The file is not a PDF");
+  const sha256 = await sha256Hex(bytes);
+  if (options.signal?.aborted) throw new IdentityDocumentError("unreadable", "Aborted", { reason: "aborted" });
+  const pdfjs = await loadPdfjs(options.workerSrc);
+  const task = pdfjs.getDocument({
+    data: bytes.slice(),
+    isEvalSupported: false,
+    enableXfa: false,
+    useSystemFonts: false,
+    disableAutoFetch: true,
+    disableStream: true,
+    useWorkerFetch: false,
+    verbosity: 0
+  });
+  task.promise.catch(() => void 0);
+  let doc;
+  const destroy = async () => {
+    try {
+      await (doc?.destroy ? doc.destroy() : task.destroy());
+    } catch {
+    }
+  };
+  let timer;
+  let onAbort;
+  const limit = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new IdentityDocumentError("unreadable", `Reading took longer than ${timeoutMs} ms`, { reason: "timeout" })), timeoutMs);
+    if (options.signal) {
+      onAbort = () => reject(new IdentityDocumentError("unreadable", "Aborted", { reason: "aborted" }));
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+  const cleanup = () => {
+    if (timer) clearTimeout(timer);
+    if (onAbort) options.signal?.removeEventListener("abort", onAbort);
+  };
+  try {
+    doc = await Promise.race([task.promise, limit]);
+    if (doc.numPages > maxPages) throw new IdentityDocumentError("too_large", `The PDF has more than ${maxPages} pages`, { reason: "pages" });
+    cleanup();
+    return { bytes, sha256, pdfjs, doc, destroy };
+  } catch (err) {
+    cleanup();
+    await destroy();
+    throw err instanceof IdentityDocumentError ? err : mapPdfjsError(err);
+  }
+}
+function itemsToLines(items) {
+  const rows = [];
+  for (const it of items) {
+    const s = it.str;
+    if (!s || !s.trim()) continue;
+    const x = it.transform?.[4] ?? 0;
+    const y = it.transform?.[5] ?? 0;
+    const row = rows.find((r) => Math.abs(r.y - y) <= 2);
+    if (row) row.parts.push({ x, s });
+    else rows.push({ y, parts: [{ x, s }] });
+  }
+  rows.sort((a, b) => b.y - a.y);
+  return rows.map((r) => r.parts.sort((a, b) => a.x - b.x).map((p) => p.s.trim()).join(" ")).join("\n");
+}
+async function readPdfText(source, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const opened = await openPdf(source, options);
+  let timer;
+  try {
+    const read = (async () => {
+      const pages2 = [];
+      for (let n = 1; n <= opened.doc.numPages; n++) {
+        const page = await opened.doc.getPage(n);
+        pages2.push(itemsToLines((await page.getTextContent()).items));
+        page.cleanup?.();
+      }
+      return pages2;
+    })();
+    const limit = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new IdentityDocumentError("unreadable", `Reading took longer than ${timeoutMs} ms`, { reason: "timeout" })), timeoutMs);
+    });
+    const pages = await Promise.race([read, limit]);
+    const text = pages.join("\n\n");
+    if (text.replace(/\s+/g, "").length < (options.minChars ?? 20)) throw new IdentityDocumentError("no_text", "The PDF has no text layer");
+    return { text, pages: pages.length, sha256: opened.sha256 };
+  } catch (err) {
+    throw err instanceof IdentityDocumentError ? err : mapPdfjsError(err);
+  } finally {
+    if (timer) clearTimeout(timer);
+    await opened.destroy();
+  }
+}
+
+// src/fiscal-document/qr.ts
+function makeCanvas(width, height) {
+  const g = globalThis;
+  if (g.OffscreenCanvas) return new g.OffscreenCanvas(width, height);
+  if (g.document) {
+    const c = g.document.createElement("canvas");
+    c.width = width;
+    c.height = height;
+    return c;
+  }
+  return null;
+}
+async function decodeImage(image, canvas, custom2) {
+  if (custom2) return await custom2(image) ?? null;
+  const Detector = globalThis.BarcodeDetector;
+  if (Detector) {
+    try {
+      const found = await new Detector({ formats: ["qr_code"] }).detect(canvas);
+      if (found[0]?.rawValue) return found[0].rawValue;
+    } catch {
+    }
+  }
+  try {
+    const mod = await import('jsqr');
+    return mod.default(image.data, image.width, image.height)?.data ?? null;
+  } catch {
+    return null;
+  }
+}
+async function scan(page, scale, custom2) {
+  const viewport = page.getViewport({ scale });
+  const canvas = makeCanvas(Math.ceil(viewport.width), Math.ceil(viewport.height));
+  if (!canvas && !custom2) return null;
+  const c = canvas ?? { width: Math.ceil(viewport.width), height: Math.ceil(viewport.height), getContext: () => null };
+  const context = c.getContext("2d");
+  if (!context) return null;
+  await page.render({ canvasContext: context, viewport }).promise;
+  return decodeImage(context.getImageData(0, 0, c.width, c.height), c, custom2);
+}
+async function decodePdfQr(source, options = {}) {
+  const opened = await openPdf(source, options);
+  try {
+    const last = opened.doc.numPages;
+    const wanted = options.pages ?? [1, last];
+    const pages = [...new Set(wanted)].filter((n) => n >= 1 && n <= last);
+    for (const n of pages) {
+      try {
+        const page = await opened.doc.getPage(n);
+        const found = await scan(page, options.scale ?? 2, options.decode);
+        page.cleanup?.();
+        if (found) return found;
+      } catch (err) {
+        if (err instanceof IdentityDocumentError) throw err;
+      }
+    }
+    return null;
+  } finally {
+    await opened.destroy();
+  }
+}
+
+exports.DEFAULT_MAX_BYTES = DEFAULT_MAX_BYTES;
+exports.DEFAULT_MAX_PAGES = DEFAULT_MAX_PAGES;
+exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+exports.IdentityDocumentError = IdentityDocumentError;
+exports.IdentityRulesError = IdentityRulesError;
+exports.MAX_TEXT_LENGTH = MAX_TEXT_LENGTH;
+exports.buildDocumentEvidence = buildDocumentEvidence;
+exports.catalogsFromRegion = catalogsFromRegion;
+exports.decodePdfQr = decodePdfQr;
+exports.extractIdentityDocument = extractIdentityDocument;
+exports.foldText = foldText;
+exports.isIdentityDocumentError = isIdentityDocumentError;
+exports.readPdfText = readPdfText;
+exports.registerIdentityExtractor = registerIdentityExtractor;
+exports.setPdfjsLoader = setPdfjsLoader;
+exports.sha256Hex = sha256Hex;
+exports.validateRules = validateRules;
+//# sourceMappingURL=fiscal-document.cjs.map
+//# sourceMappingURL=fiscal-document.cjs.map