three-slicer-viewer 0.2.5

package/dist/sl1_write-CvrNejbW.js

@@ -0,0 +1,302 @@
+import { strToU8 as V, zipSync as I, zlibSync as z } from "three/examples/jsm/libs/fflate.module.js";
+let $ = !0;
+function it(t) {
+  $ = !!t;
+}
+const O = {
+  info: (...t) => {
+    $ && console.info(...t);
+  },
+  warn: (...t) => {
+    $ && console.warn(...t);
+  },
+  error: (...t) => {
+    $ && console.error(...t);
+  }
+};
+function j(t) {
+  const e = [];
+  let n = null;
+  for (let r = 0; r < t.length; r += 8) {
+    const a = t[r], f = t[r + 1], c = t[r + 4], s = t[r + 5];
+    n && Math.abs(n.lx - a) < 1e-6 && Math.abs(n.ly - f) < 1e-6 ? (n.pts.push(c, s), n.lx = c, n.ly = s) : (n = { pts: [a, f, c, s], lx: c, ly: s }, e.push(n));
+  }
+  return e.map((r) => r.pts);
+}
+function R(t, e, n, r, a, f) {
+  const c = new Array(n).fill(null);
+  for (const l of t) {
+    const i = l.length / 2;
+    for (let o = 0; o < i; o++) {
+      const d = (o + 1) % i;
+      let u = r(l[o * 2], l[o * 2 + 1]), p = a(l[o * 2], l[o * 2 + 1]), x = r(l[d * 2], l[d * 2 + 1]), w = a(l[d * 2], l[d * 2 + 1]);
+      if (p === w) continue;
+      if (p > w) {
+        const y = u;
+        u = x, x = y;
+        const _ = p;
+        p = w, w = _;
+      }
+      const b = Math.max(0, Math.ceil(p - 0.5));
+      if (b >= n || w < 0.5) continue;
+      const m = { x: u + (b + 0.5 - p) / (w - p) * (x - u), dx: (x - u) / (w - p), yEnd: w };
+      (c[b] ??= []).push(m);
+    }
+  }
+  const s = [];
+  for (let l = 0; l < n; l++) {
+    const i = l + 0.5;
+    c[l] && s.push(...c[l]);
+    for (let o = s.length - 1; o >= 0; o--) s[o].yEnd <= i && s.splice(o, 1);
+    s.sort((o, d) => o.x - d.x);
+    for (let o = 0; o + 1 < s.length; o += 2) {
+      const d = Math.max(0, Math.ceil(s[o].x - 0.5)), u = Math.min(e - 1, Math.floor(s[o + 1].x - 0.5));
+      u >= d && f(l, d, u);
+    }
+    for (const o of s) o.x += o.dx;
+  }
+}
+function X(t, e, n = 1) {
+  const { px: r, py: a } = e, f = j(t), c = new Uint8Array(r * a);
+  if (n <= 1)
+    return R(
+      f,
+      r,
+      a,
+      (i, o) => e.map(i, o)[0],
+      (i, o) => e.map(i, o)[1],
+      (i, o, d) => {
+        c.fill(255, i * r + o, i * r + d + 1);
+      }
+    ), c;
+  const s = new Uint16Array(r * a);
+  R(
+    f,
+    r * n,
+    a * n,
+    (i, o) => e.map(i, o)[0] * n,
+    (i, o) => e.map(i, o)[1] * n,
+    (i, o, d) => {
+      const u = i / n | 0;
+      for (let p = o; p <= d; p++) s[u * r + (p / n | 0)]++;
+    }
+  );
+  const l = n * n;
+  for (let i = 0; i < s.length; i++) c[i] = Math.round(s[i] * 255 / l);
+  return c;
+}
+const Y = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]), G = (() => {
+  const t = new Uint32Array(256);
+  for (let e = 0; e < 256; e++) {
+    let n = e;
+    for (let r = 0; r < 8; r++) n = n & 1 ? 3988292384 ^ n >>> 1 : n >>> 1;
+    t[e] = n >>> 0;
+  }
+  return t;
+})(), W = (t) => {
+  let e = 4294967295;
+  for (let n = 0; n < t.length; n++) e = G[(e ^ t[n]) & 255] ^ e >>> 8;
+  return (e ^ 4294967295) >>> 0;
+}, E = (t, e) => {
+  const n = new Uint8Array(12 + e.length), r = new DataView(n.buffer);
+  r.setUint32(0, e.length);
+  for (let f = 0; f < 4; f++) n[4 + f] = t.charCodeAt(f);
+  n.set(e, 8);
+  const a = n.subarray(4, 8 + e.length);
+  return r.setUint32(8 + e.length, W(a)), n;
+}, H = async (t) => {
+  const e = new CompressionStream("deflate"), n = [], r = (async () => {
+    const l = e.readable.getReader();
+    for (; ; ) {
+      const { value: i, done: o } = await l.read();
+      if (o) break;
+      n.push(i);
+    }
+  })(), a = e.writable.getWriter();
+  await a.write(t), await a.close(), await r;
+  let f = 0;
+  for (const l of n) f += l.length;
+  const c = new Uint8Array(f);
+  let s = 0;
+  for (const l of n)
+    c.set(l, s), s += l.length;
+  return c;
+};
+async function Z(t, e, n, r = {}) {
+  if (t.length !== e * n) throw new Error(`gray8: ${t.length} bytes for ${e}x${n}`);
+  const a = new Uint8Array(13), f = new DataView(a.buffer);
+  f.setUint32(0, e), f.setUint32(4, n), a[8] = 8, a[9] = 0;
+  const c = new Uint8Array(n * (1 + e));
+  for (let u = 0; u < n; u++) c.set(t.subarray(u * e, (u + 1) * e), u * (1 + e) + 1);
+  const s = typeof CompressionStream < "u" ? await H(c) : r.deflate ? r.deflate(c) : (() => {
+    throw new Error("gray8: no CompressionStream and no deflate fallback injected");
+  })(), l = [Y, E("IHDR", a), E("IDAT", s), E("IEND", new Uint8Array(0))];
+  let i = 0;
+  for (const u of l) i += u.length;
+  const o = new Uint8Array(i);
+  let d = 0;
+  for (const u of l)
+    o.set(u, d), d += u.length;
+  return o;
+}
+function q(t) {
+  const e = Number(t.display_width) > 0 ? Number(t.display_width) : 120.96, n = Number(t.display_height) > 0 ? Number(t.display_height) : 68.04, r = Number(t.display_pixels_x) > 0 ? Math.round(Number(t.display_pixels_x)) : 2560, a = Number(t.display_pixels_y) > 0 ? Math.round(Number(t.display_pixels_y)) : 1440, f = t.display_mirror_x !== !1, c = t.display_mirror_y === !0, s = (t.display_orientation ?? "portrait") !== "landscape", l = r / e, i = a / n, o = (u) => (f ? e / 2 - u : u + e / 2) * l, d = (u) => (c ? n / 2 - u : u + n / 2) * i;
+  return s ? {
+    px: a,
+    py: r,
+    mirrorX: f,
+    portrait: s,
+    // canvas columns run along the display's y axis, rows along the (mirrored) x axis
+    map: (u, p) => [d(p), o(u)]
+  } : {
+    px: r,
+    py: a,
+    mirrorX: f,
+    portrait: s,
+    map: (u, p) => [o(u), d(p)]
+  };
+}
+function J(t, e, n) {
+  const r = e.length / 8;
+  if (!r) return 0;
+  let a = 0;
+  t.beginPath();
+  let f = NaN, c = NaN;
+  for (let s = 0; s < r; s++) {
+    const l = e[s * 8], i = e[s * 8 + 1], o = e[s * 8 + 4], d = e[s * 8 + 5];
+    (l !== f || i !== c) && (t.moveTo(...n.map(l, i)), a++), t.lineTo(...n.map(o, d)), f = o, c = d;
+  }
+  return t.fill("evenodd"), a;
+}
+const K = (t) => String(t ?? "");
+function Q({ params: t, stats: e, jobName: n, timestamp: r }) {
+  const a = String(t.material_print_speed ?? "fast"), f = {
+    action: "print",
+    jobDir: n,
+    expTime: t.exposure_time,
+    expTimeFirst: t.initial_exposure_time,
+    expUserProfile: a === "slow" ? 1 : a === "fast" ? 0 : 2,
+    fileCreationTimestamp: r ?? "",
+    hollow: t.hollowing_enable ? 1 : 0,
+    layerHeight: t.layer_height,
+    materialName: t.sla_material_settings_id ?? "",
+    numFade: t.faded_layers,
+    numFast: e.layers,
+    numSlow: 0,
+    printProfile: t.sla_print_settings_id ?? "",
+    printTime: Number(e.time_estimate ?? 0).toFixed(6),
+    printerModel: t.printer_model ?? "",
+    printerProfile: t.printer_settings_id ?? "",
+    printerVariant: t.printer_variant ?? "",
+    prusaSlicerVersion: "three-slicer",
+    usedMaterial: Number(e.resin_ml ?? 0).toFixed(6)
+  };
+  return Object.keys(f).sort().map((c) => `${c} = ${K(f[c])}`).join(`
+`) + `
+`;
+}
+const T = (t, e) => `${t}${String(e).padStart(5, "0")}.png`, tt = "Metadata/threeslicer_roles.bin", et = "Metadata/threeslicer_scene.bin";
+function nt({ modelSTL: t, supportMesh: e, padMesh: n, lift: r = 0 }) {
+  const a = t instanceof Uint8Array ? t : new Uint8Array(t ?? 0), f = e instanceof Float32Array ? e : new Float32Array(e ?? 0), c = n instanceof Float32Array ? n : new Float32Array(n ?? 0), s = new Uint8Array(12 + a.length + 4 + f.length * 4 + 4 + c.length * 4), l = new DataView(s.buffer);
+  s.set([84, 83, 83, 49], 0), l.setFloat32(4, r, !0);
+  let i = 8;
+  l.setUint32(i, a.length, !0), i += 4, s.set(a, i), i += a.length;
+  for (const o of [f, c]) {
+    l.setUint32(i, o.length, !0), i += 4;
+    for (let d = 0; d < o.length; d++)
+      l.setFloat32(i, o[d], !0), i += 4;
+  }
+  return s;
+}
+function ot(t) {
+  const e = t.map(({ paths: c }) => {
+    const s = [];
+    for (let l = 0; l + 7 < c.length; l += 8) {
+      const i = c[l + 3] & 15;
+      if (i === 5 || i === 6) for (let o = 0; o < 8; o++) s.push(c[l + o]);
+    }
+    return s;
+  }), n = 8 + e.reduce((c, s) => c + 4 + s.length * 4, 0), r = new Uint8Array(n), a = new DataView(r.buffer);
+  r.set([84, 83, 82, 49], 0), a.setUint32(4, e.length, !0);
+  let f = 8;
+  for (const c of e) {
+    a.setUint32(f, c.length, !0), f += 4;
+    for (const s of c)
+      a.setFloat32(f, s, !0), f += 4;
+  }
+  return r;
+}
+function rt({ layers: t, params: e, makeWorker: n, workerCount: r, onProgress: a, aa: f = 1 }) {
+  return new Promise((c, s) => {
+    const l = new Array(t.length), i = new Array(r).fill(0);
+    let o = 0, d = !1;
+    const u = [], p = (x) => {
+      d = !0, u.forEach((w) => w.terminate()), s(x);
+    };
+    for (let x = 0; x < r; x++) {
+      const w = [], b = [];
+      for (let y = x; y < t.length; y += r)
+        w.push(y), b.push(t[y].paths);
+      const m = n();
+      u.push(m), m.onerror = (y) => p(new Error("SL1 encode worker: " + (y?.message || "failed"))), m.onmessage = ({ data: y }) => {
+        if (!d) {
+          if (y.progress != null) {
+            i[x] = y.progress, a?.(i.reduce((_, U) => _ + U, 0), t.length);
+            return;
+          }
+          y.indices.forEach((_, U) => {
+            l[_] = y.pngs[U];
+          }), m.terminate(), ++o === r && c(l);
+        }
+      }, m.postMessage({ indices: w, paths: b, params: e, aa: f });
+    }
+  });
+}
+async function lt({ layers: t, params: e, stats: n, jobName: r = "plate", timestamp: a, makeCanvas: f, onProgress: c, scene: s = null, makeWorker: l = null, workerCount: i = 0, aa: o = 1, gpuRaster: d = null }) {
+  const u = f ?? null, p = q(e), x = {}, w = l && typeof Worker < "u" && t.length > 1 ? {
+    makeWorker: l,
+    workerCount: Math.max(1, Math.min(i > 0 ? i : 4, t.length))
+  } : null, b = () => performance.now(), m = { canvas: 0, clear: 0, draw: 0, encode: 0, read: 0 }, y = (h, g) => {
+    const v = b();
+    return m[h] += v - g, v;
+  };
+  let _ = 0, U = 0;
+  const B = async (h) => {
+    let g = b();
+    if (!u) {
+      const P = d ? await d(t[h].paths, p, o, t[h], h) : X(t[h].paths, p, o);
+      g = y("draw", g);
+      const D = await Z(P, p.px, p.py, { deflate: z });
+      return y("encode", g), _ += D.length, D;
+    }
+    const v = u(p.px, p.py), S = v.getContext("2d");
+    g = y("canvas", g), S.fillStyle = "#000", S.fillRect(0, 0, p.px, p.py), g = y("clear", g), S.fillStyle = "#fff", U += J(S, t[h].paths, p), g = y("draw", g);
+    const L = await v.convertToBlob({ type: "image/png" });
+    g = y("encode", g);
+    const C = new Uint8Array(await L.arrayBuffer());
+    return y("read", g), _ += C.length, C;
+  }, F = b();
+  if (w) {
+    const h = await rt({ layers: t, params: e, onProgress: c, aa: o, ...w });
+    for (let g = 0; g < t.length; g++)
+      x[T(r, g)] = [h[g], { level: 0 }], _ += h[g].length;
+  } else
+    for (let h = 0; h < t.length; h++)
+      x[T(r, h)] = [await B(h), { level: 0 }], h & 31 || c?.(h, t.length);
+  const M = b();
+  x["config.ini"] = V(Q({ params: e, stats: n, jobName: r, timestamp: a })), x[tt] = [ot(t), { level: 6 }], s && (x[et] = [nt(s), { level: 6 }]);
+  const N = b(), k = I(x), A = (h) => h.toFixed(0);
+  return O.info(`[vp-prof] sl1 build: ${t.length} layers ${p.px}x${p.py},` + (w ? ` raster ${A(M - F)}ms (${w.workerCount} workers),` : ` ${U} loops, raster ${A(M - F)}ms (canvas ${A(m.canvas)} + clear ${A(m.clear)} + draw ${A(m.draw)} + encode ${A(m.encode)} + read ${A(m.read)}),`) + ` sidecar ${A(N - M)}ms, zip ${A(b() - N)}ms -> ${(k.byteLength / 1e6).toFixed(1)}MB (png ${(_ / 1e6).toFixed(1)}MB)`), k;
+}
+export {
+  et as S,
+  tt as a,
+  j as b,
+  it as c,
+  J as d,
+  Z as e,
+  O as l,
+  lt as m,
+  X as r,
+  q as s
+};

package/dist/sla_reconstruct-CXkYhux2.js

@@ -0,0 +1,176 @@
+const U = new Int8Array(8), W = new Int8Array(8), G = new Int8Array(8);
+for (let t = 0; t < 8; t++)
+  U[t] = t & 1, W[t] = t >> 1 & 1, G[t] = t >> 2 & 1;
+const T = [], rt = [];
+for (let t = 0; t < 8; t++) for (let l = t + 1; l < 8; l++)
+  Math.abs(U[t] - U[l]) + Math.abs(W[t] - W[l]) + Math.abs(G[t] - G[l]) === 1 && (T.push(t), rt.push(l));
+const ot = 127.5, q = (t) => t > ot, x = (t) => {
+  const l = [];
+  let A = new t(1048576), r = 0, m = 0;
+  return {
+    push3(u, C, h) {
+      r + 3 > A.length && (l.push(A.subarray(0, r)), m += r, A = new t(1 << 20), r = 0), A[r++] = u, A[r++] = C, A[r++] = h;
+    },
+    concat() {
+      l.push(A.subarray(0, r)), m += r;
+      const u = new t(m);
+      let C = 0;
+      for (const h of l)
+        u.set(h, C), C += h.length;
+      return u;
+    }
+  };
+}, ct = { 0: [0.68, 0.238, 0.023], 5: [0.328, 0.188, 0.687], 6: [0.434, 0.352, 0.144] };
+function ht(t, l, A, r, m, u, C, h) {
+  const b = t + 1, a = l + 1;
+  let o = new Int32Array(b * a).fill(-1), i = new Int32Array(b * a).fill(-1);
+  const N = null;
+  let F = N, w = N, H = null, P = null, J = null, d = null, at = 0;
+  const tt = x(Float32Array), Y = x(Uint32Array), et = x(Float32Array);
+  let nt = 0, Q = !1;
+  const S = (g, c, n) => !g || c < 0 || n < 0 || c >= t || n >= l ? 0 : g[c + t * n], O = new Float64Array(8);
+  function lt(g, c, n, R, s, k, y, p) {
+    const e = c + 1 + b * (n + 1), M = g[e];
+    if (M >= 0) return M;
+    O[0] = S(s, c, n), O[1] = S(s, c + 1, n), O[2] = S(s, c, n + 1), O[3] = S(s, c + 1, n + 1), O[4] = S(k, c, n), O[5] = S(k, c + 1, n), O[6] = S(k, c, n + 1), O[7] = S(k, c + 1, n + 1);
+    let z = 0, f = 0, I = 0, v = 0;
+    for (let E = 0; E < T.length; E++) {
+      const B = T[E], L = rt[E];
+      if (q(O[B]) === q(O[L])) continue;
+      const X = Math.min(1, Math.max(0, (ot - O[B]) / (O[L] - O[B])));
+      z += U[B] + X * (U[L] - U[B]), f += W[B] + X * (W[L] - W[B]), I += G[B] + X * (G[L] - G[B]), v++;
+    }
+    const K = v ? z / v : 0.5, j = v ? f / v : 0.5, D = v ? I / v : 0.5;
+    if (tt.push3(u + (c + K + 0.5) * A, C + (n + j + 0.5) * r, h + (R + D + 0.5) * m), Q) {
+      let E = 0;
+      for (let L = 0; L < 8; L++) {
+        if (!q(O[L])) continue;
+        const X = S(G[L] ? p : y, c + U[L], n + W[L]);
+        if (X === 5) {
+          E = 5;
+          break;
+        }
+        X === 6 && (E = 6);
+      }
+      const B = ct[E];
+      et.push3(B[0], B[1], B[2]);
+    }
+    return g[e] = nt, nt++;
+  }
+  const Z = (g, c, n) => c === N || n < 0 || n >= l ? t : g ? g[n * 2] : 0, _ = (g, c, n) => c === N || n < 0 || n >= l ? -1 : g ? g[n * 2 + 1] : t - 1;
+  function V(g, c, n) {
+    const R = at++, s = (e, M) => lt(o, e, M, R - 1, F, w, H, P), k = (e, M) => lt(i, e, M, R, w, g, P, c), y = (e, M, z, f, I) => {
+      I ? (Y.push3(f, z, M), Y.push3(f, M, e)) : (Y.push3(e, M, z), Y.push3(e, z, f));
+    };
+    for (let e = 0; e < l; e++) {
+      const M = Math.min(Z(J, F, e), Z(d, w, e)), z = Math.max(_(J, F, e), _(d, w, e));
+      for (let f = M; f <= z; f++) {
+        const I = q(S(F, f, e)), v = q(S(w, f, e));
+        I !== v && y(s(f - 1, e - 1), s(f, e - 1), s(f, e), s(f - 1, e), !I);
+      }
+    }
+    for (let e = 0; e < l; e++) {
+      const M = Z(d, w, e), z = _(d, w, e);
+      for (let f = M - 1; f <= z; f++) {
+        const I = q(S(w, f, e)), v = q(S(w, f + 1, e));
+        I !== v && y(s(f, e - 1), s(f, e), k(f, e), k(f, e - 1), !I);
+      }
+    }
+    for (let e = -1; e < l; e++) {
+      const M = Math.min(Z(d, w, e), Z(d, w, e + 1)), z = Math.max(_(d, w, e), _(d, w, e + 1));
+      for (let f = M; f <= z; f++) {
+        const I = q(S(w, f, e)), v = q(S(w, f, e + 1));
+        I !== v && y(s(f - 1, e), k(f - 1, e), k(f, e), s(f, e), !I);
+      }
+    }
+    const p = o;
+    o = i, i = p.fill(-1);
+  }
+  let $ = !1;
+  return {
+    // Slices arrive bottom-up. Layer s can only be processed once s+1 is known (its cells' upper corners live
+    //  there), so the first slice just primes the window and every later push runs the step one layer behind.
+    //  `roles` is an optional parallel Uint8Array (0=model, 5=support, 6=pad) that turns on vertex colours;
+    //  `ranges` the per-row occupancy spans fillSliceFromRGBA returns, which confine the sweep to the model.
+    pushSlice(g, c = null, n = null) {
+      if (c && (Q = !0), !$) {
+        $ = !0, w = g, P = c, d = n;
+        return;
+      }
+      V(g, c), F = w, w = g, H = P, P = c, J = d, d = n;
+    },
+    finish({ smoothRounds: g = 0, normalRounds: c = 0 } = {}) {
+      $ && (V(N, null), F = w, w = N, H = P, P = null, J = d, d = null), V(N, null);
+      const n = tt.concat(), R = Y.concat();
+      g > 0 && st(n, R, g);
+      const s = new Float32Array(n.length);
+      for (let k = 0; k < R.length; k += 3) {
+        const y = R[k] * 3, p = R[k + 1] * 3, e = R[k + 2] * 3, M = n[p] - n[y], z = n[p + 1] - n[y + 1], f = n[p + 2] - n[y + 2], I = n[e] - n[y], v = n[e + 1] - n[y + 1], K = n[e + 2] - n[y + 2], j = z * K - f * v, D = f * I - M * K, E = M * v - z * I;
+        s[y] += j, s[y + 1] += D, s[y + 2] += E, s[p] += j, s[p + 1] += D, s[p + 2] += E, s[e] += j, s[e + 1] += D, s[e + 2] += E;
+      }
+      return ft(s), c > 0 && ut(s, R, c), { positions: n, indices: R, normals: s, colors: Q ? et.concat() : null };
+    }
+  };
+}
+function ft(t) {
+  for (let l = 0; l < t.length; l += 3) {
+    const A = Math.hypot(t[l], t[l + 1], t[l + 2]) || 1;
+    t[l] /= A, t[l + 1] /= A, t[l + 2] /= A;
+  }
+}
+function ut(t, l, A = 2) {
+  const r = new Float32Array(t.length);
+  for (let m = 0; m < A; m++) {
+    r.fill(0);
+    for (let u = 0; u < l.length; u += 3) {
+      const C = l[u] * 3, h = l[u + 1] * 3, b = l[u + 2] * 3;
+      for (const [a, o] of [[C, h], [h, b], [b, C]])
+        r[a] += t[o], r[a + 1] += t[o + 1], r[a + 2] += t[o + 2], r[o] += t[a], r[o + 1] += t[a + 1], r[o + 2] += t[a + 2];
+    }
+    for (let u = 0; u < t.length; u += 3)
+      t[u] += 0.5 * r[u], t[u + 1] += 0.5 * r[u + 1], t[u + 2] += 0.5 * r[u + 2];
+    ft(t);
+  }
+}
+function st(t, l, A = 4) {
+  const r = new Float32Array(t.length), m = new Float32Array(t.length / 3), u = (h, b) => {
+    const a = h * 3, o = b * 3, i = Math.abs(t[o + 2] - t[a + 2]) + 0.05 * (Math.abs(t[o] - t[a]) + Math.abs(t[o + 1] - t[a + 1])) + 1e-6;
+    r[a] += i * t[o], r[a + 1] += i * t[o + 1], r[a + 2] += i * t[o + 2], r[o] += i * t[a], r[o + 1] += i * t[a + 1], r[o + 2] += i * t[a + 2], m[h] += i, m[b] += i;
+  }, C = (h) => {
+    r.fill(0), m.fill(0);
+    for (let b = 0; b < l.length; b += 3) {
+      const a = l[b], o = l[b + 1], i = l[b + 2];
+      u(a, o), u(o, i), u(i, a);
+    }
+    for (let b = 0; b < m.length; b++) {
+      const a = m[b];
+      if (!a) continue;
+      const o = b * 3;
+      t[o] += h * (r[o] / a - t[o]), t[o + 1] += h * (r[o + 1] / a - t[o + 1]), t[o + 2] += h * (r[o + 2] / a - t[o + 2]);
+    }
+  };
+  for (let h = 0; h < A; h++)
+    C(0.5), C(-0.53);
+}
+function bt(t, l, A, r, m) {
+  const u = new Uint32Array(l.buffer, l.byteOffset, l.byteLength >> 2), C = new Int32Array(r * 2);
+  for (let h = 0; h < r; h++) {
+    const b = r - 1 - h, a = h * A * 4 >> 2, o = A * (b + r * m);
+    let i = A, N = -1;
+    for (let F = 0; F < A; F++) {
+      const w = u[a + F];
+      if (w === 0) {
+        t[o + F] = 0;
+        continue;
+      }
+      const H = w >> 8 & 255;
+      t[o + F] = H, H && (F < i && (i = F), F > N && (N = F));
+    }
+    C[b * 2] = i, C[b * 2 + 1] = N;
+  }
+  return C;
+}
+export {
+  bt as f,
+  ht as m
+};

package/dist/sla_reconstruct.worker.js

@@ -0,0 +1,24 @@
+import { m as c } from "./sla_reconstruct-CXkYhux2.js";
+let e = null, o = { nets: 0, finish: 0 };
+self.onmessage = (m) => {
+  const s = m.data;
+  try {
+    if (s.init) {
+      e = c(s.nx, s.ny, s.sx, s.sy, s.sz, s.ox, s.oy, s.oz), o = { nets: 0, finish: 0 };
+      return;
+    }
+    if (s.slice) {
+      const n = performance.now();
+      e.pushSlice(s.slice, s.roles, s.ranges), o.nets += performance.now() - n;
+      return;
+    }
+    if (s.finish) {
+      const n = performance.now(), { positions: i, indices: t, normals: f, colors: r } = e.finish({ smoothRounds: s.smoothRounds ?? 2, normalRounds: s.normalRounds ?? 0 });
+      o.finish = performance.now() - n, e = null;
+      const a = [i.buffer, t.buffer, f.buffer];
+      r && a.push(r.buffer), self.postMessage({ positions: i, indices: t, normals: f, colors: r, timings: o, producerTimings: s.producerTimings, spin: s.spin }, a);
+    }
+  } catch (n) {
+    self.postMessage({ error: String(n?.message || n) });
+  }
+};

package/dist/sla_slice.worker.js

@@ -0,0 +1,73 @@
+import { f as D } from "./sla_reconstruct-CXkYhux2.js";
+import { d as H } from "./sl1_write-CvrNejbW.js";
+let i = 6;
+const M = (u, k) => {
+  const m = [];
+  for (let l = 0; l + 7 < u.length; l += 8) if ((u[l + 3] & 15) === k) for (let e = 0; e < 8; e++) m.push(u[l + e]);
+  return m;
+};
+self.onmessage = async (u) => {
+  const { indices: k, pngs: m, rolePaths: l, nx: e, ny: r, matrix: w, scale: d, width: B, height: O, batch: A } = u.data;
+  A > 0 && (i = A);
+  try {
+    const s = { decode: 0, draw: 0, read: 0, roles: 0, fill: 0 };
+    let n = 0;
+    const y = new OffscreenCanvas(e, r * i).getContext("2d", { willReadFrequently: !0 }), f = (l ? new OffscreenCanvas(e, r * i) : null)?.getContext("2d", { willReadFrequently: !0 }), F = (a) => {
+      const o = [];
+      for (let p = 0; p < i && a + p < m.length; p++) {
+        const g = a + p;
+        o.push(createImageBitmap(new Blob([m[g]], { type: "image/png" })).then((S) => (m[g] = null, S)));
+      }
+      return o;
+    };
+    let I = F(0);
+    for (let a = 0; a < m.length; a += i) {
+      n = performance.now();
+      const o = await Promise.all(I);
+      s.decode += performance.now() - n, I = F(a + i), n = performance.now(), y.setTransform(1, 0, 0, 1, 0, 0), y.clearRect(0, 0, e, r * i);
+      for (let t = 0; t < o.length; t++)
+        y.setTransform(
+          w[0] * d,
+          w[1] * d,
+          w[2] * d,
+          w[3] * d,
+          w[4] * d,
+          w[5] * d + t * r
+        ), y.drawImage(o[t], 0, 0), o[t].close?.();
+      s.draw += performance.now() - n, n = performance.now();
+      const p = y.getImageData(0, 0, e, r * o.length).data;
+      s.read += performance.now() - n, n = performance.now();
+      let g = null;
+      if (f && l.slice(a, a + o.length).some((t) => t && t.length)) {
+        f.setTransform(1, 0, 0, 1, 0, 0), f.clearRect(0, 0, e, r * i);
+        for (let t = 0; t < o.length; t++) {
+          const h = l[a + t] ?? new Float32Array(0), b = t * r, c = { map: (C, v) => [(C + B / 2) / B * e, (O / 2 - v) / O * r + b] };
+          f.fillStyle = "#00f", H(f, M(h, 6), c), f.fillStyle = "#f00", H(f, M(h, 5), c);
+        }
+        g = f.getImageData(0, 0, e, r * o.length).data, s.roles += performance.now() - n, n = performance.now();
+      }
+      n = performance.now();
+      for (let t = 0; t < o.length; t++) {
+        const h = new Uint8Array(e * r), b = D(h, p.subarray(t * e * r * 4, (t + 1) * e * r * 4), e, r, 0);
+        let c = null;
+        if (g) {
+          c = new Uint8Array(e * r);
+          const v = t * e * r * 4;
+          for (let R = 0; R < r; R++) {
+            const j = v + R * e * 4, q = e * (r - 1 - R);
+            for (let x = 0; x < e; x++) {
+              const T = j + x * 4;
+              c[q + x] = g[T] > 127 ? 5 : g[T + 2] > 127 ? 6 : 0;
+            }
+          }
+        }
+        const C = [h.buffer, b.buffer];
+        c && C.push(c.buffer), self.postMessage({ index: k[a + t], slice: h, ranges: b, roles: c }, C);
+      }
+      s.fill += performance.now() - n;
+    }
+    self.postMessage({ done: !0, timings: s });
+  } catch (s) {
+    self.postMessage({ error: String(s?.message || s) });
+  }
+};