@scanfit/browser 0.1.0-alpha.0

package/dist/chunks/geometry-57LNKdIq.js

@@ -0,0 +1,37 @@
+import { S as n } from "./types-Bf5l1UNl.js";
+function m(r) {
+  if (!Array.isArray(r) || r.length !== 4 || r.some(
+    (e) => !e || !Number.isFinite(e.x) || !Number.isFinite(e.y) || e.x < 0 || e.x > 1 || e.y < 0 || e.y > 1
+  ))
+    throw new n(
+      "INVALID_CORNERS",
+      "Keep all four corners inside the image."
+    );
+  let t = 0;
+  for (let e = 0; e < 4; e++) {
+    const o = r[e], a = r[(e + 1) % 4], i = r[(e + 2) % 4];
+    if ((a.x - o.x) * (i.y - a.y) - (a.y - o.y) * (i.x - a.x) <= 1e-5)
+      throw new n(
+        "INVALID_CORNERS",
+        "Corners must form a clockwise, non-crossing document outline."
+      );
+    t += o.x * a.y - a.x * o.y;
+  }
+  if (t < 0.01)
+    throw new n("INVALID_CORNERS", "Select a larger document area.");
+}
+function c(r, t, e = 2400, o = 4e6) {
+  const a = Math.min(
+    1,
+    e / Math.max(r, t),
+    Math.sqrt(o / (r * t))
+  );
+  return {
+    width: Math.max(1, Math.floor(r * a)),
+    height: Math.max(1, Math.floor(t * a))
+  };
+}
+export {
+  c as f,
+  m as v
+};

package/dist/chunks/types-Bf5l1UNl.js

@@ -0,0 +1,35 @@
+class s extends Error {
+  constructor(a, n, o) {
+    super(n, o), this.code = a, this.name = "ScanError";
+  }
+  code;
+}
+const t = Object.freeze({
+  maxPages: 20,
+  maxFileBytes: 25 * 1024 ** 2,
+  maxPixels: 25e6,
+  maxSessionBytes: 100 * 1024 ** 2
+}), c = [
+  { x: 0, y: 0 },
+  { x: 1, y: 0 },
+  { x: 1, y: 1 },
+  { x: 0, y: 1 }
+], r = (e) => e.map((a) => ({ ...a }));
+function i(e) {
+  if (e?.aborted)
+    throw new DOMException("Operation cancelled", "AbortError");
+}
+function x(e) {
+  return e instanceof s ? e : new s(
+    "PROCESSING_FAILED",
+    e instanceof Error ? e.message : "Document processing failed. Please try again."
+  );
+}
+export {
+  t as D,
+  c as F,
+  s as S,
+  i as a,
+  x as b,
+  r as c
+};

package/dist/core.js

@@ -0,0 +1,572 @@
+import { S as w, a as _, D as M, b as C, c as T } from "./chunks/types-Bf5l1UNl.js";
+import { F as K } from "./chunks/types-Bf5l1UNl.js";
+import { f as B, v as R } from "./chunks/geometry-57LNKdIq.js";
+const P = () => new w(
+  "INVALID_INPUT",
+  "The image header is incomplete or invalid. Choose another photo."
+);
+function A(t, e, i) {
+  try {
+    if (e + 8 > i) return;
+    const n = t.getUint32(e) === 1165519206 && t.getUint16(e + 4) === 0, f = e + (n ? 6 : 0);
+    if (f + 8 > i) return;
+    const g = t.getUint16(f) === 18761;
+    if (!g && t.getUint16(f) !== 19789 || t.getUint16(f + 2, g) !== 42)
+      return;
+    const s = f + t.getUint32(f + 4, g);
+    if (s < f || s + 2 > i) return;
+    const c = Math.min(t.getUint16(s, g), 256);
+    for (let r = 0; r < c; r++) {
+      const o = s + 2 + r * 12;
+      if (o + 12 > i) return;
+      if (t.getUint16(o, g) === 274 && t.getUint16(o + 2, g) === 3 && t.getUint32(o + 4, g) === 1) {
+        const h = t.getUint16(o + 8, g);
+        return h >= 1 && h <= 8 ? h : void 0;
+      }
+    }
+  } catch {
+  }
+}
+function z(t) {
+  const e = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  let i = 0, n = 0, f = 1, g = !1, s = "";
+  const c = (r) => {
+    !g && r !== void 0 && (f = r, g = !0);
+  };
+  if (t.length >= 24 && e.getUint32(0) === 2303741511 && e.getUint32(4) === 218765834) {
+    if (e.getUint32(12) !== 1229472850 || e.getUint32(8) !== 13) throw P();
+    i = e.getUint32(16), n = e.getUint32(20), s = "image/png";
+    for (let r = 8; r + 12 <= t.length; ) {
+      const o = e.getUint32(r), h = e.getUint32(r + 4), l = r + 8;
+      if (l + o + 4 > t.length) throw P();
+      if (h === 1633899596)
+        throw new w(
+          "UNSUPPORTED_FORMAT",
+          "Animated PNG is not supported. Choose a still photo."
+        );
+      h === 1700284774 && c(A(e, l, l + o)), r = l + o + 4;
+    }
+  } else if (t.length >= 4 && e.getUint16(0) === 65496) {
+    s = "image/jpeg";
+    let r = 2;
+    for (; r + 3 < t.length; ) {
+      if (t[r++] !== 255) throw P();
+      for (; t[r] === 255; ) r++;
+      const o = t[r++];
+      if (o === 218 || o === 217) break;
+      if (o === 1 || o >= 208 && o <= 215) continue;
+      if (r + 2 > t.length) throw P();
+      const h = e.getUint16(r);
+      if (h < 2 || r + h > t.length) throw P();
+      if (o === 225 && h >= 8 && e.getUint32(r + 2) === 1165519206 && e.getUint16(r + 6) === 0 && c(A(e, r + 2, r + h)), o >= 192 && o <= 207 && ![196, 200, 204].includes(o)) {
+        if (h < 8) throw P();
+        const l = e.getUint16(r + 3), b = e.getUint16(r + 5);
+        if (i && i !== b || n && n !== l) throw P();
+        n = l, i = b;
+      }
+      r += h;
+    }
+  } else if (t.length >= 30 && e.getUint32(0) === 1380533830 && e.getUint32(8) === 1464156752) {
+    s = "image/webp";
+    for (let r = 12; r + 8 <= t.length; ) {
+      const o = e.getUint32(r), h = e.getUint32(r + 4, !0), l = r + 8;
+      if (l + h > t.length) throw P();
+      if (o === 1448097880 && h >= 10) {
+        if (t[l] & 2)
+          throw new w(
+            "UNSUPPORTED_FORMAT",
+            "Animated WebP is not supported. Choose a still photo."
+          );
+        i = Math.max(
+          i,
+          1 + t[l + 4] + (t[l + 5] << 8) + (t[l + 6] << 16)
+        ), n = Math.max(
+          n,
+          1 + t[l + 7] + (t[l + 8] << 8) + (t[l + 9] << 16)
+        );
+      }
+      if (o === 1448097824 && h >= 10 && t[l + 3] === 157 && t[l + 4] === 1 && t[l + 5] === 42 && (i = Math.max(i, e.getUint16(l + 6, !0) & 16383), n = Math.max(n, e.getUint16(l + 8, !0) & 16383)), o === 1448097868 && h >= 5 && t[l] === 47) {
+        const b = e.getUint32(l + 1, !0);
+        i = Math.max(i, (b & 16383) + 1), n = Math.max(n, (b >>> 14 & 16383) + 1);
+      }
+      o === 1163413830 && c(A(e, l, l + h)), r = l + h + (h & 1);
+    }
+  } else
+    throw new w(
+      "UNSUPPORTED_FORMAT",
+      "Choose a JPEG, PNG, or WebP photo. PDF and HEIC imports are not included in this beta."
+    );
+  if (!i || !n || !Number.isSafeInteger(i * n)) throw P();
+  return { width: i, height: n, orientation: f, mime: s };
+}
+async function F(t, e) {
+  if (!t.size) throw P();
+  if (t.size > e.maxFileBytes)
+    throw new w(
+      "LIMIT_EXCEEDED",
+      "This photo exceeds the input file-size limit. Choose a smaller photo."
+    );
+  const i = z(new Uint8Array(await t.arrayBuffer()));
+  if (i.width * i.height > e.maxPixels)
+    throw new w(
+      "LIMIT_EXCEEDED",
+      "This photo exceeds the pixel limit. Export it at a lower resolution."
+    );
+  return i;
+}
+async function j(t) {
+  const e = new Uint8Array(await t.arrayBuffer());
+  if (e.length < 4 || e[0] !== 255 || e[1] !== 216)
+    return t;
+  const i = [];
+  let n = 2, f = 0, g = !1;
+  for (; n + 3 < e.length && e[n] === 255; ) {
+    const s = n;
+    for (; e[n] === 255; ) n++;
+    const c = e[n++];
+    if (c === 218 || c === 217) break;
+    if (c === 1 || c >= 208 && c <= 215) continue;
+    if (n + 2 > e.length) break;
+    const r = e[n] << 8 | e[n + 1];
+    if (r < 2 || n + r > e.length) break;
+    const o = n + r;
+    c === 225 && (i.push(e.slice(f, s)), f = o, g = !0), n = o;
+  }
+  return g ? (i.push(e.slice(f)), new Blob(i, { type: "image/jpeg" })) : t;
+}
+async function W(t) {
+  const e = document.createElement("canvas");
+  let i, n;
+  try {
+    if (t.kind === "decode") {
+      e.width = t.width, e.height = t.height;
+      const c = e.getContext("2d", { willReadFrequently: !0 });
+      if (!c)
+        throw new w("UNSUPPORTED_BROWSER", "A 2D canvas is required.");
+      if (typeof createImageBitmap == "function")
+        try {
+          const o = {
+            imageOrientation: "from-image",
+            resizeWidth: t.width,
+            resizeHeight: t.height,
+            resizeQuality: "high"
+          }, h = t.region;
+          i = h ? await createImageBitmap(
+            t.blob,
+            h.x,
+            h.y,
+            h.width,
+            h.height,
+            o
+          ) : await createImageBitmap(t.blob, o);
+        } catch {
+        }
+      if (i) c.drawImage(i, 0, 0, e.width, e.height);
+      else {
+        n = URL.createObjectURL(t.blob);
+        const o = new Image();
+        o.src = n, await o.decode();
+        const h = t.region;
+        h ? c.drawImage(
+          o,
+          h.x,
+          h.y,
+          h.width,
+          h.height,
+          0,
+          0,
+          e.width,
+          e.height
+        ) : c.drawImage(o, 0, 0, e.width, e.height), o.src = "";
+      }
+      const r = c.getImageData(0, 0, e.width, e.height);
+      return {
+        buffer: r.data.buffer,
+        width: r.width,
+        height: r.height
+      };
+    }
+    const f = B(t.width, t.height, t.longEdge);
+    e.width = t.width, e.height = t.height;
+    const g = e.getContext("2d");
+    if (!g)
+      throw new w("UNSUPPORTED_BROWSER", "A 2D canvas is required.");
+    g.putImageData(
+      new ImageData(
+        new Uint8ClampedArray(t.buffer),
+        t.width,
+        t.height
+      ),
+      0,
+      0
+    );
+    const s = document.createElement("canvas");
+    s.width = f.width, s.height = f.height;
+    try {
+      const c = s.getContext("2d");
+      c.fillStyle = "#fff", c.fillRect(0, 0, s.width, s.height), c.drawImage(e, 0, 0, s.width, s.height);
+      const r = await new Promise(
+        (o, h) => s.toBlob(
+          (l) => l ? o(l) : h(new Error("JPEG encoding failed.")),
+          "image/jpeg",
+          t.quality
+        )
+      );
+      if (r.type !== "image/jpeg")
+        throw new w(
+          "UNSUPPORTED_BROWSER",
+          "This browser cannot encode JPEG images."
+        );
+      return { blob: await j(r), ...f };
+    } finally {
+      s.width = s.height = 0;
+    }
+  } finally {
+    i?.close(), n && URL.revokeObjectURL(n), e.width = e.height = 0;
+  }
+}
+function V(t) {
+  return new Worker(
+    "" + new URL("assets/processor.worker-ILg2T47t.js", import.meta.url).href,
+    {
+      type: "module",
+      name: t?.name
+    }
+  );
+}
+class G {
+  constructor(e) {
+    this.url = e;
+  }
+  url;
+  worker = null;
+  sequence = 0;
+  generation = 0;
+  tail = Promise.resolve();
+  pending = /* @__PURE__ */ new Map();
+  ensure() {
+    if (this.worker) return this.worker;
+    if (typeof Worker > "u")
+      throw new w(
+        "UNSUPPORTED_BROWSER",
+        "This browser does not support processing workers."
+      );
+    if (this.url && new URL(this.url, location.href).origin !== location.origin)
+      throw new w(
+        "INVALID_INPUT",
+        "The processing worker must be served from the same origin."
+      );
+    const e = this.url ? new Worker(this.url, { type: "module" }) : new V({ name: "scanfit-processing" });
+    return this.worker = e, e.onmessage = async (i) => {
+      const n = i.data;
+      if (n.type === "bridge") {
+        try {
+          const g = await W(n.action);
+          this.worker === e && e.postMessage(
+            { type: "bridge-result", id: n.id, result: g },
+            "buffer" in g ? [g.buffer] : []
+          );
+        } catch (g) {
+          this.worker === e && e.postMessage({
+            type: "bridge-result",
+            id: n.id,
+            error: g instanceof Error ? g.message : "Canvas bridge failed."
+          });
+        }
+        return;
+      }
+      const f = this.pending.get(n.id);
+      if (f) {
+        if (n.type === "progress") {
+          f.progress?.(n.value);
+          return;
+        }
+        this.pending.delete(n.id), n.error ? f.reject(
+          new w(n.error.code ?? "PROCESSING_FAILED", n.error.message)
+        ) : f.resolve(n.result);
+      }
+    }, e.onerror = () => this.reset(
+      new w(
+        "PROCESSING_FAILED",
+        "The processing worker failed. Check worker/WASM permissions and try again."
+      )
+    ), e.onmessageerror = () => this.reset(
+      new w(
+        "PROCESSING_FAILED",
+        "Could not read the worker response."
+      )
+    ), e;
+  }
+  run(e, i, n) {
+    const f = this.generation, g = async () => {
+      if (_(i), f !== this.generation)
+        throw new DOMException("Operation cancelled", "AbortError");
+      const c = this.ensure(), r = ++this.sequence;
+      let o;
+      const h = () => this.reset(new DOMException("Operation cancelled", "AbortError"));
+      try {
+        return await new Promise((l, b) => {
+          this.pending.set(r, { resolve: l, reject: b, progress: n }), i?.addEventListener("abort", h, { once: !0 }), o = setTimeout(
+            () => this.reset(
+              new w(
+                "PROCESSING_FAILED",
+                "Processing timed out. Try fewer or smaller pages."
+              )
+            ),
+            12e4
+          );
+          try {
+            c.postMessage({ id: r, task: e });
+          } catch (U) {
+            this.pending.delete(r), b(U);
+          }
+        });
+      } finally {
+        clearTimeout(o), i?.removeEventListener("abort", h);
+      }
+    }, s = this.tail.then(g, g);
+    return this.tail = s.catch(() => {
+    }), s;
+  }
+  reset(e = new DOMException("Operation cancelled", "AbortError")) {
+    this.generation++, this.worker?.terminate(), this.worker = null;
+    for (const i of this.pending.values()) i.reject(e);
+    this.pending.clear();
+  }
+}
+function X(t = {}) {
+  const e = { ...M, ...t.limits }, i = { ...t.detectorOptions };
+  if (Object.values(e).some((a) => !Number.isSafeInteger(a) || a < 1))
+    throw new w(
+      "INVALID_INPUT",
+      "Safety limits must be positive integers."
+    );
+  if (i.minConfidence !== void 0 && (!Number.isFinite(i.minConfidence) || i.minConfidence < 0.15 || i.minConfidence > 0.95) || i.maxComponents !== void 0 && (!Number.isSafeInteger(i.maxComponents) || i.maxComponents < 1 || i.maxComponents > 16) || i.maxCandidates !== void 0 && (!Number.isSafeInteger(i.maxCandidates) || i.maxCandidates < 1 || i.maxCandidates > 64))
+    throw new w(
+      "INVALID_INPUT",
+      "Detector options are outside their supported ranges."
+    );
+  if (t.detectorModule && (typeof location > "u" || new URL(t.detectorModule, location.href).origin !== location.origin))
+    throw new w(
+      "INVALID_INPUT",
+      "Detector modules must be served from the same origin."
+    );
+  const n = t.detectorModule ? new URL(t.detectorModule, location.href).href : void 0, f = new G(t.workerUrl), g = /* @__PURE__ */ new Set();
+  let s = [], c = 0, r = !1, o = null, h = {
+    pages: [],
+    status: "idle",
+    progress: 0,
+    result: null,
+    error: null
+  };
+  const l = () => {
+    if (r)
+      throw new w("DISPOSED", "This scan session has been disposed.");
+  }, b = (a) => Object.freeze({
+    id: a.id,
+    width: a.width,
+    height: a.height,
+    sourceBytes: a.sourceBytes,
+    preview: a.preview,
+    thumbnail: a.thumbnail,
+    warnings: Object.freeze([...a.warnings]),
+    detection: a.detection ? Object.freeze({ ...a.detection }) : void 0,
+    edits: Object.freeze({
+      ...a.edits,
+      corners: Object.freeze(
+        T(a.edits.corners).map((d) => Object.freeze(d))
+      )
+    })
+  }), U = (a = {}) => {
+    if (!r) {
+      h = {
+        ...h,
+        ...a,
+        pages: Object.freeze(s.map(b))
+      };
+      for (const d of g) d();
+    }
+  }, y = () => {
+    c++, o?.abort(), o = null, U({ status: "idle", progress: 0, result: null, error: null });
+  }, v = (a) => {
+    const d = s.find((m) => m.id === a);
+    if (!d) throw new w("INVALID_INPUT", "This page no longer exists.");
+    return d;
+  };
+  function S(a, d) {
+    l(), y();
+    const m = c, u = new AbortController();
+    o = u;
+    const p = () => u.abort();
+    return d?.addEventListener("abort", p, { once: !0 }), d?.aborted && u.abort(), U({ status: a }), {
+      token: m,
+      signal: u.signal,
+      finish() {
+        d?.removeEventListener("abort", p), o === u && (o = null), !r && c === m && U({ status: "idle" });
+      }
+    };
+  }
+  function N(a, d) {
+    if (_(d), r || a !== c)
+      throw new DOMException("Operation cancelled", "AbortError");
+  }
+  return {
+    getSnapshot: () => h,
+    subscribe(a) {
+      return l(), g.add(a), () => {
+        g.delete(a);
+      };
+    },
+    async addFiles(a, { signal: d, replacePageId: m } = {}) {
+      const u = Array.from(a);
+      if (l(), !u.length) return [];
+      const p = m ? v(m) : void 0;
+      if (p && u.length !== 1)
+        throw new w("INVALID_INPUT", "Select one replacement photo.");
+      if (u.length + s.length - (p ? 1 : 0) > e.maxPages)
+        throw new w(
+          "LIMIT_EXCEEDED",
+          `The session allows at most ${e.maxPages} pages.`
+        );
+      if (u.some((I) => !(I instanceof Blob)))
+        throw new w("INVALID_INPUT", "Expected image files or blobs.");
+      if (u.reduce((I, D) => I + D.size, 0) + s.reduce((I, D) => I + D.sourceBytes, 0) - (p?.sourceBytes ?? 0) > e.maxSessionBytes)
+        throw new w(
+          "LIMIT_EXCEEDED",
+          "These photos exceed the session input limit. Choose fewer or smaller photos."
+        );
+      const E = S("importing", d), k = [];
+      try {
+        for (const I of u) {
+          N(E.token, E.signal);
+          const D = await F(I, e);
+          N(E.token, E.signal);
+          const x = await f.run(
+            {
+              kind: "analyze",
+              blob: I,
+              header: D,
+              options: {
+                detector: t.detector,
+                detectorModule: n,
+                detectorOptions: i
+              }
+            },
+            E.signal
+          );
+          N(E.token, E.signal), R(x.corners);
+          const O = {
+            id: p?.id ?? crypto.randomUUID(),
+            source: I,
+            sourceBytes: I.size,
+            width: x.width,
+            height: x.height,
+            preview: x.preview,
+            thumbnail: x.thumbnail,
+            warnings: x.warnings,
+            detection: x.detection,
+            edits: {
+              corners: T(x.corners),
+              rotation: 0,
+              filter: "natural"
+            }
+          };
+          s = p ? s.map((L) => L.id === p.id ? O : L) : [...s, O], k.push(b(O)), U({ progress: k.length / u.length });
+        }
+        return k;
+      } catch (I) {
+        if (I instanceof Error && I.name === "AbortError")
+          return k;
+        const D = C(I);
+        throw E.token === c && U({ error: D }), D;
+      } finally {
+        E.finish();
+      }
+    },
+    updatePage(a, d) {
+      l();
+      const m = v(a), u = { ...m.edits, ...d };
+      if (R(u.corners), ![0, 90, 180, 270].includes(u.rotation) || !["natural", "grayscale", "contrast"].includes(u.filter))
+        throw new w("INVALID_INPUT", "Invalid page edits.");
+      y(), s = s.map(
+        (p) => p.id === a ? { ...p, edits: { ...u, corners: T(u.corners) } } : p
+      ), U();
+    },
+    movePage(a, d) {
+      l();
+      const m = v(a);
+      if (!Number.isInteger(d) || d < 0 || d >= s.length)
+        throw new w("INVALID_INPUT", "Invalid page position.");
+      y(), s = s.filter((u) => u.id !== a), s.splice(d, 0, m), U();
+    },
+    removePage(a) {
+      l(), v(a), y(), s = s.filter((d) => d.id !== a), U();
+    },
+    async renderPage(a, d) {
+      l();
+      const m = v(a), u = c, p = await f.run({ kind: "render", page: m }, d);
+      return N(u, d), p;
+    },
+    async exportPdf(a) {
+      if (l(), !a || typeof a != "object") throw new w("INVALID_INPUT", "Provide export options with an explicit maxBytes limit.");
+      if (!s.length)
+        throw new w(
+          "INVALID_INPUT",
+          "Add at least one page before exporting."
+        );
+      const d = S("exporting", a.signal);
+      try {
+        const { signal: m, ...u } = a, p = await f.run(
+          { kind: "export", pages: [...s], options: u },
+          d.signal,
+          (I) => {
+            d.token === c && U({ progress: I });
+          }
+        );
+        N(d.token, d.signal);
+        const k = p.blob.size <= a.maxBytes ? {
+          status: "ready",
+          file: new File([p.blob], "document.pdf", {
+            type: "application/pdf"
+          }),
+          report: { ...p.report, bytes: p.blob.size }
+        } : {
+          status: "cannot-fit",
+          candidateBytes: p.blob.size,
+          report: p.report
+        };
+        return U({ result: k, progress: 1 }), k;
+      } catch (m) {
+        if (m instanceof Error && m.name === "AbortError")
+          return { status: "cancelled" };
+        const u = C(m);
+        throw d.token === c && U({ error: u }), u;
+      } finally {
+        d.finish();
+      }
+    },
+    cancel() {
+      l(), y(), f.reset();
+    },
+    dispose() {
+      r || (o?.abort(), r = !0, c++, f.reset(), s = [], h = {
+        pages: [],
+        status: "idle",
+        progress: 0,
+        result: null,
+        error: null
+      }, g.clear());
+    }
+  };
+}
+export {
+  M as DEFAULT_LIMITS,
+  K as FULL_QUAD,
+  w as ScanError,
+  _ as abortIfNeeded,
+  C as asScanError,
+  T as copyQuad,
+  X as createScanSession,
+  z as inspectImageBytes,
+  R as validateQuad
+};