@scanfit/browser 0.1.0-alpha.0

package/dist/assets/processor.worker-ILg2T47t.js

@@ -0,0 +1,1456 @@
+class $ extends Error {
+  constructor(e, n, o) {
+    super(n, o), this.code = e, this.name = "ScanError";
+  }
+  code;
+}
+const xt = [
+  { x: 0, y: 0 },
+  { x: 1, y: 0 },
+  { x: 1, y: 1 },
+  { x: 0, y: 1 }
+], wt = (t) => t.map((e) => ({ ...e }));
+function V(t) {
+  if (t?.aborted)
+    throw new DOMException("Operation cancelled", "AbortError");
+}
+function ht(t) {
+  if (!Array.isArray(t) || t.length !== 4 || t.some(
+    (n) => !n || !Number.isFinite(n.x) || !Number.isFinite(n.y) || n.x < 0 || n.x > 1 || n.y < 0 || n.y > 1
+  ))
+    throw new $(
+      "INVALID_CORNERS",
+      "Keep all four corners inside the image."
+    );
+  let e = 0;
+  for (let n = 0; n < 4; n++) {
+    const o = t[n], i = t[(n + 1) % 4], a = t[(n + 2) % 4];
+    if ((i.x - o.x) * (a.y - i.y) - (i.y - o.y) * (a.x - i.x) <= 1e-5)
+      throw new $(
+        "INVALID_CORNERS",
+        "Corners must form a clockwise, non-crossing document outline."
+      );
+    e += o.x * i.y - i.x * o.y;
+  }
+  if (e < 0.01)
+    throw new $("INVALID_CORNERS", "Select a larger document area.");
+}
+function rt(t, e, n = 2400, o = 4e6) {
+  const i = Math.min(
+    1,
+    n / Math.max(t, e),
+    Math.sqrt(o / (t * e))
+  );
+  return {
+    width: Math.max(1, Math.floor(t * i)),
+    height: Math.max(1, Math.floor(e * i))
+  };
+}
+function Mt(t) {
+  const [e, n, o, i] = t, a = n.x - o.x, c = i.x - o.x, r = e.x - n.x + o.x - i.x, l = n.y - o.y, f = i.y - o.y, s = e.y - n.y + o.y - i.y, h = a * f - c * l, d = Math.abs(r) + Math.abs(s) < 1e-12 ? 0 : (r * f - c * s) / h, p = Math.abs(r) + Math.abs(s) < 1e-12 ? 0 : (a * s - r * l) / h;
+  return [
+    n.x - e.x + d * n.x,
+    i.x - e.x + p * i.x,
+    e.x,
+    n.y - e.y + d * n.y,
+    i.y - e.y + p * i.y,
+    e.y,
+    d,
+    p
+  ];
+}
+function bt(t, e) {
+  ht(e.corners);
+  const n = e.corners.map((h) => ({
+    x: h.x * (t.width - 1),
+    y: h.y * (t.height - 1)
+  })), o = (h, d) => Math.hypot(n[h].x - n[d].x, n[h].y - n[d].y), i = rt(
+    Math.max(o(0, 1), o(3, 2)) + 1,
+    Math.max(o(0, 3), o(1, 2)) + 1
+  ), a = e.rotation === 90 || e.rotation === 270, c = a ? i.height : i.width, r = a ? i.width : i.height, l = new Uint8ClampedArray(c * r * 4), f = Mt(n), s = t.data;
+  for (let h = 0; h < r; h++)
+    for (let d = 0; d < c; d++) {
+      const p = c > 1 ? d / (c - 1) : 0, y = r > 1 ? h / (r - 1) : 0;
+      let m = p, x = y;
+      e.rotation === 90 ? (m = y, x = 1 - p) : e.rotation === 180 ? (m = 1 - p, x = 1 - y) : e.rotation === 270 && (m = 1 - y, x = p);
+      const b = f[6] * m + f[7] * x + 1, u = Math.max(
+        0,
+        Math.min(t.width - 1, (f[0] * m + f[1] * x + f[2]) / b)
+      ), g = Math.max(
+        0,
+        Math.min(t.height - 1, (f[3] * m + f[4] * x + f[5]) / b)
+      ), C = Math.floor(u), P = Math.floor(g), T = Math.min(C + 1, t.width - 1), U = Math.min(P + 1, t.height - 1), I = u - C, w = g - P, S = (P * t.width + C) * 4, A = (P * t.width + T) * 4, M = (U * t.width + C) * 4, F = (U * t.width + T) * 4, E = (1 - I) * (1 - w), v = I * (1 - w), N = (1 - I) * w, j = I * w, O = s[S + 3] / 255, B = s[A + 3] / 255, L = s[M + 3] / 255, at = s[F + 3] / 255, k = (h * c + d) * 4;
+      for (let D = 0; D < 3; D++)
+        l[k + D] = (s[S + D] * O + 255 * (1 - O)) * E + (s[A + D] * B + 255 * (1 - B)) * v + (s[M + D] * L + 255 * (1 - L)) * N + (s[F + D] * at + 255 * (1 - at)) * j;
+      if (e.filter === "grayscale") {
+        const D = 0.2126 * l[k] + 0.7152 * l[k + 1] + 0.0722 * l[k + 2];
+        l[k] = l[k + 1] = l[k + 2] = D;
+      } else if (e.filter === "contrast")
+        for (let D = 0; D < 3; D++)
+          l[k + D] = (l[k + D] - 128) * 1.15 + 128;
+      l[k + 3] = 255;
+    }
+  return new ImageData(l, c, r);
+}
+const It = 0.5, R = (t, e = 0, n = 1) => Math.max(e, Math.min(n, t)), ut = () => typeof performance > "u" ? Date.now() : performance.now();
+function Ut(t) {
+  const e = new Uint8Array(t.width * t.height);
+  for (let n = 0, o = 0; o < e.length; o++, n += 4) {
+    const i = t.data[n + 3] / 255, a = 77 * t.data[n] + 150 * t.data[n + 1] + 29 * t.data[n + 2] >> 8;
+    e[o] = Math.round(a * i + 255 * (1 - i));
+  }
+  return e;
+}
+function St(t, e, n) {
+  const o = Math.max(e, n) >= 600 ? 2 : 1, i = o * 2 + 1, a = new Uint8Array(t.length), c = new Uint8Array(t.length);
+  for (let r = 0; r < n; r++) {
+    const l = r * e;
+    for (let f = 0; f < e; f++) {
+      let s = 0;
+      for (let h = -o; h <= o; h++)
+        s += t[l + Math.max(0, Math.min(e - 1, f + h))];
+      a[l + f] = Math.round(s / i);
+    }
+  }
+  for (let r = 0; r < n; r++)
+    for (let l = 0; l < e; l++) {
+      let f = 0;
+      for (let s = -o; s <= o; s++)
+        f += a[Math.max(0, Math.min(n - 1, r + s)) * e + l];
+      c[r * e + l] = Math.round(f / i);
+    }
+  return c;
+}
+function At(t, e, n) {
+  const o = new Uint16Array(t.length), i = new Uint32Array(2041);
+  let a = 0;
+  for (let f = 1; f < n - 1; f++)
+    for (let s = 1; s < e - 1; s++) {
+      const h = f * e + s, d = -t[h - e - 1] + t[h - e + 1] - 2 * t[h - 1] + 2 * t[h + 1] - t[h + e - 1] + t[h + e + 1], p = -t[h - e - 1] - 2 * t[h - e] - t[h - e + 1] + t[h + e - 1] + 2 * t[h + e] + t[h + e + 1], y = Math.min(2040, Math.abs(d) + Math.abs(p));
+      o[h] = y, y && (i[y]++, a++);
+    }
+  let c = 0;
+  const r = a * 0.82;
+  let l = 0;
+  for (let f = 1; f < i.length; f++)
+    if (c += i[f], c >= r) {
+      l = f;
+      break;
+    }
+  return {
+    magnitude: o,
+    threshold: Math.round(R(l || 24, 24, 600)),
+    nonzero: a
+  };
+}
+function Ft(t, e, n, o) {
+  const i = new Uint8Array(t.length), a = new Int32Array(t.length), c = o * 0.42;
+  let r = 0, l = 0, f = 0;
+  for (let d = 0; d < t.length; d++)
+    t[d] >= o ? (i[d] = 2, a[l++] = d, f++) : t[d] >= c && (i[d] = 1);
+  for (; r < l; ) {
+    const d = a[r++], p = d % e, y = Math.floor(d / e);
+    for (let m = -1; m <= 1; m++)
+      for (let x = -1; x <= 1; x++) {
+        if (!x && !m || p + x < 0 || p + x >= e || y + m < 0 || y + m >= n)
+          continue;
+        const b = d + m * e + x;
+        i[b] === 1 && (i[b] = 2, a[l++] = b);
+      }
+  }
+  const s = new Uint8Array(i.length);
+  let h = 0;
+  for (let d = 0; d < i.length; d++)
+    i[d] === 2 && (s[d] = 1, h++);
+  return { binary: s, density: h / s.length, strong: f };
+}
+function Ct(t, e, n) {
+  const o = new Uint8Array(t.length);
+  for (let i = 1; i < n - 1; i++)
+    for (let a = 1; a < e - 1; a++) {
+      const c = i * e + a;
+      (t[c] || t[c - 1] || t[c + 1] || t[c - e] || t[c + e] || t[c - e - 1] || t[c - e + 1] || t[c + e - 1] || t[c + e + 1]) && (o[c] = 1);
+    }
+  return o;
+}
+function Pt(t) {
+  const e = new Uint32Array(256);
+  for (const r of t) e[r]++;
+  let n = 0;
+  for (let r = 0; r < 256; r++) n += r * e[r];
+  let o = 0, i = 0, a = -1, c = 127;
+  for (let r = 0; r < 255; r++) {
+    o += e[r], i += r * e[r];
+    const l = t.length - o;
+    if (!o || !l) continue;
+    const f = i / o - (n - i) / l, s = o * l * f * f;
+    s > a && (a = s, c = r);
+  }
+  return c;
+}
+function vt(t, e, n) {
+  const o = new Uint32Array(256);
+  let i = 0;
+  const a = (s) => {
+    o[s]++, i++;
+  };
+  for (let s = 0; s < e; s++)
+    a(t[s]), a(t[(n - 1) * e + s]);
+  for (let s = 1; s < n - 1; s++)
+    a(t[s * e]), a(t[s * e + e - 1]);
+  let c = 0, r = 127;
+  for (let s = 0; s < o.length; s++)
+    if (c += o[s], c >= i / 2) {
+      r = s;
+      break;
+    }
+  const l = new Uint32Array(256);
+  for (let s = 0; s < o.length; s++)
+    l[Math.abs(s - r)] += o[s];
+  c = 0;
+  let f = 0;
+  for (let s = 0; s < l.length; s++)
+    if (c += l[s], c >= i / 2) {
+      f = s;
+      break;
+    }
+  return { median: r, deviation: f };
+}
+function Et(t, e, n) {
+  const o = Pt(t), i = vt(t, e, n), a = new Uint8Array(t.length), c = new Uint8Array(t.length), r = new Uint8Array(t.length), l = Math.max(16, i.deviation * 2.5);
+  for (let f = 0; f < t.length; f++)
+    a[f] = t[f] > o ? 1 : 0, c[f] = t[f] <= o ? 1 : 0, r[f] = Math.abs(t[f] - i.median) >= l ? 1 : 0;
+  return { bright: a, dark: c, contrast: r };
+}
+function Nt(t, e, n, o, i) {
+  const a = new Uint8Array(t.length), c = new Int32Array(t.length), r = [], l = o ? Math.max(64, t.length * 0.025) : Math.max(40, (e + n) * 0.06);
+  for (let f = 0; f < t.length; f++) {
+    if (!t[f] || a[f]) continue;
+    let s = 0, h = 0, d = 0, p = 0, y = e, m = n, x = 0, b = 0, u = 0;
+    const g = [], C = new Array(8), P = [
+      1 / 0,
+      -1 / 0,
+      1 / 0,
+      -1 / 0,
+      1 / 0,
+      -1 / 0,
+      1 / 0,
+      -1 / 0
+    ];
+    for (c[h++] = f, a[f] = 1; s < h; ) {
+      const U = c[s++], I = U % e, w = Math.floor(U / e);
+      d++, y = Math.min(y, I), m = Math.min(m, w), x = Math.max(x, I), b = Math.max(b, w), (I === 0 || I === e - 1 || w === 0 || w === n - 1) && u++;
+      const S = [I + w, I + w, I - w, I - w, I, I, w, w];
+      for (let M = 0; M < 8; M++)
+        (M % 2 ? S[M] > P[M] : S[M] < P[M]) && (P[M] = S[M], C[M] = { x: I, y: w });
+      let A = !1;
+      for (let M = -1; M <= 1; M++)
+        for (let F = -1; F <= 1; F++) {
+          if (!F && !M) continue;
+          const E = I + F, v = w + M;
+          if (E < 0 || E >= e || v < 0 || v >= n) {
+            A = !0;
+            continue;
+          }
+          const N = v * e + E;
+          t[N] ? a[N] || (a[N] = 1, c[h++] = N) : A = !0;
+        }
+      if (A)
+        if (p++, g.length < 2048) g.push({ x: I, y: w });
+        else {
+          const M = (Math.imul(p, 2654435761) >>> 0) % p | 0;
+          M < g.length && (g[M] = { x: I, y: w });
+        }
+    }
+    const T = (x - y + 1) * (b - m + 1);
+    if (d >= l && T >= t.length * 0.055 && d < t.length * 0.985) {
+      for (const U of C) U && g.push(U);
+      r.push({ count: d, boundsArea: T, touches: u, boundary: g });
+    }
+  }
+  return r.sort(
+    (f, s) => s.boundsArea * Math.min(1, s.count / l) - f.boundsArea * Math.min(1, f.count / l)
+  ).slice(0, i);
+}
+const X = (t, e, n) => (e.x - t.x) * (n.y - t.y) - (e.y - t.y) * (n.x - t.x);
+function Tt(t) {
+  const e = [...t].sort((i, a) => i.x - a.x || i.y - a.y).filter(
+    (i, a, c) => !a || i.x !== c[a - 1].x || i.y !== c[a - 1].y
+  );
+  if (e.length <= 4) return e;
+  const n = [], o = [];
+  for (const i of e) {
+    for (; n.length >= 2 && X(n.at(-2), n.at(-1), i) <= 0; )
+      n.pop();
+    n.push(i);
+  }
+  for (let i = e.length - 1; i >= 0; i--) {
+    const a = e[i];
+    for (; o.length >= 2 && X(o.at(-2), o.at(-1), a) <= 0; )
+      o.pop();
+    o.push(a);
+  }
+  return n.pop(), o.pop(), [...n, ...o];
+}
+function $t(t) {
+  const e = [...t];
+  for (; e.length > 4; ) {
+    let n = 0, o = 1 / 0;
+    for (let i = 0; i < e.length; i++) {
+      const a = e[(i + e.length - 1) % e.length], c = e[i], r = e[(i + 1) % e.length], l = Math.abs(X(a, c, r));
+      l < o && (o = l, n = i);
+    }
+    e.splice(n, 1);
+  }
+  return e;
+}
+function Z(t, e) {
+  const n = Math.abs(t - e) % Math.PI;
+  return Math.min(n, Math.PI - n);
+}
+function q(t, e) {
+  const n = Math.cos(t.theta), o = Math.sin(t.theta), i = Math.cos(e.theta), a = Math.sin(e.theta), c = n * a - o * i;
+  return Math.abs(c) < 0.08 ? null : {
+    x: (t.rho * a - o * e.rho) / c,
+    y: (n * e.rho - t.rho * i) / c
+  };
+}
+function Dt(t, e, n, o) {
+  const i = [];
+  let a = 0;
+  for (let u = 1; u < o - 1; u++)
+    for (let g = 1; g < n - 1; g++)
+      if (!(t[u * n + g] < e))
+        if (a++, i.length < 5e3) i.push({ x: g, y: u });
+        else {
+          const C = (Math.imul(a, 2246822519) >>> 0) % a | 0;
+          C < i.length && (i[C] = { x: g, y: u });
+        }
+  if (i.length < 24) return [];
+  const c = 90, r = 2, l = Math.hypot(n, o), f = Math.ceil(l * 2 / r) + 1, s = new Uint16Array(c * f), h = new Float32Array(c), d = new Float32Array(c);
+  for (let u = 0; u < c; u++) {
+    const g = u * Math.PI / c;
+    h[u] = Math.cos(g), d[u] = Math.sin(g);
+  }
+  for (const u of i)
+    for (let g = 0; g < c; g++) {
+      const C = Math.round(
+        (u.x * h[g] + u.y * d[g] + l) / r
+      ), P = g * f + C;
+      s[P] < 65535 && s[P]++;
+    }
+  const p = Math.max(10, Math.round(Math.min(n, o) * 0.055)), y = [];
+  for (let u = 0; u < c; u++)
+    for (let g = 1; g < f - 1; g++) {
+      const C = s[u * f + g];
+      C < p || y.push({
+        theta: u * Math.PI / c,
+        rho: g * r - l,
+        votes: C
+      });
+    }
+  y.sort((u, g) => g.votes - u.votes);
+  const m = [];
+  for (const u of y)
+    if (!m.some(
+      (g) => Z(u.theta, g.theta) < 4 * Math.PI / c && Math.abs(u.rho - g.rho) < r * 5
+    ) && (m.push(u), m.length >= 28))
+      break;
+  const x = [];
+  for (let u = 0; u < m.length; u++)
+    for (let g = u + 1; g < m.length; g++) {
+      const C = Math.abs(m[u].rho - m[g].rho), P = Z(m[u].theta, m[g].theta);
+      P <= 16 * Math.PI / 180 && C >= Math.min(n, o) * 0.16 && x.push({
+        lines: [m[u], m[g]],
+        score: m[u].votes + m[g].votes - P * 180 / Math.PI
+      });
+    }
+  x.sort((u, g) => g.score - u.score);
+  const b = [];
+  for (let u = 0; u < Math.min(16, x.length); u++)
+    for (let g = u + 1; g < Math.min(16, x.length); g++) {
+      if (Z(
+        x[u].lines[0].theta,
+        x[g].lines[0].theta
+      ) < 38 * Math.PI / 180) continue;
+      const [P, T] = x[u].lines, [U, I] = x[g].lines, w = [
+        q(P, U),
+        q(T, U),
+        q(T, I),
+        q(P, I)
+      ];
+      w.some(
+        (S) => !S || S.x < -n * 0.03 || S.x > n * 1.03 || S.y < -o * 0.03 || S.y > o * 1.03
+      ) || b.push({
+        points: w,
+        source: "hough-lines",
+        score: x[u].score + x[g].score
+      });
+    }
+  return b.sort((u, g) => g.score - u.score).slice(0, 20).map(({ points: u, source: g }) => ({ points: u, source: g }));
+}
+function Rt(t) {
+  return t.length < 4 ? [] : [
+    (n) => n.x + n.y,
+    (n) => -(n.x - n.y),
+    (n) => -(n.x + n.y),
+    (n) => n.x - n.y
+  ].map(
+    (n) => t.reduce(
+      (o, i) => n(i) < n(o) ? i : o
+    )
+  );
+}
+function Ot(t, e, n) {
+  if (t.length !== 4 || new Set(t.map((r) => `${r.x},${r.y}`)).size !== 4)
+    return null;
+  const o = t.reduce(
+    (r, l) => ({
+      x: r.x + l.x / 4,
+      y: r.y + l.y / 4
+    }),
+    { x: 0, y: 0 }
+  );
+  let i = [...t].sort(
+    (r, l) => Math.atan2(r.y - o.y, r.x - o.x) - Math.atan2(l.y - o.y, l.x - o.x)
+  ), a = 0;
+  for (let r = 1; r < 4; r++)
+    i[r].x + i[r].y < i[a].x + i[a].y && (a = r);
+  i = [...i.slice(a), ...i.slice(0, a)], X(i[0], i[1], i[2]) < 0 && (i = [i[0], i[3], i[2], i[1]]);
+  const c = i.map((r) => ({
+    x: R(r.x / Math.max(1, e - 1)),
+    y: R(r.y / Math.max(1, n - 1))
+  }));
+  try {
+    return ht(c), c;
+  } catch {
+    return null;
+  }
+}
+function jt(t) {
+  let e = 0;
+  for (let n = 0; n < 4; n++) {
+    const o = t[n], i = t[(n + 1) % 4];
+    e += o.x * i.y - i.x * o.y;
+  }
+  return Math.abs(e) / 2;
+}
+function tt(t, e, n, o, i) {
+  const a = Math.max(0, Math.min(e - 1, Math.round(o))), c = Math.max(0, Math.min(n - 1, Math.round(i)));
+  return t[c * e + a];
+}
+function Lt(t, e, n, o, i, a) {
+  const c = jt(t);
+  if (c < 0.055 || c > 0.985) return null;
+  const r = t.map((U) => ({
+    x: U.x * (i - 1),
+    y: U.y * (a - 1)
+  })), l = r.map((U, I) => {
+    const w = r[(I + 1) % 4];
+    return {
+      dx: w.x - U.x,
+      dy: w.y - U.y,
+      length: Math.hypot(w.x - U.x, w.y - U.y)
+    };
+  }), f = Math.hypot(i, a), s = Math.min(...l.map((U) => U.length)) / f;
+  if (s < 0.055) return null;
+  let h = 0;
+  for (let U = 0; U < 4; U++) {
+    const I = r[(U + 3) % 4], w = r[U], S = r[(U + 1) % 4], A = I.x - w.x, M = I.y - w.y, F = S.x - w.x, E = S.y - w.y, v = Math.abs(
+      (A * F + M * E) / Math.max(1, Math.hypot(A, M) * Math.hypot(F, E))
+    );
+    h += 1 - R(v / 0.72);
+  }
+  h /= 4;
+  let d = 0, p = 0, y = 0, m = 0;
+  for (let U = 0; U < 4; U++) {
+    const I = r[U], w = l[U], S = Math.max(12, Math.min(180, Math.round(w.length / 2))), A = -w.dy / Math.max(1, w.length), M = w.dx / Math.max(1, w.length);
+    for (let F = 1; F < S; F++) {
+      const E = F / S, v = I.x + w.dx * E, N = I.y + w.dy * E;
+      let j = 0;
+      for (let L = -2; L <= 2; L++)
+        j = Math.max(
+          j,
+          tt(
+            n,
+            i,
+            a,
+            v + A * L,
+            N + M * L
+          )
+        );
+      d += j >= o * 0.7 ? 1 : 0, p += R(j / Math.max(1, o * 1.8));
+      const O = tt(
+        e,
+        i,
+        a,
+        v + A * 4,
+        N + M * 4
+      ), B = tt(
+        e,
+        i,
+        a,
+        v - A * 4,
+        N - M * 4
+      );
+      y += R(Math.abs(O - B) / 48), m++;
+    }
+  }
+  const x = m ? 0.67 * (d / m) + 0.33 * (p / m) : 0;
+  y = m ? y / m : 0;
+  const b = R((c - 0.055) / 0.3) * R((0.985 - c) / 0.08), u = R((s - 0.055) / 0.18), g = 0.72 * h + 0.28 * u, C = t.reduce(
+    (U, I) => U + R(
+      Math.min(I.x, I.y, 1 - I.x, 1 - I.y) / 0.025
+    ),
+    0
+  ) / 4, T = (0.43 * x + 0.2 * y + 0.15 * b + 0.17 * g + 0.05 * u) * (0.56 + 0.44 * C);
+  return {
+    score: T,
+    confidence: R((T - 0.3) / 0.55),
+    coverage: c,
+    edgeSupport: x,
+    contrast: y,
+    rectangularity: g
+  };
+}
+function W(t, e, n, o, i, a, c) {
+  return {
+    engine: "scanfit-classical",
+    confidence: e,
+    candidateCount: n,
+    edgeThreshold: o,
+    edgeDensity: i,
+    durationMs: Math.max(0, ut() - t),
+    coverage: a?.coverage ?? 0,
+    edgeSupport: a?.edgeSupport ?? 0,
+    contrast: a?.contrast ?? 0,
+    rectangularity: a?.rectangularity ?? 0,
+    fallbackReason: c
+  };
+}
+function kt(t, e = {}) {
+  const n = ut(), o = t.width, i = t.height;
+  if (!Number.isSafeInteger(o) || !Number.isSafeInteger(i) || o < 32 || i < 32 || t.data.length !== o * i * 4)
+    return {
+      corners: null,
+      confidence: 0,
+      diagnostics: W(
+        n,
+        0,
+        0,
+        0,
+        0,
+        void 0,
+        "invalid-image"
+      )
+    };
+  const a = St(Ut(t), o, i), c = At(a, o, i), r = Ft(
+    c.magnitude,
+    o,
+    i,
+    c.threshold
+  );
+  if (c.nonzero < t.width + t.height || r.strong < 8)
+    return {
+      corners: null,
+      confidence: 0,
+      diagnostics: W(
+        n,
+        0,
+        0,
+        c.threshold,
+        r.density,
+        void 0,
+        "uniform-image"
+      )
+    };
+  const l = Et(a, o, i), f = [
+    {
+      binary: Ct(r.binary, o, i),
+      source: "edges",
+      filled: !1
+    },
+    { binary: l.bright, source: "bright-region", filled: !0 },
+    { binary: l.dark, source: "dark-region", filled: !0 },
+    { binary: l.contrast, source: "border-contrast", filled: !0 }
+  ], s = Math.max(
+    1,
+    Math.min(
+      16,
+      Number.isSafeInteger(e.maxComponents) ? e.maxComponents : 8
+    )
+  ), h = [];
+  h.push(
+    ...Dt(
+      c.magnitude,
+      c.threshold,
+      o,
+      i
+    )
+  );
+  for (const b of f)
+    for (const u of Nt(
+      b.binary,
+      o,
+      i,
+      b.filled,
+      s
+    )) {
+      if (u.touches > u.count * 0.45 && u.boundsArea > o * i * 0.9)
+        continue;
+      const g = Tt(u.boundary);
+      g.length >= 4 && (h.push({ points: $t(g), source: b.source }), h.push({ points: Rt(g), source: b.source }));
+    }
+  const d = Math.max(
+    1,
+    Math.min(
+      64,
+      Number.isSafeInteger(e.maxCandidates) ? e.maxCandidates : 24
+    )
+  ), p = /* @__PURE__ */ new Map();
+  for (const b of h) {
+    const u = Ot(b.points, o, i);
+    if (!u) continue;
+    const g = u.map(
+      (C) => `${Math.round(C.x * 40)},${Math.round(C.y * 40)}`
+    ).join(";");
+    if (p.has(g) || p.set(g, { quad: u, source: b.source }), p.size >= d) break;
+  }
+  let y;
+  for (const b of p.values()) {
+    const u = Lt(
+      b.quad,
+      a,
+      c.magnitude,
+      c.threshold,
+      o,
+      i
+    );
+    u && (!y || u.score > y.metrics.score) && (y = { ...b, metrics: u });
+  }
+  const m = y?.metrics.confidence ?? 0, x = R(
+    Number.isFinite(e.minConfidence) ? e.minConfidence : It,
+    0.15,
+    0.95
+  );
+  return !y || m < x || y.metrics.edgeSupport < 0.28 ? {
+    corners: null,
+    confidence: m,
+    diagnostics: W(
+      n,
+      m,
+      p.size,
+      c.threshold,
+      r.density,
+      y?.metrics,
+      y ? "low-confidence" : "no-candidate"
+    )
+  } : {
+    corners: y.quad,
+    confidence: m,
+    diagnostics: {
+      ...W(
+        n,
+        m,
+        p.size,
+        c.threshold,
+        r.density,
+        y.metrics
+      ),
+      source: y.source
+    }
+  };
+}
+function zt(t = {}) {
+  return {
+    async detect(e) {
+      return kt(e, t);
+    }
+  };
+}
+var Bt = [
+  278,
+  278,
+  355,
+  556,
+  556,
+  889,
+  667,
+  191,
+  333,
+  333,
+  389,
+  584,
+  278,
+  333,
+  278,
+  278,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  556,
+  278,
+  278,
+  584,
+  584,
+  584,
+  556,
+  1015,
+  667,
+  667,
+  722,
+  722,
+  667,
+  611,
+  778,
+  722,
+  278,
+  500,
+  667,
+  556,
+  833,
+  722,
+  778,
+  667,
+  778,
+  722,
+  667,
+  611,
+  722,
+  667,
+  944,
+  667,
+  667,
+  611,
+  278,
+  278,
+  278,
+  469,
+  556,
+  333,
+  556,
+  556,
+  500,
+  556,
+  556,
+  278,
+  556,
+  556,
+  222,
+  222,
+  500,
+  222,
+  833,
+  556,
+  556,
+  556,
+  556,
+  333,
+  500,
+  278,
+  556,
+  500,
+  722,
+  500,
+  500,
+  500,
+  334,
+  260,
+  334,
+  584
+], _t = /* @__PURE__ */ new Map([
+  [8364, 128],
+  [8218, 130],
+  [402, 131],
+  [8222, 132],
+  [8230, 133],
+  [8224, 134],
+  [8225, 135],
+  [710, 136],
+  [8240, 137],
+  [352, 138],
+  [8249, 139],
+  [338, 140],
+  [381, 142],
+  [8216, 145],
+  [8217, 146],
+  [8220, 147],
+  [8221, 148],
+  [8226, 149],
+  [8211, 150],
+  [8212, 151],
+  [732, 152],
+  [8482, 153],
+  [353, 154],
+  [8250, 155],
+  [339, 156],
+  [382, 158],
+  [376, 159]
+]);
+class dt {
+  value;
+  constructor(e) {
+    this.value = e;
+  }
+}
+function st(t, e) {
+  G("Text size", e);
+  let n = 0;
+  for (const o of t) {
+    const i = gt(o);
+    n += i >= 32 && i <= 126 ? Bt[i - 32] : 556;
+  }
+  return n * e / 1e3;
+}
+function _(t, ...e) {
+  if (e.some((n) => !Number.isFinite(n)))
+    throw new TypeError(`${t} values must be finite numbers`);
+}
+function G(t, ...e) {
+  if (_(t, ...e), e.some((n) => n <= 0))
+    throw new RangeError(`${t} values must be greater than zero`);
+}
+function gt(t) {
+  const e = t.codePointAt(0), n = e <= 127 || e >= 160 && e <= 255 ? e : _t.get(e);
+  if (n === void 0)
+    throw new TypeError(`Unsupported character U+${e.toString(16).toUpperCase().padStart(4, "0")}; Helvetica text is limited to WinAnsi`);
+  return n;
+}
+function H(t) {
+  return !t || t === "none" || (t = t.replace(/^#/, ""), t.length === 3 && (t = t[0] + t[0] + t[1] + t[1] + t[2] + t[2]), !/^[0-9a-fA-F]{6}$/.test(t)) ? null : [parseInt(t.slice(0, 2), 16) / 255, parseInt(t.slice(2, 4), 16) / 255, parseInt(t.slice(4, 6), 16) / 255];
+}
+function J(t, e) {
+  return t ? `${t[0].toFixed(3)} ${t[1].toFixed(3)} ${t[2].toFixed(3)} ${e}` : "";
+}
+function Gt(t) {
+  if (t.length < 2 || t[0] !== 255 || t[1] !== 216)
+    throw new Error("Invalid JPEG: missing SOI marker");
+  let e = 2;
+  for (; e < t.length - 1; ) {
+    if (t[e] !== 255) {
+      e++;
+      continue;
+    }
+    const n = t[e + 1];
+    if (n === 218)
+      break;
+    if (n >= 192 && n <= 207 && ![196, 200, 204].includes(n)) {
+      if (e + 9 >= t.length)
+        break;
+      const a = t[e + 5] << 8 | t[e + 6], c = t[e + 7] << 8 | t[e + 8], r = t[e + 9];
+      if (c && a)
+        return { width: c, height: a, colorSpace: r === 1 ? "/DeviceGray" : r === 4 ? "/DeviceCMYK" : "/DeviceRGB" };
+    }
+    if (e + 3 >= t.length)
+      break;
+    const i = t[e + 2] << 8 | t[e + 3];
+    e += 2 + i;
+  }
+  throw new Error("Invalid JPEG: no valid SOF marker found");
+}
+function mt(t) {
+  let e = "(";
+  for (const n of t) {
+    const o = gt(n);
+    o === 92 || o === 40 || o === 41 ? e += "\\" + String.fromCharCode(o) : o === 13 ? e += "\\r" : o === 10 ? e += "\\n" : o < 32 || o >= 127 ? e += `\\${o.toString(8).padStart(3, "0")}` : e += String.fromCharCode(o);
+  }
+  return e + ")";
+}
+function Y(t) {
+  return t == null ? "null" : typeof t == "boolean" ? t ? "true" : "false" : typeof t == "number" ? Number.isInteger(t) ? String(t) : t.toFixed(4).replace(/\.?0+$/, "") : typeof t == "string" ? t : t instanceof dt ? mt(t.value) : Array.isArray(t) ? "[" + t.map(Y).join(" ") + "]" : t instanceof pt ? `${t.id} 0 R` : typeof t == "object" ? `<<
+` + Object.entries(t).filter(([n, o]) => o !== void 0).map(([n, o]) => `/${n} ${Y(o)}`).join(`
+`) + `
+>>` : String(t);
+}
+class pt {
+  id;
+  constructor(e) {
+    this.id = e;
+  }
+}
+function Qt() {
+  const t = [], e = [];
+  let n = 1;
+  function o(s, h = null) {
+    const d = n++;
+    return t.push({ id: d, dict: s, stream: h }), new pt(d);
+  }
+  function i(s, h, d) {
+    let p, y, m;
+    if (typeof s == "function" ? (p = 612, y = 792, m = s) : (p = s, y = h, m = d), G("Page dimensions", p, y), typeof m != "function")
+      throw new TypeError("page() requires a callback");
+    const x = [], b = [], u = [];
+    let g = 0;
+    m({
+      text(S, A, M, F, E = {}) {
+        _("Text coordinates", A, M), G("Text size", F);
+        const { align: v = "left", width: N, color: j = "#000000" } = E;
+        let O = A;
+        if (v !== "left" && N !== void 0) {
+          _("Text width", N);
+          const L = st(S, F);
+          v === "center" && (O = A + (N - L) / 2), v === "right" && (O = A + N - L);
+        }
+        const B = J(H(j), "rg") || "0.000 0.000 0.000 rg";
+        x.push(B, "BT", `/F1 ${F} Tf`, `${O.toFixed(2)} ${M.toFixed(2)} Td`, `${mt(S)} Tj`, "ET");
+      },
+      rect(S, A, M, F, E) {
+        _("Rectangle coordinates", S, A), G("Rectangle dimensions", M, F);
+        const v = J(H(E), "rg");
+        v && x.push(v, `${S.toFixed(2)} ${A.toFixed(2)} ${M.toFixed(2)} ${F.toFixed(2)} re`, "f");
+      },
+      line(S, A, M, F, E, v = 1) {
+        _("Line coordinates", S, A, M, F), G("Line width", v);
+        const N = J(H(E), "RG");
+        N && x.push(`${v.toFixed(2)} w`, N, `${S.toFixed(2)} ${A.toFixed(2)} m`, `${M.toFixed(2)} ${F.toFixed(2)} l`, "S");
+      },
+      image(S, A, M, F, E) {
+        _("Image coordinates", A, M), G("Image dimensions", F, E);
+        const { width: v, height: N, colorSpace: j } = Gt(S), O = `/Im${g++}`, B = o({
+          Type: "/XObject",
+          Subtype: "/Image",
+          Width: v,
+          Height: N,
+          ColorSpace: j,
+          BitsPerComponent: 8,
+          Filter: "/DCTDecode",
+          Length: S.length
+        }, S);
+        b.push({ name: O, ref: B }), x.push("q", `${F.toFixed(2)} 0 0 ${E.toFixed(2)} ${A.toFixed(2)} ${M.toFixed(2)} cm`, `${O} Do`, "Q");
+      },
+      link(S, A, M, F, E, v = {}) {
+        if (_("Link coordinates", A, M), G("Link dimensions", F, E), u.push({ url: S, rect: [A, M, A + F, M + E] }), v.underline) {
+          const N = J(H(v.underline), "RG");
+          N && x.push("0.75 w", N, `${A.toFixed(2)} ${(M + 2).toFixed(2)} m`, `${(A + F).toFixed(2)} ${(M + 2).toFixed(2)} l`, "S");
+        }
+      }
+    });
+    const P = x.join(`
+`), T = new TextEncoder().encode(P), U = o({ Length: T.length }, T), I = {};
+    for (const S of b)
+      I[S.name.slice(1)] = S.ref;
+    const w = u.map((S) => o({
+      Type: "/Annot",
+      Subtype: "/Link",
+      Rect: S.rect,
+      Border: [0, 0, 0],
+      A: { Type: "/Action", S: "/URI", URI: new dt(S.url) }
+    }));
+    e.push(o({
+      Type: "/Page",
+      Parent: null,
+      MediaBox: [0, 0, p, y],
+      Contents: U,
+      Resources: { Font: { F1: null }, XObject: Object.keys(I).length > 0 ? I : void 0 },
+      Annots: w.length > 0 ? w : void 0
+    }));
+  }
+  let a = !1;
+  function c() {
+    if (!e.length)
+      throw new Error("PDF must have at least one page");
+    if (a)
+      throw new Error("build() can only be called once");
+    a = !0;
+    const s = o({ Type: "/Font", Subtype: "/Type1", BaseFont: "/Helvetica", Encoding: "/WinAnsiEncoding" }), h = o({ Type: "/Pages", Kids: e, Count: e.length });
+    for (const d of t)
+      if (d.dict.Type === "/Page") {
+        d.dict.Parent = h;
+        const p = d.dict.Resources;
+        p?.Font && (p.Font.F1 = s);
+      }
+    return o({ Type: "/Catalog", Pages: h });
+  }
+  function* r(s) {
+    const h = new TextEncoder(), d = [];
+    let p = 0;
+    const y = h.encode(`%PDF-1.4
+%ÿÿÿÿ
+`);
+    p += y.length, yield y;
+    for (const b of t) {
+      d[b.id] = p;
+      const u = `${b.id} 0 obj
+${Y(b.dict)}
+`;
+      if (b.stream) {
+        const g = h.encode(u + `stream
+`), C = b.stream, P = h.encode(`
+endstream
+endobj
+`);
+        p += g.length, yield g, p += C.length, yield C, p += P.length, b.stream = null, yield P;
+      } else {
+        const g = h.encode(u + `endobj
+`);
+        p += g.length, yield g;
+      }
+    }
+    const m = p;
+    let x = `xref
+0 ${t.length + 1}
+0000000000 65535 f 
+`;
+    for (let b = 1; b <= t.length; b++)
+      x += String(d[b]).padStart(10, "0") + ` 00000 n 
+`;
+    x += `trailer
+${Y({ Size: t.length + 1, Root: s })}
+`, x += `startxref
+${m}
+%%EOF
+`, yield h.encode(x);
+  }
+  function l() {
+    const s = [];
+    let h = 0;
+    for (const y of r(c()))
+      s.push(y), h += y.length;
+    const d = new Uint8Array(h);
+    let p = 0;
+    for (const y of s)
+      d.set(y, p), p += y.length;
+    return d;
+  }
+  function f() {
+    const s = r(c());
+    return new ReadableStream({
+      pull(h) {
+        const { done: d, value: p } = s.next();
+        d ? h.close() : h.enqueue(p);
+      }
+    });
+  }
+  return { page: i, build: l, buildStream: f, measureText: st };
+}
+function Vt(t) {
+  if (!Number.isSafeInteger(t.maxBytes) || t.maxBytes < 1)
+    throw new $(
+      "INVALID_INPUT",
+      "maxBytes must be a positive integer number of bytes."
+    );
+  const e = t.minQuality ?? 0.65, n = t.minLongEdge ?? 1600;
+  if (!Number.isFinite(e) || e < 0.1 || e > 0.9)
+    throw new $(
+      "INVALID_INPUT",
+      "minQuality must be between 0.1 and 0.9."
+    );
+  if (!Number.isSafeInteger(n) || n < 128 || n > 2400)
+    throw new $(
+      "INVALID_INPUT",
+      "minLongEdge must be an integer between 128 and 2400."
+    );
+  if (t.pageSize && !["a4", "letter", "image"].includes(t.pageSize))
+    throw new $("INVALID_INPUT", "Unknown PDF page size.");
+}
+async function ct(t, e = "a4") {
+  if (!t.length)
+    throw new $(
+      "INVALID_INPUT",
+      "Add at least one page before exporting."
+    );
+  const n = Qt();
+  for (const o of t) {
+    const i = new Uint8Array(await o.jpeg.arrayBuffer());
+    if (o.jpeg.type !== "image/jpeg" || i[0] !== 255 || i[1] !== 216)
+      throw new $(
+        "PROCESSING_FAILED",
+        "The browser did not produce a valid JPEG."
+      );
+    const a = e === "a4" ? [595.28, 841.89] : e === "letter" ? [612, 792] : [o.width * 0.75, o.height * 0.75], c = Math.min(a[0] / o.width, a[1] / o.height), r = o.width * c, l = o.height * c;
+    n.page(
+      a[0],
+      a[1],
+      (f) => f.image(i, (a[0] - r) / 2, (a[1] - l) / 2, r, l)
+    );
+  }
+  return new Response(n.buildStream(), {
+    headers: { "Content-Type": "application/pdf" }
+  }).blob();
+}
+async function qt(t, e, n, o) {
+  if (Vt(n), !t.length)
+    throw new $(
+      "INVALID_INPUT",
+      "Add at least one page before exporting."
+    );
+  const i = t.map(() => 0), a = n.pageSize ?? "a4", c = async (s, h, d) => {
+    if (V(n.signal), i[s] >= 12)
+      throw new $(
+        "PROCESSING_FAILED",
+        "Encoding attempt limit reached."
+      );
+    i[s]++;
+    const p = await e.encode(s, h, d);
+    return V(n.signal), p;
+  }, r = [];
+  for (let s = 0; s < t.length; s++)
+    r.push(await c(s, 2400, 0.9)), o?.((s + 1) / t.length * 0.35);
+  let l = await ct(r, a);
+  if (V(n.signal), l.size > n.maxBytes) {
+    const s = r.map((m) => m.jpeg.size);
+    let h = Math.max(
+      0,
+      n.maxBytes - (l.size - s.reduce((m, x) => m + x, 0)) - 1024
+    ), d = s.reduce((m, x) => m + x, 0);
+    const p = n.minQuality ?? 0.65, y = [
+      ...new Set(
+        [0.9, 0.8, 0.7, p].filter((m) => m >= p)
+      )
+    ];
+    for (let m = 0; m < t.length; m++) {
+      const x = Math.max(
+        0,
+        Math.floor(h * s[m] / d)
+      ), b = r[m], u = Math.max(b.width, b.height), g = Math.min(u, n.minLongEdge ?? 1600), C = [
+        .../* @__PURE__ */ new Set([u, Math.round((u + g) / 2), g])
+      ];
+      let P = b, T = b.jpeg.size <= x;
+      t: for (const U of C)
+        for (const I of y) {
+          if (T) break t;
+          if (U === u && I === 0.9) continue;
+          const w = await c(m, U, I);
+          if (w.jpeg.size < P.jpeg.size && (P = w), w.jpeg.size <= x) {
+            P = w, T = !0;
+            break t;
+          }
+        }
+      r[m] = P, h -= P.jpeg.size, d -= s[m], o?.(0.35 + (m + 1) / t.length * 0.6);
+    }
+    l = await ct(r, a);
+  }
+  V(n.signal);
+  const f = {
+    bytes: l.size,
+    maxBytes: n.maxBytes,
+    pageSize: a,
+    limits: {
+      minQuality: n.minQuality ?? 0.65,
+      minLongEdge: n.minLongEdge ?? 1600,
+      maxEncodesPerPage: 12
+    },
+    pages: r.map(
+      (s, h) => ({
+        id: s.id,
+        imageBytes: s.jpeg.size,
+        width: s.width,
+        height: s.height,
+        quality: s.quality,
+        attempts: i[h],
+        warnings: s.warnings,
+        preview: s.jpeg
+      })
+    )
+  };
+  return o?.(1), {
+    status: l.size <= n.maxBytes ? "ready" : "cannot-fit",
+    blob: l,
+    report: f
+  };
+}
+const z = () => new $(
+  "INVALID_INPUT",
+  "The image header is incomplete or invalid. Choose another photo."
+);
+function et(t, e, n) {
+  try {
+    if (e + 8 > n) return;
+    const o = t.getUint32(e) === 1165519206 && t.getUint16(e + 4) === 0, i = e + (o ? 6 : 0);
+    if (i + 8 > n) return;
+    const a = t.getUint16(i) === 18761;
+    if (!a && t.getUint16(i) !== 19789 || t.getUint16(i + 2, a) !== 42)
+      return;
+    const c = i + t.getUint32(i + 4, a);
+    if (c < i || c + 2 > n) return;
+    const r = Math.min(t.getUint16(c, a), 256);
+    for (let l = 0; l < r; l++) {
+      const f = c + 2 + l * 12;
+      if (f + 12 > n) return;
+      if (t.getUint16(f, a) === 274 && t.getUint16(f + 2, a) === 3 && t.getUint32(f + 4, a) === 1) {
+        const s = t.getUint16(f + 8, a);
+        return s >= 1 && s <= 8 ? s : void 0;
+      }
+    }
+  } catch {
+  }
+}
+function Wt(t) {
+  const e = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  let n = 0, o = 0, i = 1, a = !1, c = "";
+  const r = (l) => {
+    !a && l !== void 0 && (i = l, a = !0);
+  };
+  if (t.length >= 24 && e.getUint32(0) === 2303741511 && e.getUint32(4) === 218765834) {
+    if (e.getUint32(12) !== 1229472850 || e.getUint32(8) !== 13) throw z();
+    n = e.getUint32(16), o = e.getUint32(20), c = "image/png";
+    for (let l = 8; l + 12 <= t.length; ) {
+      const f = e.getUint32(l), s = e.getUint32(l + 4), h = l + 8;
+      if (h + f + 4 > t.length) throw z();
+      if (s === 1633899596)
+        throw new $(
+          "UNSUPPORTED_FORMAT",
+          "Animated PNG is not supported. Choose a still photo."
+        );
+      s === 1700284774 && r(et(e, h, h + f)), l = h + f + 4;
+    }
+  } else if (t.length >= 4 && e.getUint16(0) === 65496) {
+    c = "image/jpeg";
+    let l = 2;
+    for (; l + 3 < t.length; ) {
+      if (t[l++] !== 255) throw z();
+      for (; t[l] === 255; ) l++;
+      const f = t[l++];
+      if (f === 218 || f === 217) break;
+      if (f === 1 || f >= 208 && f <= 215) continue;
+      if (l + 2 > t.length) throw z();
+      const s = e.getUint16(l);
+      if (s < 2 || l + s > t.length) throw z();
+      if (f === 225 && s >= 8 && e.getUint32(l + 2) === 1165519206 && e.getUint16(l + 6) === 0 && r(et(e, l + 2, l + s)), f >= 192 && f <= 207 && ![196, 200, 204].includes(f)) {
+        if (s < 8) throw z();
+        const h = e.getUint16(l + 3), d = e.getUint16(l + 5);
+        if (n && n !== d || o && o !== h) throw z();
+        o = h, n = d;
+      }
+      l += s;
+    }
+  } else if (t.length >= 30 && e.getUint32(0) === 1380533830 && e.getUint32(8) === 1464156752) {
+    c = "image/webp";
+    for (let l = 12; l + 8 <= t.length; ) {
+      const f = e.getUint32(l), s = e.getUint32(l + 4, !0), h = l + 8;
+      if (h + s > t.length) throw z();
+      if (f === 1448097880 && s >= 10) {
+        if (t[h] & 2)
+          throw new $(
+            "UNSUPPORTED_FORMAT",
+            "Animated WebP is not supported. Choose a still photo."
+          );
+        n = Math.max(
+          n,
+          1 + t[h + 4] + (t[h + 5] << 8) + (t[h + 6] << 16)
+        ), o = Math.max(
+          o,
+          1 + t[h + 7] + (t[h + 8] << 8) + (t[h + 9] << 16)
+        );
+      }
+      if (f === 1448097824 && s >= 10 && t[h + 3] === 157 && t[h + 4] === 1 && t[h + 5] === 42 && (n = Math.max(n, e.getUint16(h + 6, !0) & 16383), o = Math.max(o, e.getUint16(h + 8, !0) & 16383)), f === 1448097868 && s >= 5 && t[h] === 47) {
+        const d = e.getUint32(h + 1, !0);
+        n = Math.max(n, (d & 16383) + 1), o = Math.max(o, (d >>> 14 & 16383) + 1);
+      }
+      f === 1163413830 && r(et(e, h, h + s)), l = h + s + (s & 1);
+    }
+  } else
+    throw new $(
+      "UNSUPPORTED_FORMAT",
+      "Choose a JPEG, PNG, or WebP photo. PDF and HEIC imports are not included in this beta."
+    );
+  if (!n || !o || !Number.isSafeInteger(n * o)) throw z();
+  return { width: n, height: o, orientation: i, mime: c };
+}
+async function Ht(t) {
+  const e = new Uint8Array(await t.arrayBuffer());
+  if (e.length < 4 || e[0] !== 255 || e[1] !== 216)
+    return t;
+  const n = [];
+  let o = 2, i = 0, a = !1;
+  for (; o + 3 < e.length && e[o] === 255; ) {
+    const c = o;
+    for (; e[o] === 255; ) o++;
+    const r = e[o++];
+    if (r === 218 || r === 217) break;
+    if (r === 1 || r >= 208 && r <= 215) continue;
+    if (o + 2 > e.length) break;
+    const l = e[o] << 8 | e[o + 1];
+    if (l < 2 || o + l > e.length) break;
+    const f = o + l;
+    r === 225 && (n.push(e.slice(i, c)), i = f, a = !0), o = f;
+  }
+  return a ? (n.push(e.slice(i)), new Blob(n, { type: "image/jpeg" })) : t;
+}
+const Q = self;
+let Jt = 0;
+const ot = /* @__PURE__ */ new Map();
+function yt(t) {
+  return new Promise((e, n) => {
+    const o = ++Jt;
+    ot.set(o, { resolve: e, reject: n }), Q.postMessage(
+      { type: "bridge", id: o, action: t },
+      t.kind === "encode" ? [t.buffer] : []
+    );
+  });
+}
+let nt, lt;
+async function it(t, e, n = 2400, o) {
+  const i = e.orientation >= 5, a = rt(
+    o?.width ?? (i ? e.height : e.width),
+    o?.height ?? (i ? e.width : e.height),
+    n
+  );
+  if (typeof OffscreenCanvas < "u" && typeof createImageBitmap == "function") {
+    let r, l;
+    try {
+      const f = {
+        imageOrientation: "from-image",
+        resizeWidth: a.width,
+        resizeHeight: a.height,
+        resizeQuality: "high"
+      };
+      r = o ? await createImageBitmap(
+        t,
+        o.x,
+        o.y,
+        o.width,
+        o.height,
+        f
+      ) : await createImageBitmap(t, f), l = new OffscreenCanvas(a.width, a.height);
+      const s = l.getContext("2d", { willReadFrequently: !0 });
+      return s.drawImage(r, 0, 0, a.width, a.height), s.getImageData(0, 0, a.width, a.height);
+    } catch {
+    } finally {
+      r?.close(), l && (l.width = l.height = 0);
+    }
+  }
+  const c = await yt({ kind: "decode", blob: t, ...a, region: o });
+  return new ImageData(
+    new Uint8ClampedArray(c.buffer),
+    c.width,
+    c.height
+  );
+}
+async function K(t, e, n) {
+  const o = rt(t.width, t.height, e);
+  if (typeof OffscreenCanvas < "u") {
+    const i = new OffscreenCanvas(t.width, t.height), a = new OffscreenCanvas(o.width, o.height);
+    try {
+      i.getContext("2d").putImageData(t, 0, 0);
+      const c = a.getContext("2d");
+      c.fillStyle = "#fff", c.fillRect(0, 0, a.width, a.height), c.drawImage(i, 0, 0, a.width, a.height);
+      const r = await a.convertToBlob({ type: "image/jpeg", quality: n });
+      if (r.type === "image/jpeg")
+        return { blob: await Ht(r), ...o };
+    } catch {
+    } finally {
+      i.width = i.height = a.width = a.height = 0;
+    }
+  }
+  return yt({
+    kind: "encode",
+    buffer: t.data.slice().buffer,
+    width: t.width,
+    height: t.height,
+    quality: n,
+    longEdge: e
+  });
+}
+function Kt(t) {
+  const { width: e, height: n, data: o } = t;
+  let i = 0, a = 0, c = 0;
+  const r = (f) => 0.2126 * o[f] + 0.7152 * o[f + 1] + 0.0722 * o[f + 2];
+  for (let f = 1; f < n - 1; f += 3)
+    for (let s = 1; s < e - 1; s += 3) {
+      const h = (f * e + s) * 4, d = r(h);
+      i += d;
+      const p = r(h - 4) + r(h + 4) + r(h - e * 4) + r(h + e * 4) - 4 * d;
+      a += p * p, c++;
+    }
+  const l = [];
+  return c && i / c < 55 && l.push("possibly-dark"), c && a / c < 12 && l.push("possibly-blurry"), l;
+}
+async function ft(t) {
+  const e = Wt(
+    new Uint8Array(await t.source.arrayBuffer())
+  ), n = t.edits.corners.map((r) => ({
+    x: r.x * (t.width - 1),
+    y: r.y * (t.height - 1)
+  })), o = Math.floor(Math.min(...n.map((r) => r.x))), i = Math.floor(Math.min(...n.map((r) => r.y))), a = {
+    x: o,
+    y: i,
+    width: Math.ceil(Math.max(...n.map((r) => r.x))) - o + 1,
+    height: Math.ceil(Math.max(...n.map((r) => r.y))) - i + 1
+  }, c = n.map((r) => ({
+    x: (r.x - o) / Math.max(1, a.width - 1),
+    y: (r.y - i) / Math.max(1, a.height - 1)
+  }));
+  return bt(await it(t.source, e, 2400, a), {
+    ...t.edits,
+    corners: c
+  });
+}
+async function Xt(t, e) {
+  if (t.kind === "analyze") {
+    const i = await it(t.blob, t.header, 1200), a = await it(t.blob, t.header, 800);
+    let c = wt(xt), r;
+    const l = Kt(a);
+    if (t.options.detector !== "none")
+      try {
+        (!nt || lt !== t.options.detectorModule) && (nt = t.options.detectorModule ? await (await import(
+          /* @vite-ignore */
+          t.options.detectorModule
+        )).createDetector(t.options.detectorOptions) : zt(t.options.detectorOptions), lt = t.options.detectorModule);
+        const y = await nt.detect(a);
+        r = y.diagnostics, y.corners ? c = y.corners : l.push("manual-crop");
+      } catch {
+        l.push("detection-unavailable", "manual-crop");
+      }
+    else l.push("manual-crop");
+    const f = await K(i, 1200, 0.88), s = await K(i, 256, 0.75), h = t.header.orientation >= 5, d = h ? t.header.height : t.header.width, p = h ? t.header.width : t.header.height;
+    return Math.max(d, p) < 1600 && l.push("low-resolution"), {
+      preview: f.blob,
+      thumbnail: s.blob,
+      width: d,
+      height: p,
+      corners: c,
+      warnings: l,
+      detection: r
+    };
+  }
+  if (t.kind === "render")
+    return (await K(await ft(t.page), 1200, 0.88)).blob;
+  let n = -1, o = null;
+  try {
+    return await qt(
+      t.pages,
+      {
+        async encode(i, a, c) {
+          n !== i && (o = null, o = await ft(t.pages[i]), n = i);
+          const r = await K(o, a, c), l = t.pages[i];
+          return {
+            id: l.id,
+            jpeg: r.blob,
+            width: r.width,
+            height: r.height,
+            quality: c,
+            warnings: l.warnings
+          };
+        }
+      },
+      t.options,
+      (i) => Q.postMessage({ type: "progress", id: e, value: i })
+    );
+  } finally {
+    o = null;
+  }
+}
+Q.onmessage = (t) => {
+  const e = t.data;
+  if (e.type === "bridge-result") {
+    const n = ot.get(e.id);
+    n && (ot.delete(e.id), e.error ? n.reject(new Error(e.error)) : n.resolve(e.result));
+    return;
+  }
+  Xt(e.task, e.id).then((n) => Q.postMessage({ id: e.id, result: n })).catch(
+    (n) => Q.postMessage({
+      id: e.id,
+      error: {
+        code: n.code ?? "PROCESSING_FAILED",
+        message: n.message ?? "Document processing failed."
+      }
+    })
+  );
+};