@andresxid/xid_camera_ocr_sdk_react 0.1.0

package/dist/cv-worker.js

@@ -0,0 +1,670 @@
+// src/core/geometry.ts
+var ID1_RATIO = 85.6 / 53.98;
+var TD3_RATIO = 125 / 88;
+var TYPE_BOUNDARY_RATIO = 1.503;
+var HINT_TOLERANCE = 0.05;
+var CAPTURABLE_ASPECT_MIN = 1.25;
+var CAPTURABLE_ASPECT_MAX = 1.75;
+var ASPECT_SCORE_FALLOFF = 0.25;
+function orderCorners(points) {
+  if (points.length !== 4) throw new Error(`orderCorners expects 4 points, got ${points.length}`);
+  const cx = (points[0].x + points[1].x + points[2].x + points[3].x) / 4;
+  const cy = (points[0].y + points[1].y + points[2].y + points[3].y) / 4;
+  const cycle = [...points].sort(
+    (a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx)
+  );
+  let start = 0;
+  for (let i = 1; i < 4; i++) {
+    const p = cycle[i];
+    const s = cycle[start];
+    if (p.x + p.y < s.x + s.y || p.x + p.y === s.x + s.y && p.y < s.y) start = i;
+  }
+  return [0, 1, 2, 3].map((k) => cycle[(start + k) % 4]);
+}
+function polygonArea(points) {
+  let sum = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return Math.abs(sum) / 2;
+}
+function sideLengths(quad) {
+  const [tl, tr, br, bl] = quad;
+  return {
+    top: Math.hypot(tr.x - tl.x, tr.y - tl.y),
+    right: Math.hypot(br.x - tr.x, br.y - tr.y),
+    bottom: Math.hypot(br.x - bl.x, br.y - bl.y),
+    left: Math.hypot(bl.x - tl.x, bl.y - tl.y)
+  };
+}
+function interiorAngles(quad) {
+  const out = [0, 0, 0, 0];
+  for (let i = 0; i < 4; i++) {
+    const prev = quad[(i + 3) % 4];
+    const cur = quad[i];
+    const next = quad[(i + 1) % 4];
+    const ax = prev.x - cur.x;
+    const ay = prev.y - cur.y;
+    const bx = next.x - cur.x;
+    const by = next.y - cur.y;
+    const la = Math.hypot(ax, ay);
+    const lb = Math.hypot(bx, by);
+    if (la === 0 || lb === 0) {
+      out[i] = 0;
+      continue;
+    }
+    const cos = Math.min(1, Math.max(-1, (ax * bx + ay * by) / (la * lb)));
+    out[i] = Math.acos(cos) * 180 / Math.PI;
+  }
+  return out;
+}
+function isValidQuad(quad, minAngle = 70, maxAngle = 110) {
+  const s = sideLengths(quad);
+  if (s.top <= 0 || s.right <= 0 || s.bottom <= 0 || s.left <= 0) return false;
+  if (!isConvex(quad) || polygonArea(quad) <= 0) return false;
+  return interiorAngles(quad).every((a) => a >= minAngle && a <= maxAngle);
+}
+function isConvex(quad) {
+  let sign = 0;
+  for (let i = 0; i < 4; i++) {
+    const a = quad[i];
+    const b = quad[(i + 1) % 4];
+    const c = quad[(i + 2) % 4];
+    const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+    if (cross === 0) return false;
+    const s = Math.sign(cross);
+    if (sign === 0) sign = s;
+    else if (s !== sign) return false;
+  }
+  return true;
+}
+function rectifiedAspect(quad) {
+  const s = sideLengths(quad);
+  const w = (s.top + s.bottom) / 2;
+  const h = (s.left + s.right) / 2;
+  const short = Math.min(w, h);
+  if (short <= 0) return 0;
+  return Math.max(w, h) / short;
+}
+function aspectScore(aspect) {
+  if (!Number.isFinite(aspect)) return 0;
+  const d = Math.min(Math.abs(aspect - ID1_RATIO), Math.abs(aspect - TD3_RATIO));
+  return Math.max(0, 1 - d / ASPECT_SCORE_FALLOFF);
+}
+function scoreCandidate(c) {
+  return 0.5 * c.areaRatio + 0.3 * c.rectangularity + 0.2 * aspectScore(c.aspect);
+}
+function typeHintFromAspect(aspect) {
+  const nominal = aspect >= TYPE_BOUNDARY_RATIO ? ID1_RATIO : TD3_RATIO;
+  if (Math.abs(aspect - nominal) / nominal <= HINT_TOLERANCE) {
+    return nominal === ID1_RATIO ? "INE" : "PASSPORT_MX";
+  }
+  return "OTHER";
+}
+function isCapturableAspect(aspect) {
+  return aspect >= CAPTURABLE_ASPECT_MIN && aspect <= CAPTURABLE_ASPECT_MAX;
+}
+function canonicalRatioFor(type, measuredAspect) {
+  if (type === "INE") return ID1_RATIO;
+  if (type === "PASSPORT_MX") return TD3_RATIO;
+  return measuredAspect;
+}
+
+// src/core/quality.ts
+var QUALITY_THRESHOLDS = {
+  brightnessMin: 0.18,
+  brightnessMax: 0.9,
+  blurMin: 60,
+  glareMax: 0.04,
+  fillMin: 0.25,
+  glarePixel: 248
+};
+function quadRowSpans(quad, width, height) {
+  const spans = new Int32Array(height * 2);
+  for (let y = 0; y < height; y++) {
+    const yc = y + 0.5;
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    for (let i = 0; i < 4; i++) {
+      const a = quad[i];
+      const b = quad[(i + 1) % 4];
+      const lo = Math.min(a.y, b.y);
+      const hi = Math.max(a.y, b.y);
+      if (yc < lo || yc > hi || hi === lo) continue;
+      const x = a.x + (yc - a.y) * (b.x - a.x) / (b.y - a.y);
+      if (x < xMin) xMin = x;
+      if (x > xMax) xMax = x;
+    }
+    if (xMin === Infinity) {
+      spans[y * 2] = 0;
+      spans[y * 2 + 1] = 0;
+      continue;
+    }
+    spans[y * 2] = Math.max(0, Math.ceil(xMin - 0.5));
+    spans[y * 2 + 1] = Math.min(width, Math.floor(xMax + 0.5));
+  }
+  return spans;
+}
+function measureQuality(gray, quad) {
+  const { data, width: W, height: H } = gray;
+  const spans = quadRowSpans(quad, W, H);
+  const glarePixel = QUALITY_THRESHOLDS.glarePixel;
+  let sum = 0;
+  let glare = 0;
+  let count = 0;
+  let lapSum = 0;
+  let lapSq = 0;
+  let lapCount = 0;
+  for (let y = 0; y < H; y++) {
+    const xs = spans[y * 2];
+    const xe = spans[y * 2 + 1];
+    if (xs >= xe) continue;
+    let lx = 0;
+    let rx = 0;
+    if (y > 0 && y < H - 1) {
+      lx = Math.max(xs, spans[(y - 1) * 2], spans[(y + 1) * 2]) + 1;
+      rx = Math.min(xe, spans[(y - 1) * 2 + 1], spans[(y + 1) * 2 + 1]) - 1;
+    }
+    const row = y * W;
+    for (let x = xs; x < xe; x++) {
+      const i = row + x;
+      const v = data[i];
+      sum += v;
+      if (v >= glarePixel) glare++;
+      count++;
+      if (x >= lx && x < rx) {
+        const r = 4 * v - data[i - W] - data[i + W] - data[i - 1] - data[i + 1];
+        lapSum += r;
+        lapSq += r * r;
+        lapCount++;
+      }
+    }
+  }
+  const brightness = count > 0 ? sum / count / 255 : 0;
+  const glareRatio = count > 0 ? glare / count : 0;
+  const blurScore = lapCount > 0 ? Math.max(0, lapSq / lapCount - (lapSum / lapCount) ** 2) : 0;
+  const frameArea = W * H;
+  const docFillRatio = frameArea > 0 ? polygonArea(quad) / frameArea : 0;
+  const ok = brightness >= QUALITY_THRESHOLDS.brightnessMin && brightness <= QUALITY_THRESHOLDS.brightnessMax && blurScore >= QUALITY_THRESHOLDS.blurMin && glareRatio <= QUALITY_THRESHOLDS.glareMax && docFillRatio >= QUALITY_THRESHOLDS.fillMin;
+  return { brightness, blurScore, glareRatio, docFillRatio, ok };
+}
+function frameMeanBrightness(gray) {
+  const { data } = gray;
+  if (data.length === 0) return 0;
+  let sum = 0;
+  for (let i = 0; i < data.length; i++) sum += data[i];
+  return sum / data.length / 255;
+}
+
+// src/core/cv-detection.ts
+var MIN_AREA_RATIO = 0.08;
+var MAX_AREA_RATIO = 0.95;
+var APPROX_EPSILON = 0.02;
+var BORDER_PADDING = 8;
+var CLAHE_CLIP = 2;
+var CLAHE_TILE = 8;
+var CANNY_SIGMA = 0.33;
+var DILATE_ITERATIONS = 2;
+var BORDER_TOUCH_PX = 2;
+var MAX_BORDER_CORNERS = 1;
+var BORDER_TOUCH_LIMIT = BORDER_TOUCH_PX + DILATE_ITERATIONS;
+var NESTED_AREA_FACTOR = 2;
+var NESTED_MARGIN_PX = 2 * (DILATE_ITERATIONS + 1);
+var POLARITY_MIN_DIFF = 10;
+var POLARITY_RING_SCALE = 1.1;
+var QUALITY_INSET_PX = DILATE_ITERATIONS + 1;
+var MAX_REDUCIBLE_VERTICES = 6;
+var REDUCED_MIN_FILL = 0.92;
+var REDUCED_MAX_FILL = 1 / REDUCED_MIN_FILL;
+var INDIRECT_SCORE_FACTOR = 0.85;
+var PRIOR_WEIGHT = 2;
+var PRIOR_D_CAP = 0.05;
+var COARSE_SCALE = 2;
+var MIN_COARSE_SIDE = 64;
+function empty(frameBrightness) {
+  return { detected: false, documentType: null, aspectRatio: null, corners: null, boundingBox: null, quality: null, frameBrightness, score: null };
+}
+function detectDocumentCV(cv, imageData, _acceptedTypes, opts = {}) {
+  const frame = { brightness: 0 };
+  try {
+    return detectInner(cv, imageData, frame, opts.prior ?? null);
+  } catch (err) {
+    console.warn("[xid-camera-ocr] detectDocumentCV failed:", err);
+    return empty(frame.brightness);
+  }
+}
+function detectInner(cv, imageData, frame, prior) {
+  const { width: W, height: H } = imageData;
+  const mats = [];
+  const own = (m) => {
+    mats.push(m);
+    return m;
+  };
+  try {
+    const src = own(cv.matFromImageData(imageData));
+    const gray = own(new cv.Mat());
+    const small = own(new cv.Mat());
+    const ws = {
+      equalized: own(new cv.Mat()),
+      filtered: own(new cv.Mat()),
+      padded: own(new cv.Mat()),
+      edges: own(new cv.Mat()),
+      dilated: own(new cv.Mat()),
+      kernel: own(cv.Mat.ones(3, 3, cv.CV_8U)),
+      contours: own(new cv.MatVector()),
+      hierarchy: own(new cv.Mat()),
+      hull: own(new cv.Mat()),
+      approx: own(new cv.Mat()),
+      clahe: own(new cv.CLAHE(CLAHE_CLIP, new cv.Size(CLAHE_TILE, CLAHE_TILE)))
+    };
+    cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
+    frame.brightness = frameMeanBrightness(grayView(gray, W, H));
+    const cut = [];
+    let best = scanScale(cv, gray, ws, W, H, cut, prior);
+    let lowres = false;
+    const sw = Math.round(W / COARSE_SCALE), sh = Math.round(H / COARSE_SCALE);
+    if (!best && sw >= MIN_COARSE_SIDE && sh >= MIN_COARSE_SIDE) {
+      cv.resize(gray, small, new cv.Size(sw, sh), 0, 0, cv.INTER_AREA);
+      best = scanScale(cv, small, ws, W, H, cut, prior);
+      lowres = best !== null;
+    }
+    if (best && isNestedInCut(best, cut, grayView(gray, W, H))) best = null;
+    if (!best) return empty(frame.brightness);
+    const provenance = lowres ? "lowres" : best.reduced ? "reduced" : "direct";
+    const xs = best.quad.map((p) => p.x);
+    const ys = best.quad.map((p) => p.y);
+    const minX = Math.min(...xs), maxX = Math.max(...xs), minY = Math.min(...ys), maxY = Math.max(...ys);
+    return {
+      detected: true,
+      documentType: typeHintFromAspect(best.aspect),
+      aspectRatio: best.aspect,
+      corners: best.quad,
+      boundingBox: { x: minX / W, y: minY / H, width: (maxX - minX) / W, height: (maxY - minY) / H },
+      // Fresh view: any allocation since cvtColor may have grown (and detached) the heap.
+      // The inset is in pass pixels: a half-resolution contour sits twice as far (in
+      // full-frame pixels) outside the edge.
+      quality: measureQuality(grayView(gray, W, H), insetQuad(best.quad, QUALITY_INSET_PX * best.scale)),
+      frameBrightness: frame.brightness,
+      score: provenance === "direct" ? best.score : best.score * INDIRECT_SCORE_FACTOR,
+      provenance
+    };
+  } finally {
+    for (const m of mats) m.delete();
+  }
+}
+function scanScale(cv, gray, ws, W, H, cut, prior) {
+  const w = gray.cols, h = gray.rows;
+  const sx = W / w, sy = H / h;
+  const passArea = w * h;
+  const up = (p) => ({ x: p.x * sx, y: p.y * sy });
+  const { hull, approx, contours } = ws;
+  ws.clahe.apply(gray, ws.equalized);
+  cv.bilateralFilter(ws.equalized, ws.filtered, 9, 75, 75, cv.BORDER_DEFAULT);
+  cv.copyMakeBorder(ws.filtered, ws.padded, BORDER_PADDING, BORDER_PADDING, BORDER_PADDING, BORDER_PADDING, cv.BORDER_CONSTANT, new cv.Scalar(0));
+  const median = medianOf(ws.padded.data);
+  cv.Canny(ws.padded, ws.edges, Math.max(10, (1 - CANNY_SIGMA) * median), Math.min(255, (1 + CANNY_SIGMA) * median));
+  cv.dilate(ws.edges, ws.dilated, ws.kernel, new cv.Point(-1, -1), DILATE_ITERATIONS);
+  cv.findContours(ws.dilated, contours, ws.hierarchy, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE);
+  let best = null;
+  for (let i = 0; i < contours.size(); i++) {
+    const c = contours.get(i);
+    try {
+      const box = cv.boundingRect(c);
+      if (box.width * box.height < passArea * MIN_AREA_RATIO) continue;
+      cv.convexHull(c, hull, false, true);
+      const area = cv.contourArea(hull);
+      if (area < passArea * MIN_AREA_RATIO || area > passArea * MAX_AREA_RATIO) continue;
+      cv.approxPolyDP(hull, approx, APPROX_EPSILON * cv.arcLength(hull, true), true);
+      if (approx.rows < 4 || approx.rows > MAX_REDUCIBLE_VERTICES || !cv.isContourConvex(approx)) continue;
+      const reduced = approx.rows !== 4;
+      let pts;
+      if (!reduced) {
+        pts = matPoints(approx, w, h);
+      } else {
+        const quad4 = reduceToQuad(rawPoints(approx));
+        if (!quad4) continue;
+        pts = quad4.map((p) => clampPoint(p, w, h));
+        const fill = area / polygonArea(pts);
+        if (!(fill >= REDUCED_MIN_FILL && fill <= REDUCED_MAX_FILL)) continue;
+      }
+      const fullArea = area * sx * sy;
+      const full = pts.map(up);
+      const borderLimit = BORDER_TOUCH_LIMIT * sx;
+      if (borderCorners(full, W, H, borderLimit) > MAX_BORDER_CORNERS) {
+        if (!spansFrame(full, W, H, borderLimit)) cut.push({ pts: full, area: fullArea });
+        continue;
+      }
+      const quad = orderCorners(full);
+      if (!isValidQuad(quad)) continue;
+      const rect = cv.minAreaRect(reduced ? hull : approx);
+      const rectArea = rect.size.width * rect.size.height;
+      const rectangularity = rectArea > 0 ? Math.min(1, area / rectArea) : 0;
+      const aspect = rectifiedAspect(quad);
+      if (!isCapturableAspect(aspect)) continue;
+      const score = scoreCandidate({ areaRatio: area / passArea, rectangularity, aspect });
+      const rank = prior ? score - priorPenalty(quad, prior, W, H) : score;
+      if (!best || rank > best.rank) best = { quad, score, rank, aspect, area: fullArea, scale: sx, reduced };
+    } finally {
+      c.delete();
+    }
+  }
+  return best;
+}
+function priorPenalty(quad, prior, W, H) {
+  let best = Infinity;
+  for (let shift = 0; shift < 4; shift++) {
+    let maxMove = 0;
+    for (let i = 0; i < 4; i++) {
+      const p = quad[(i + shift) % 4];
+      maxMove = Math.max(maxMove, Math.hypot(p.x - prior[i].x, p.y - prior[i].y));
+    }
+    best = Math.min(best, maxMove);
+  }
+  return PRIOR_WEIGHT * Math.min(best / Math.hypot(W, H), PRIOR_D_CAP);
+}
+function grayView(gray, width, height) {
+  return { data: gray.data, width, height };
+}
+function rawPoints(mat) {
+  const d = mat.data32S;
+  const pts = [];
+  for (let k = 0; k < mat.rows; k++) pts.push({ x: d[k * 2] - BORDER_PADDING, y: d[k * 2 + 1] - BORDER_PADDING });
+  return pts;
+}
+function clampPoint(p, W, H) {
+  return { x: Math.min(W, Math.max(0, p.x)), y: Math.min(H, Math.max(0, p.y)) };
+}
+function matPoints(mat, W, H) {
+  return rawPoints(mat).map((p) => clampPoint(p, W, H));
+}
+function reduceToQuad(poly) {
+  let pts = poly;
+  while (pts.length > 4) {
+    const n = pts.length;
+    let bestIdx = -1, bestAdded = Infinity, bestX = null;
+    for (let i = 0; i < n; i++) {
+      const a0 = pts[(i + n - 1) % n], a1 = pts[i], b1 = pts[(i + 1) % n], b0 = pts[(i + 2) % n];
+      const x = forwardIntersection(a0, a1, b0, b1);
+      if (!x) continue;
+      const added = Math.abs((x.x - a1.x) * (b1.y - a1.y) - (x.y - a1.y) * (b1.x - a1.x)) / 2;
+      if (added < bestAdded) {
+        bestAdded = added;
+        bestIdx = i;
+        bestX = x;
+      }
+    }
+    if (bestIdx < 0 || !bestX) return null;
+    const next = [];
+    for (let k = 0; k < n; k++) {
+      if (k === bestIdx) next.push(bestX);
+      else if (k !== (bestIdx + 1) % n) next.push(pts[k]);
+    }
+    pts = next;
+  }
+  return pts;
+}
+function forwardIntersection(a0, a1, b0, b1) {
+  const dax = a1.x - a0.x, day = a1.y - a0.y, dbx = b1.x - b0.x, dby = b1.y - b0.y;
+  const den = dax * dby - day * dbx;
+  if (Math.abs(den) < 1e-9) return null;
+  const t = ((b0.x - a0.x) * dby - (b0.y - a0.y) * dbx) / den;
+  const u = ((b0.x - a0.x) * day - (b0.y - a0.y) * dax) / den;
+  if (t < 1 || u < 1) return null;
+  return { x: a0.x + t * dax, y: a0.y + t * day };
+}
+function spansFrame(pts, W, H, limit) {
+  const xs = pts.map((p) => p.x), ys = pts.map((p) => p.y);
+  return Math.min(...xs) <= limit && Math.max(...xs) >= W - limit || Math.min(...ys) <= limit && Math.max(...ys) >= H - limit;
+}
+function isNestedInCut(best, cut, gray) {
+  const margin = NESTED_MARGIN_PX * best.scale;
+  const nested = cut.some((o) => o.area >= NESTED_AREA_FACTOR * best.area && best.quad.every((p) => insideConvex(o.pts, p, margin)));
+  if (!nested) return false;
+  if (typeHintFromAspect(best.aspect) === "OTHER") return true;
+  const { inner, ring } = innerAndRingMeans(gray, insetQuad(best.quad, QUALITY_INSET_PX * best.scale), best.quad);
+  return inner < ring - POLARITY_MIN_DIFF;
+}
+function innerAndRingMeans(gray, inner, quad) {
+  const { data, width: W, height: H } = gray;
+  const cx = (quad[0].x + quad[1].x + quad[2].x + quad[3].x) / 4;
+  const cy = (quad[0].y + quad[1].y + quad[2].y + quad[3].y) / 4;
+  const outer = quad.map((p) => ({ x: cx + (p.x - cx) * POLARITY_RING_SCALE, y: cy + (p.y - cy) * POLARITY_RING_SCALE }));
+  const so = quadRowSpans(outer, W, H), sq = quadRowSpans(quad, W, H), si = quadRowSpans(inner, W, H);
+  let sumIn = 0, nIn = 0, sumRing = 0, nRing = 0;
+  for (let y = 0; y < H; y++) {
+    const xs = so[y * 2], xe = so[y * 2 + 1];
+    if (xs >= xe) continue;
+    const qs = sq[y * 2], qe = sq[y * 2 + 1], is = si[y * 2], ie = si[y * 2 + 1];
+    const row = y * W;
+    for (let x = xs; x < xe; x++) {
+      const v = data[row + x];
+      if (x >= is && x < ie) {
+        sumIn += v;
+        nIn++;
+      } else if (x < qs || x >= qe) {
+        sumRing += v;
+        nRing++;
+      }
+    }
+  }
+  return { inner: nIn > 0 ? sumIn / nIn : 0, ring: nRing > 0 ? sumRing / nRing : 0 };
+}
+function insideConvex(poly, p, margin) {
+  let twiceArea = 0;
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i], b = poly[(i + 1) % poly.length];
+    twiceArea += a.x * b.y - b.x * a.y;
+  }
+  const winding = Math.sign(twiceArea);
+  if (winding === 0) return false;
+  for (let i = 0; i < poly.length; i++) {
+    const a = poly[i], b = poly[(i + 1) % poly.length];
+    const len = Math.hypot(b.x - a.x, b.y - a.y);
+    if (len === 0) continue;
+    const dist = winding * ((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) / len;
+    if (dist < margin) return false;
+  }
+  return true;
+}
+function insetQuad(quad, d) {
+  return quad.map((p, i) => {
+    const prev = quad[(i + 3) % 4], next = quad[(i + 1) % 4];
+    const ux = prev.x - p.x, uy = prev.y - p.y, vx = next.x - p.x, vy = next.y - p.y;
+    const lu = Math.hypot(ux, uy), lv = Math.hypot(vx, vy);
+    const bx = ux / lu + vx / lv, by = uy / lu + vy / lv;
+    const lb = Math.hypot(bx, by);
+    const sinHalf = Math.sin(Math.acos(Math.min(1, Math.max(-1, (ux * vx + uy * vy) / (lu * lv)))) / 2);
+    const k = d / sinHalf / lb;
+    return { x: p.x + bx * k, y: p.y + by * k };
+  });
+}
+function borderCorners(pts, W, H, limit) {
+  let n = 0;
+  for (const p of pts) {
+    if (p.x <= limit || p.x >= W - limit || p.y <= limit || p.y >= H - limit) n++;
+  }
+  return n;
+}
+function medianOf(data) {
+  const hist = new Uint32Array(256);
+  for (let i = 0; i < data.length; i++) hist[data[i]]++;
+  let acc = 0;
+  for (let v = 0; v < 256; v++) {
+    acc += hist[v];
+    if (acc >= data.length / 2) return v;
+  }
+  return 128;
+}
+
+// src/core/cv-warp.ts
+var DEFAULT_WARP_LONG_SIDE = 1024;
+function warpDocumentImageData(cv, source, corners, docType, longSide = DEFAULT_WARP_LONG_SIDE) {
+  const ratio = clampAspect(canonicalRatioFor(docType, rectifiedAspect(corners)));
+  const shortSide = Math.max(1, Math.round(longSide / ratio));
+  const s = sideLengths(corners);
+  const portrait = s.top + s.bottom < s.left + s.right;
+  const fixedLandscape = docType === "INE" || docType === "PASSPORT_MX";
+  const q = portrait && fixedLandscape ? [corners[3], corners[0], corners[1], corners[2]] : corners;
+  const landscapeOut = !portrait || fixedLandscape;
+  const outW = landscapeOut ? longSide : shortSide;
+  const outH = landscapeOut ? shortSide : longSide;
+  let src = null;
+  let dst = null;
+  let srcPts = null;
+  let dstPts = null;
+  let M = null;
+  let rgba = null;
+  try {
+    src = cv.matFromImageData(source);
+    dst = new cv.Mat();
+    srcPts = cv.matFromArray(4, 1, cv.CV_32FC2, [
+      q[0].x,
+      q[0].y,
+      q[1].x,
+      q[1].y,
+      q[2].x,
+      q[2].y,
+      q[3].x,
+      q[3].y
+    ]);
+    dstPts = cv.matFromArray(4, 1, cv.CV_32FC2, [0, 0, outW, 0, outW, outH, 0, outH]);
+    M = cv.getPerspectiveTransform(srcPts, dstPts);
+    cv.warpPerspective(
+      src,
+      dst,
+      M,
+      new cv.Size(outW, outH),
+      cv.INTER_LINEAR,
+      cv.BORDER_CONSTANT,
+      new cv.Scalar(0, 0, 0, 255)
+    );
+    if (dst.channels() !== 4) {
+      rgba = new cv.Mat();
+      cv.cvtColor(dst, rgba, cv.COLOR_BGR2RGBA);
+    }
+    return makeImageData(new Uint8ClampedArray((rgba ?? dst).data), outW, outH);
+  } finally {
+    for (const m of [rgba, M, dstPts, srcPts, dst, src]) m?.delete();
+  }
+}
+function clampAspect(ratio) {
+  if (!Number.isFinite(ratio)) return CAPTURABLE_ASPECT_MIN;
+  return Math.min(CAPTURABLE_ASPECT_MAX, Math.max(CAPTURABLE_ASPECT_MIN, ratio));
+}
+function makeImageData(data, width, height) {
+  if (typeof globalThis.ImageData === "function") return new ImageData(data, width, height);
+  return { data, width, height, colorSpace: "srgb" };
+}
+
+// src/core/worker-protocol.ts
+var OPENCV_READY_TIMEOUT_MS = 3e4;
+function isQuad(v) {
+  return Array.isArray(v) && v.length === 4 && v.every((p) => !!p && typeof p === "object" && Number.isFinite(p.x) && Number.isFinite(p.y));
+}
+
+// src/core/cv-worker.ts
+var dynamicImport = (url) => import(
+  /* @vite-ignore */
+  /* webpackIgnore: true */
+  url
+);
+var errorMessage = (err) => err instanceof Error ? err.message : String(err);
+function isCv(m) {
+  return !!m && (typeof m === "object" || typeof m === "function") && typeof m.Mat === "function";
+}
+function stripThen(m) {
+  if (m && (typeof m === "object" || typeof m === "function") && !(m instanceof Promise) && typeof m.then === "function") {
+    delete m.then;
+    if (typeof m.then === "function") {
+      Object.defineProperty(m, "then", { value: void 0, configurable: true, writable: true });
+    }
+  }
+}
+function transferableBuffer(data) {
+  if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength && data.buffer instanceof ArrayBuffer) {
+    return data.buffer;
+  }
+  return data.slice().buffer;
+}
+async function loadOpenCV(url, opts = {}) {
+  const { importer = dynamicImport, timeoutMs = OPENCV_READY_TIMEOUT_MS, pollMs = 25 } = opts;
+  let timedOut = false;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      reject(new Error(`OpenCV from ${url} was not ready within ${timeoutMs} ms`));
+    }, timeoutMs);
+  });
+  const resolveModule = async () => {
+    let mod;
+    try {
+      mod = await importer(url);
+    } catch (err) {
+      throw new Error(`Failed to load OpenCV from ${url}: ${errorMessage(err)}`);
+    }
+    const ns = mod ?? {};
+    let m = ns.default ?? globalThis.cv ?? mod;
+    if (!isCv(m) && typeof m === "function") m = m();
+    if (m instanceof Promise) m = await m;
+    stripThen(m);
+    const ready = m?.ready;
+    if (!isCv(m) && ready instanceof Promise) await ready.then(() => void 0);
+    while (!isCv(m)) {
+      if (timedOut) throw new Error("timed out");
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+    return m;
+  };
+  try {
+    return await Promise.race([resolveModule(), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function installCvWorker(scope, deps = {}) {
+  const detect = deps.detect ?? ((cv2, img, opts) => detectDocumentCV(cv2, img, void 0, opts));
+  const warp = deps.warp ?? ((cv2, img, corners, docType, longSide) => warpDocumentImageData(cv2, img, corners, docType, longSide));
+  let cv = null;
+  let initStarted = false;
+  scope.addEventListener("message", async (e) => {
+    const msg = e.data;
+    if (!msg || typeof msg !== "object") return;
+    if (msg.type === "init") {
+      if (initStarted) return;
+      initStarted = true;
+      try {
+        cv = await loadOpenCV(msg.opencvUrl, deps);
+        scope.postMessage({ type: "ready" });
+      } catch (err) {
+        scope.postMessage({ type: "init-error", error: errorMessage(err) });
+      }
+      return;
+    }
+    if (msg.type !== "analyze" && msg.type !== "warp") return;
+    if (!cv) {
+      scope.postMessage({ type: "error", id: msg.id, error: "OpenCV not ready" });
+      return;
+    }
+    try {
+      const img = new ImageData(new Uint8ClampedArray(msg.buffer), msg.width, msg.height);
+      if (msg.type === "analyze") {
+        const opts = isQuad(msg.prior) ? { prior: msg.prior } : {};
+        scope.postMessage({ type: "analyze-result", id: msg.id, result: detect(cv, img, opts) });
+      } else {
+        const out = warp(cv, img, msg.corners, msg.docType, msg.longSide);
+        const buffer = transferableBuffer(out.data);
+        scope.postMessage({ type: "warp-result", id: msg.id, width: out.width, height: out.height, buffer }, [buffer]);
+      }
+    } catch (err) {
+      scope.postMessage({ type: "error", id: msg.id, error: errorMessage(err) });
+    }
+  });
+}
+if (typeof self !== "undefined" && typeof globalThis.document === "undefined") {
+  installCvWorker(self);
+}
+
+export { OPENCV_READY_TIMEOUT_MS, installCvWorker, loadOpenCV, transferableBuffer };