three-slicer 0.2.1 → 0.2.3

package/viewer/dist/make_worker.js

@@ -14,3 +14,18 @@ export function makeSlicerWorker() {
 export function makeParse3mfWorker() {
   return new Worker(new URL('./parse_3mf.worker.js', import.meta.url), { type: 'module' })
 }
+
+// SL1 mesh-reconstruction workers — same dist-relative story as the 3mf parser above. The pipeline is N slice
+// producers (PNG -> occupancy) feeding one nets consumer; see sla_slice.worker.js for why it splits there.
+export function makeSlaReconstructWorker() {
+  return new Worker(new URL('./sla_reconstruct.worker.js', import.meta.url), { type: 'module' })
+}
+
+export function makeSlaSliceWorker() {
+  return new Worker(new URL('./sla_slice.worker.js', import.meta.url), { type: 'module' })
+}
+
+// SL1 export encoder — the write-side counterpart of the slice workers above, same dist-relative story.
+export function makeSl1EncodeWorker() {
+  return new Worker(new URL('./sl1_encode.worker.js', import.meta.url), { type: 'module' })
+}

package/viewer/dist/sl1_encode.worker.js

@@ -0,0 +1,10 @@
+import { s as p, d as c } from "./sl1_write-UHmQ_itC.js";
+self.onmessage = async ({ data: { indices: f, paths: n, params: o } }) => {
+  const a = p(o), r = new OffscreenCanvas(a.px, a.py), e = r.getContext("2d"), t = [];
+  for (let s = 0; s < f.length; s++) {
+    e.fillStyle = "#000", e.fillRect(0, 0, a.px, a.py), e.fillStyle = "#fff", c(e, n[s], a);
+    const l = await r.convertToBlob({ type: "image/png" });
+    t.push(new Uint8Array(await l.arrayBuffer())), (s & 7) === 7 && self.postMessage({ progress: s + 1 });
+  }
+  self.postMessage({ indices: f, pngs: t }, t.map((s) => s.buffer));
+};

package/viewer/dist/sl1_write-UHmQ_itC.js

@@ -0,0 +1,170 @@
+import { strToU8 as R, zipSync as T } from "three/examples/jsm/libs/fflate.module.js";
+let F = !0;
+function Z(e) {
+  F = !!e;
+}
+const C = {
+  info: (...e) => {
+    F && console.info(...e);
+  },
+  warn: (...e) => {
+    F && console.warn(...e);
+  },
+  error: (...e) => {
+    F && console.error(...e);
+  }
+};
+function O(e) {
+  const t = Number(e.display_width) > 0 ? Number(e.display_width) : 120.96, u = Number(e.display_height) > 0 ? Number(e.display_height) : 68.04, o = Number(e.display_pixels_x) > 0 ? Math.round(Number(e.display_pixels_x)) : 2560, i = Number(e.display_pixels_y) > 0 ? Math.round(Number(e.display_pixels_y)) : 1440, s = e.display_mirror_x !== !1, r = e.display_mirror_y === !0, n = (e.display_orientation ?? "portrait") !== "landscape", a = o / t, l = i / u, f = (p) => (s ? t / 2 - p : p + t / 2) * a, c = (p) => (r ? u / 2 - p : p + u / 2) * l;
+  return n ? {
+    px: i,
+    py: o,
+    mirrorX: s,
+    portrait: n,
+    // canvas columns run along the display's y axis, rows along the (mirrored) x axis
+    map: (p, y) => [c(y), f(p)]
+  } : {
+    px: o,
+    py: i,
+    mirrorX: s,
+    portrait: n,
+    map: (p, y) => [f(p), c(y)]
+  };
+}
+function k(e, t, u) {
+  const o = t.length / 8;
+  if (!o) return 0;
+  let i = 0;
+  e.beginPath();
+  let s = NaN, r = NaN;
+  for (let n = 0; n < o; n++) {
+    const a = t[n * 8], l = t[n * 8 + 1], f = t[n * 8 + 4], c = t[n * 8 + 5];
+    (a !== s || l !== r) && (e.moveTo(...u.map(a, l)), i++), e.lineTo(...u.map(f, c)), s = f, r = c;
+  }
+  return e.fill("evenodd"), i;
+}
+const V = (e) => String(e ?? "");
+function X({ params: e, stats: t, jobName: u, timestamp: o }) {
+  const i = String(e.material_print_speed ?? "fast"), s = {
+    action: "print",
+    jobDir: u,
+    expTime: e.exposure_time,
+    expTimeFirst: e.initial_exposure_time,
+    expUserProfile: i === "slow" ? 1 : i === "fast" ? 0 : 2,
+    fileCreationTimestamp: o ?? "",
+    hollow: e.hollowing_enable ? 1 : 0,
+    layerHeight: e.layer_height,
+    materialName: e.sla_material_settings_id ?? "",
+    numFade: e.faded_layers,
+    numFast: t.layers,
+    numSlow: 0,
+    printProfile: e.sla_print_settings_id ?? "",
+    printTime: Number(t.time_estimate ?? 0).toFixed(6),
+    printerModel: e.printer_model ?? "",
+    printerProfile: e.printer_settings_id ?? "",
+    printerVariant: e.printer_variant ?? "",
+    prusaSlicerVersion: "three-slicer",
+    usedMaterial: Number(t.resin_ml ?? 0).toFixed(6)
+  };
+  return Object.keys(s).sort().map((r) => `${r} = ${V(s[r])}`).join(`
+`) + `
+`;
+}
+const L = (e, t) => `${e}${String(t).padStart(5, "0")}.png`, Y = "Metadata/threeslicer_roles.bin", D = "Metadata/threeslicer_scene.bin";
+function j({ modelSTL: e, supportMesh: t, padMesh: u, lift: o = 0 }) {
+  const i = e instanceof Uint8Array ? e : new Uint8Array(e ?? 0), s = t instanceof Float32Array ? t : new Float32Array(t ?? 0), r = u instanceof Float32Array ? u : new Float32Array(u ?? 0), n = new Uint8Array(12 + i.length + 4 + s.length * 4 + 4 + r.length * 4), a = new DataView(n.buffer);
+  n.set([84, 83, 83, 49], 0), a.setFloat32(4, o, !0);
+  let l = 8;
+  a.setUint32(l, i.length, !0), l += 4, n.set(i, l), l += i.length;
+  for (const f of [s, r]) {
+    a.setUint32(l, f.length, !0), l += 4;
+    for (let c = 0; c < f.length; c++)
+      a.setFloat32(l, f[c], !0), l += 4;
+  }
+  return n;
+}
+function z(e) {
+  const t = e.map(({ paths: r }) => {
+    const n = [];
+    for (let a = 0; a + 7 < r.length; a += 8) {
+      const l = r[a + 3] & 15;
+      if (l === 5 || l === 6) for (let f = 0; f < 8; f++) n.push(r[a + f]);
+    }
+    return n;
+  }), u = 8 + t.reduce((r, n) => r + 4 + n.length * 4, 0), o = new Uint8Array(u), i = new DataView(o.buffer);
+  o.set([84, 83, 82, 49], 0), i.setUint32(4, t.length, !0);
+  let s = 8;
+  for (const r of t) {
+    i.setUint32(s, r.length, !0), s += 4;
+    for (const n of r)
+      i.setFloat32(s, n, !0), s += 4;
+  }
+  return o;
+}
+function H({ layers: e, params: t, makeWorker: u, workerCount: o, onProgress: i }) {
+  return new Promise((s, r) => {
+    const n = new Array(e.length), a = new Array(o).fill(0);
+    let l = 0, f = !1;
+    const c = [], p = (y) => {
+      f = !0, c.forEach((_) => _.terminate()), r(y);
+    };
+    for (let y = 0; y < o; y++) {
+      const _ = [], m = [];
+      for (let g = y; g < e.length; g += o)
+        _.push(g), m.push(e[g].paths);
+      const w = u();
+      c.push(w), w.onerror = (g) => p(new Error("SL1 encode worker: " + ((g == null ? void 0 : g.message) || "failed"))), w.onmessage = ({ data: g }) => {
+        if (!f) {
+          if (g.progress != null) {
+            a[y] = g.progress, i == null || i(a.reduce((b, $) => b + $, 0), e.length);
+            return;
+          }
+          g.indices.forEach((b, $) => {
+            n[b] = g.pngs[$];
+          }), w.terminate(), ++l === o && s(n);
+        }
+      }, w.postMessage({ indices: _, paths: m, params: t });
+    }
+  });
+}
+async function q({ layers: e, params: t, stats: u, jobName: o = "plate", timestamp: i, makeCanvas: s, onProgress: r, scene: n = null, makeWorker: a = null, workerCount: l = 0 }) {
+  const f = s ?? (typeof OffscreenCanvas < "u" ? (h, d) => new OffscreenCanvas(h, d) : null), c = O(t), p = {}, y = a && typeof Worker < "u" && e.length > 1 ? {
+    makeWorker: a,
+    workerCount: Math.max(1, Math.min(l > 0 ? l : 4, e.length))
+  } : null;
+  if (!y && !f) throw new Error("SL1 export needs a canvas (OffscreenCanvas or an injected factory)");
+  const _ = () => performance.now(), m = { canvas: 0, clear: 0, draw: 0, encode: 0, read: 0 }, w = (h, d) => {
+    const S = _();
+    return m[h] += S - d, S;
+  };
+  let g = 0, b = 0;
+  const $ = async (h) => {
+    let d = _();
+    const S = f(c.px, c.py), v = S.getContext("2d");
+    d = w("canvas", d), v.fillStyle = "#000", v.fillRect(0, 0, c.px, c.py), d = w("clear", d), v.fillStyle = "#fff", b += k(v, e[h].paths, c), d = w("draw", d);
+    const B = await S.convertToBlob({ type: "image/png" });
+    d = w("encode", d);
+    const U = new Uint8Array(await B.arrayBuffer());
+    return w("read", d), g += U.length, U;
+  }, E = _();
+  if (y) {
+    const h = await H({ layers: e, params: t, onProgress: r, ...y });
+    for (let d = 0; d < e.length; d++)
+      p[L(o, d)] = [h[d], { level: 0 }], g += h[d].length;
+  } else
+    for (let h = 0; h < e.length; h++)
+      p[L(o, h)] = [await $(h), { level: 0 }], h & 31 || r == null || r(h, e.length);
+  const N = _();
+  p["config.ini"] = R(X({ params: t, stats: u, jobName: o, timestamp: i })), p[Y] = [z(e), { level: 6 }], n && (p[D] = [j(n), { level: 6 }]);
+  const A = _(), M = T(p), x = (h) => h.toFixed(0);
+  return C.info(`[vp-prof] sl1 build: ${e.length} layers ${c.px}x${c.py},` + (y ? ` raster ${x(N - E)}ms (${y.workerCount} workers),` : ` ${b} loops, raster ${x(N - E)}ms (canvas ${x(m.canvas)} + clear ${x(m.clear)} + draw ${x(m.draw)} + encode ${x(m.encode)} + read ${x(m.read)}),`) + ` sidecar ${x(A - N)}ms, zip ${x(_() - A)}ms -> ${(M.byteLength / 1e6).toFixed(1)}MB (png ${(g / 1e6).toFixed(1)}MB)`), M;
+}
+export {
+  D as S,
+  Y as a,
+  Z as b,
+  k as d,
+  C as l,
+  q as m,
+  O as s
+};

package/viewer/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/viewer/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 == null ? void 0 : n.message) || n) });
+  }
+};

package/viewer/dist/sla_slice.worker.js

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