three-slicer-viewer 0.3.2 → 0.3.4

package/dist/parse_3mf-CpbA-6Iq.js

@@ -0,0 +1,666 @@
+import { inflateSync as pt, unzip as mt, unzipSync as Y } from "three/examples/jsm/libs/fflate.module.js";
+import { S as ht } from "./viewer_defaults-B7UUZ582.js";
+const ot = [
+  1,
+  10,
+  100,
+  1e3,
+  1e4,
+  1e5,
+  1e6,
+  1e7,
+  1e8,
+  1e9,
+  1e10,
+  1e11,
+  1e12,
+  1e13,
+  1e14,
+  1e15,
+  1e16,
+  1e17,
+  1e18,
+  1e19,
+  1e20,
+  1e21,
+  1e22
+], dt = new TextDecoder(), N = (t, e, i) => dt.decode(t.subarray(e, i));
+function $(t, e, i) {
+  let n = e, o = !1;
+  n < i && (t[n] === 45 || t[n] === 43) && (o = t[n] === 45, n++);
+  let r = 0, c = -1, a = 0;
+  for (; n < i; n++) {
+    const p = t[n];
+    if (p >= 48 && p <= 57)
+      r = r * 10 + (p - 48), a++, c >= 0 && c++;
+    else if (p === 46 && c < 0) c = 0;
+    else return Number(N(t, e, i));
+  }
+  if (!a || r > 9007199254740991 || c > 22) return Number(N(t, e, i));
+  let s = r;
+  return c > 0 && (s = r / ot[c]), o ? -s : s;
+}
+let T = 0;
+function B(t, e) {
+  let i = e, n = !1, o = t[i];
+  (o === 45 || o === 43) && (n = o === 45, o = t[++i]);
+  let r = 0, c = -1, a = 0;
+  for (; ; o = t[++i])
+    if (o >= 48 && o <= 57)
+      r = r * 10 + (o - 48), a++, c >= 0 && c++;
+    else if (o === 46 && c < 0) c = 0;
+    else break;
+  if (o !== 34) {
+    const p = t.indexOf(34, i);
+    return T = p + 1, Number(N(t, e, p));
+  }
+  if (T = i + 1, !a || r > 9007199254740991 || c > 22) return Number(N(t, e, i));
+  let s = r;
+  return c > 0 && (s = r / ot[c]), n ? -s : s;
+}
+const V = (t, e, i) => t[e] === 32 && t[e + 1] === i && t[e + 2] === 61 && t[e + 3] === 34, q = (t, e, i) => t[e] === 32 && t[e + 1] === 118 && t[e + 2] === i && t[e + 3] === 61 && t[e + 4] === 34, H = (t) => t === 32 || t === 10 || t === 13 || t === 9, O = (t, e, i, n) => {
+  if (i - e !== n.length) return !1;
+  for (let o = 0; o < n.length; o++) if (t[e + o] !== n.charCodeAt(o)) return !1;
+  return !0;
+};
+function U(t, e, i) {
+  const n = t.length;
+  for (; e < n; ) {
+    let o = t[e];
+    for (; H(o); ) o = t[++e];
+    if (o === 62) return e + 1;
+    if (o === 47) {
+      e++;
+      continue;
+    }
+    const r = e;
+    for (; e < n && t[e] !== 61 && t[e] !== 62 && !H(t[e]); ) e++;
+    const c = e;
+    for (; H(t[e]); ) e++;
+    if (t[e] !== 61) continue;
+    for (e++; H(t[e]); ) e++;
+    const a = t[e];
+    if (a !== 34 && a !== 39) continue;
+    const s = e + 1, p = t.indexOf(a, s);
+    if (p < 0) return n;
+    a === 34 && i(r, c, s, p), e = p + 1;
+  }
+  return n;
+}
+const K = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
+function gt(t) {
+  if (!t) return K;
+  const e = t.trim().split(/\s+/).map(Number);
+  return e.length === 12 && e.every(Number.isFinite) ? e : K;
+}
+const G = [
+  ["paint_color", "color"],
+  // multi-material: state 1..16 == Extruder1..16
+  ["paint_supports", "supports"],
+  // support enforcer/blocker: states 1 and 2
+  ["paint_seam", "seam"],
+  // unsupported by the kernel — collected for the warning only
+  ["paint_fuzzy_skin", "fuzzy"]
+  // ditto
+], wt = Object.fromEntries(G);
+function it() {
+  return { color: /* @__PURE__ */ new Map(), supports: /* @__PURE__ */ new Map(), seam: /* @__PURE__ */ new Map(), fuzzy: /* @__PURE__ */ new Map() };
+}
+function jt(t) {
+  return !t || G.every(([, e]) => t[e].size === 0);
+}
+class Q {
+  constructor() {
+    this.data = new Float64Array(1024), this.length = 0;
+  }
+  push3(e, i, n) {
+    if (this.length + 3 > this.data.length) {
+      const o = new Float64Array(this.data.length * 2);
+      o.set(this.data), this.data = o;
+    }
+    this.data[this.length] = e, this.data[this.length + 1] = i, this.data[this.length + 2] = n, this.length += 3;
+  }
+  view() {
+    return this.data.subarray(0, this.length);
+  }
+}
+function W(t) {
+  const e = /* @__PURE__ */ new Map(), i = [];
+  let n = null, o = 0, r = 0, c = 0, a = 0, s = 0, p = 0, u = 0, l = null, h = null, m = null, w = null, M = null;
+  const S = () => {
+    if (n.id)
+      if (n.components.length) e.set(n.id, { components: n.components });
+      else {
+        let g = null;
+        n.verts.length >= 9 && n.tris.length && (g = { verts: n.verts.view(), tris: n.tris.view(), paint: n.paint }), e.set(n.id, { mesh: g });
+      }
+    n = null;
+  }, A = () => ({ objectid: l, path: h || m, transform: gt(w) }), k = (g, z, I, f) => {
+    O(t, g, z, "objectid") ? l = N(t, I, f) : O(t, g, z, "p:path") ? h = N(t, I, f) : O(t, g, z, "path") ? m = N(t, I, f) : O(t, g, z, "transform") && (w = N(t, I, f));
+  }, F = (g, z, I, f) => {
+    if (z - g !== 1) return;
+    const d = t[g];
+    d === 120 ? r = $(t, I, f) : d === 121 ? c = $(t, I, f) : d === 122 && (a = $(t, I, f));
+  }, b = (g, z, I, f) => {
+    if (z - g === 2 && t[g] === 118) {
+      const d = t[g + 1];
+      d === 49 ? s = $(t, I, f) : d === 50 ? p = $(t, I, f) : d === 51 && (u = $(t, I, f));
+    } else if (t[g] === 112 && z - g > 6) {
+      const d = wt[N(t, g, z)];
+      d && f > I && (M ??= []).push(d, N(t, I, f));
+    }
+  };
+  let j = null;
+  const P = (g, z, I, f) => {
+    O(t, g, z, "id") && (j = N(t, I, f));
+  }, _ = t.length;
+  let x = 0;
+  for (; x = t.indexOf(60, x), !(x < 0); ) {
+    let g = x + 1;
+    const z = t[g] === 47;
+    z && g++;
+    const I = t[g];
+    if (I === 33 || I === 63) {
+      if (t[g + 1] === 45 && t[g + 2] === 45) {
+        let d = g + 3;
+        for (; (d = t.indexOf(45, d)) >= 0 && !(t[d + 1] === 45 && t[d + 2] === 62); ) d++;
+        x = _, d >= 0 && (x = d + 3);
+      } else x = t.indexOf(62, g) + 1 || _;
+      continue;
+    }
+    let f = g;
+    for (; f < _ && !H(t[f]) && t[f] !== 62 && t[f] !== 47; ) f++;
+    if (z) {
+      n && O(t, g, f, "object") ? S() : o === 1 && O(t, g, f, "build") && (o = 2), x = t.indexOf(62, f) + 1 || _;
+      continue;
+    }
+    if (n) {
+      if (O(t, g, f, "vertex")) {
+        if (V(t, f, 120) && (r = B(t, f + 4), V(t, T, 121) && (c = B(t, T + 4), V(t, T, 122) && (a = B(t, T + 4), t[T] === 47 && t[T + 1] === 62)))) {
+          x = T + 2, n.id && n.verts.push3(r, c, a);
+          continue;
+        }
+        r = 0, c = 0, a = 0, x = U(t, f, F), n.id && n.verts.push3(r, c, a);
+        continue;
+      }
+      if (O(t, g, f, "triangle")) {
+        s = 0, p = 0, u = 0, M = null;
+        let d = f;
+        if (q(t, f, 49)) {
+          const L = B(t, f + 5);
+          if (q(t, T, 50)) {
+            const ft = B(t, T + 5);
+            if (q(t, T, 51)) {
+              const ut = B(t, T + 5);
+              s = L, p = ft, u = ut, d = T;
+            }
+          }
+        }
+        if (d !== f && t[d] === 47 && t[d + 1] === 62 ? x = d + 2 : x = U(t, d, b), !n.id) continue;
+        const E = n.tris.length / 3;
+        if (n.tris.push3(s, p, u), M) for (let L = 0; L < M.length; L += 2) n.paint[M[L]].set(E, M[L + 1]);
+        continue;
+      }
+      if (O(t, g, f, "component")) {
+        l = null, h = null, m = null, w = null, x = U(t, f, k), l && n.components.push(A());
+        continue;
+      }
+    } else if (O(t, g, f, "object")) {
+      j = null, x = U(t, f, P), n = { id: j, components: [], verts: new Q(), tris: new Q(), paint: it() }, t[x - 2] === 47 && S();
+      continue;
+    } else if (o === 0 && O(t, g, f, "build")) {
+      x = U(t, f, () => {
+      }), o = 1, t[x - 2] === 47 && (o = 2);
+      continue;
+    } else if (o === 1 && O(t, g, f, "item")) {
+      l = null, h = null, m = null, w = null, x = U(t, f, k), l && i.push(A());
+      continue;
+    }
+    x = t.indexOf(62, f) + 1 || _;
+  }
+  return { objects: e, items: i };
+}
+const Mt = new TextDecoder(), v = (t, e) => t[e] | t[e + 1] << 8, C = (t, e) => (t[e] | t[e + 1] << 8 | t[e + 2] << 16 | t[e + 3] << 24) >>> 0;
+function _t(t) {
+  let e = -1;
+  for (let r = t.length - 22; r >= Math.max(0, t.length - 65557); r--)
+    if (C(t, r) === 101010256) {
+      e = r;
+      break;
+    }
+  if (e < 0) return null;
+  const i = v(t, e + 10);
+  let n = C(t, e + 16);
+  if (i === 65535 || n === 4294967295) return null;
+  const o = /* @__PURE__ */ new Map();
+  for (let r = 0; r < i; r++) {
+    if (C(t, n) !== 33639248) return null;
+    const c = v(t, n + 8), a = v(t, n + 10), s = C(t, n + 20), p = C(t, n + 24), u = v(t, n + 28), l = v(t, n + 30), h = v(t, n + 32), m = C(t, n + 42);
+    if (c & 1 || s === 4294967295 || p === 4294967295 || m === 4294967295 || a !== 0 && a !== 8 || C(t, m) !== 67324752) return null;
+    const w = Mt.decode(t.subarray(n + 46, n + 46 + u)), M = m + 30 + v(t, m + 26) + v(t, m + 28);
+    o.set(w, { method: a, compressedSize: s, size: p, dataStart: M }), n += 46 + u + l + h;
+  }
+  return o;
+}
+function rt(t, e) {
+  return t.subarray(e.dataStart, e.dataStart + e.compressedSize);
+}
+async function st(t, e) {
+  if (e.method === 0) return t.slice();
+  if (typeof DecompressionStream == "function" && typeof Response == "function") {
+    const i = new Blob([t]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
+    return new Uint8Array(await new Response(i).arrayBuffer());
+  }
+  return pt(t, { out: new Uint8Array(e.size) });
+}
+function It(t) {
+  const e = t.length, i = new Float32Array(e);
+  for (let l = 0; l < e; l += 3)
+    i[l] = t[l], i[l + 1] = t[l + 2], i[l + 2] = -t[l + 1];
+  let n = 1 / 0, o = 1 / 0, r = 1 / 0, c = -1 / 0, a = -1 / 0, s = -1 / 0;
+  for (let l = 0; l < e; l += 3)
+    n = Math.min(n, i[l]), c = Math.max(c, i[l]), o = Math.min(o, i[l + 1]), a = Math.max(a, i[l + 1]), r = Math.min(r, i[l + 2]), s = Math.max(s, i[l + 2]);
+  const p = (n + c) / 2, u = (r + s) / 2;
+  for (let l = 0; l < e; l += 3)
+    i[l] -= p, i[l + 1] -= o, i[l + 2] -= u;
+  return { localPos: i, size: { w: c - n, d: s - r, h: a - o } };
+}
+function xt(t) {
+  const e = new Float32Array(t.length), i = t;
+  for (let n = 0; n < i.length; n += 9) {
+    const o = i[n], r = i[n + 1], c = i[n + 2], a = i[n + 3], s = i[n + 4], p = i[n + 5], u = i[n + 6] - a, l = i[n + 7] - s, h = i[n + 8] - p, m = o - a, w = r - s, M = c - p;
+    e[n] = l * M - h * w, e[n + 1] = h * m - u * M, e[n + 2] = u * w - l * m;
+    const S = e[n], A = e[n + 1], k = e[n + 2], F = 1 / (Math.sqrt(S * S + A * A + k * k) || 1);
+    e[n] = S * F, e[n + 1] = A * F, e[n + 2] = k * F, e[n + 3] = e[n + 6] = e[n], e[n + 4] = e[n + 7] = e[n + 1], e[n + 5] = e[n + 8] = e[n + 2];
+  }
+  return e;
+}
+function Pt(t) {
+  const e = [1 / 0, 1 / 0, 1 / 0], i = [-1 / 0, -1 / 0, -1 / 0];
+  for (let n = 0; n < t.length; n += 3)
+    for (let o = 0; o < 3; o++) {
+      const r = t[n + o];
+      r < e[o] && (e[o] = r), r > i[o] && (i[o] = r);
+    }
+  return { min: e, max: i };
+}
+function zt(t, e) {
+  const i = [0, 0, 0];
+  if (!(e.max[0] < e.min[0] || e.max[1] < e.min[1] || e.max[2] < e.min[2])) for (let r = 0; r < 3; r++) i[r] = (e.min[r] + e.max[r]) * 0.5;
+  let o = 0;
+  for (let r = 0; r < t.length; r += 3) {
+    const c = i[0] - t[r], a = i[1] - t[r + 1], s = i[2] - t[r + 2];
+    o = Math.max(o, c * c + a * a + s * s);
+  }
+  return { center: i, radius: Math.sqrt(o) };
+}
+function St(t) {
+  const { localPos: e, size: i } = It(t), n = Pt(e);
+  return { localPos: e, size: i, normals: xt(e), bounds: n, sphere: zt(e, n) };
+}
+function Tt(t) {
+  return new Promise((e) => {
+    let i = !1;
+    const n = (o) => {
+      i || (i = !0, e(o));
+    };
+    try {
+      mt(t, (o, r) => {
+        n(o ? Y(t) : r);
+      });
+    } catch {
+      n(Y(t));
+    }
+  });
+}
+const At = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
+function ct(t, e) {
+  const i = new Array(12);
+  for (let n = 0; n < 4; n++)
+    for (let o = 0; o < 3; o++) {
+      let r = 0;
+      n === 3 && (r = e[9 + o]), i[n * 3 + o] = t[n * 3] * e[o] + t[n * 3 + 1] * e[3 + o] + t[n * 3 + 2] * e[6 + o] + r;
+    }
+  return i;
+}
+const Z = {};
+function D(t, e) {
+  return (Z[e] || (Z[e] = new RegExp(`\\b${e}\\s*=\\s*"([^"]*)"`))).exec(t)?.[1] ?? null;
+}
+function R(t) {
+  const e = String(t).replace(/^\/+/, "");
+  return e.includes("%") ? decodeURIComponent(e) : e;
+}
+function J(t) {
+  const e = {};
+  for (const i of t.match(/<metadata\b[^>]*>/g) || []) {
+    const n = D(i, "key");
+    n && (e[n] = D(i, "value") ?? "");
+  }
+  return e;
+}
+function Ot(t) {
+  const e = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), n = /<object\b([^>]*)>([\s\S]*?)<\/object>/g;
+  let o;
+  for (; o = n.exec(t); ) {
+    const a = D(o[1], "id");
+    if (a) {
+      const s = o[2];
+      e.set(a, J(s.replace(/<(?:part|volume)\b[\s\S]*?<\/(?:part|volume)>/g, "")));
+      const p = [];
+      for (const u of s.match(/<volume\b[\s\S]*?<\/volume>/g) || []) {
+        const l = J(u).volume_type, h = l === "SupportBlocker" ? "blocker" : l === "SupportEnforcer" ? "enforcer" : null, m = Number(D(u, "firstid")), w = Number(D(u, "lastid"));
+        h && Number.isInteger(m) && Number.isInteger(w) && m >= 0 && w >= m && p.push({ firstTriangle: m, lastTriangle: w, kind: h });
+      }
+      p.length && i.set(a, p);
+    }
+  }
+  const r = [], c = /<plate\b[^>]*>([\s\S]*?)<\/plate>/g;
+  for (; o = c.exec(t); ) {
+    const a = o[1], s = J(a.replace(/<model_instance\b[\s\S]*?<\/model_instance>/g, "")), p = [];
+    for (const u of a.match(/<model_instance\b[\s\S]*?<\/model_instance>/g) || []) {
+      const l = J(u).object_id;
+      l && p.push(l);
+    }
+    r.push({ index: Math.max(0, (Number(s.plater_id) || r.length + 1) - 1), objectIds: p, gcodeFile: s.gcode_file || null });
+  }
+  return { objects: e, plates: r, volumes: i };
+}
+const Nt = Object.freeze({
+  manualSupportPoints: "prepared-roundtrip",
+  drainHoles: "preserved-unsupported",
+  modifierVolumes: "prepared-mask-filtering",
+  uiEditing: "unavailable"
+});
+function y(t, e, i, n, o) {
+  const r = /* @__PURE__ */ new Map();
+  if (!t?.trim()) return r;
+  const c = t.trim().split(/\r?\n/), a = new RegExp(`^${e}_format_version=(\\d+)$`).exec(c[0]), s = a ? Number(a[1]) : 0;
+  for (const p of c.slice(a ? 1 : 0)) {
+    const u = /^object_id=(\d+)\|(.*)$/.exec(p);
+    if (!u || r.has(Number(u?.[1]))) continue;
+    const l = Number(u[1]), h = u[2].trim() ? u[2].trim().split(/\s+/).map(Number) : [], m = i(s);
+    if (!m || h.length % m !== 0 || h.some((M) => !Number.isFinite(M))) {
+      n.push({ code: e === "support_points" ? "SLA_SUPPORT_POINT_COUNT" : "SLA_DRAIN_HOLE_COUNT", object: l }), r.set(l, []);
+      continue;
+    }
+    const w = [];
+    for (let M = 0; M < h.length; M += m) w.push(o(h.slice(M, M + m), s));
+    r.set(l, w);
+  }
+  return r;
+}
+function tt(t, e) {
+  const [i, n, o] = e;
+  return [i * t[0] + n * t[3] + o * t[6] + t[9], i * t[1] + n * t[4] + o * t[7] + t[10], i * t[2] + n * t[5] + o * t[8] + t[11]];
+}
+function kt(t, e) {
+  const [i, n, o] = e, r = [i * t[0] + n * t[3] + o * t[6], i * t[1] + n * t[4] + o * t[7], i * t[2] + n * t[5] + o * t[8]], c = Math.hypot(...r);
+  return c ? r.map((a) => a / c) : r;
+}
+function Lt(t, e) {
+  const i = (s) => {
+    const p = t.get(s);
+    return p ? e.decode(p) : null;
+  }, n = {
+    settings: null,
+    // Metadata/project_settings.config — the flattened preset (raw upstream strings)
+    objectMeta: /* @__PURE__ */ new Map(),
+    // 3mf object id -> per-object metadata (name, extruder, per-object overrides)
+    plates: [],
+    // [{index, objectIds}]
+    hasLayerHeightProfile: !1,
+    hasCustomGcodePerLayer: !1,
+    volumeMeta: /* @__PURE__ */ new Map(),
+    sla: { capabilities: { ...Nt }, issues: [], supportPoints: /* @__PURE__ */ new Map(), drainHoles: /* @__PURE__ */ new Map() },
+    viewerSettings: null,
+    // Metadata/three_slicer_settings.json — this package's own member (write_3mf.js)
+    plateSettings: null,
+    //  ...its two halves: global viewer knobs, and per-plate overrides keyed by plate index
+    plateCount: null,
+    //  ...and the plate count it was saved with (empty plates hold no <plate> record)
+    gcodePlates: null
+    // a .gcode.3mf's sliced plates: [{index, gcode}] (write_3mf.js writeGcode3MF), else null
+  }, o = i("Metadata/project_settings.config");
+  if (o)
+    try {
+      n.settings = JSON.parse(o);
+    } catch {
+      n.settings = null;
+    }
+  const r = i("Metadata/three_slicer_settings.json");
+  if (r) {
+    let s = null;
+    try {
+      s = JSON.parse(r);
+    } catch {
+      s = null;
+    }
+    const p = (u) => u && typeof u == "object" && !Array.isArray(u);
+    if (p(s)) {
+      p(s.viewer) && Object.keys(s.viewer).length && (n.viewerSettings = s.viewer);
+      let u = [];
+      p(s.plates) && (u = Object.entries(s.plates));
+      const l = u.filter(([h, m]) => /^\d+$/.test(h) && p(m) && Object.keys(m).length);
+      l.length && (n.plateSettings = Object.fromEntries(l.map(([h, m]) => [Number(h), m]))), Number.isInteger(s.plateCount) && s.plateCount >= 1 && (n.plateCount = s.plateCount);
+    }
+  }
+  const c = i("Metadata/model_settings.config");
+  if (c) {
+    const s = Ot(c);
+    n.objectMeta = s.objects, n.plates = s.plates, n.volumeMeta = s.volumes;
+  }
+  const a = n.plates.map((s) => ({ index: s.index, gcode: s.gcodeFile && i(R(s.gcodeFile)) })).filter((s) => s.gcode);
+  return a.length && (n.gcodePlates = a), n.sla.supportPoints = y(
+    i("Metadata/Slic3r_PE_sla_support_points.txt"),
+    "support_points",
+    (s) => s === 0 ? 3 : s === 1 ? 5 : 0,
+    n.sla.issues,
+    (s, p) => ({
+      position: s.slice(0, 3),
+      radius: p === 0 ? ht : s[3],
+      type: p === 0 || s[4] === 2 ? "manual" : s[4] === 1 ? "island" : "slope"
+    })
+  ), n.sla.drainHoles = y(
+    i("Metadata/Slic3r_PE_sla_drain_holes.txt"),
+    "drain_holes",
+    (s) => s === 1 ? 8 : 0,
+    n.sla.issues,
+    (s) => {
+      const p = Math.hypot(s[3], s[4], s[5]), u = p ? s.slice(3, 6).map((l) => l / p) : s.slice(3, 6);
+      return { position: s.slice(0, 3).map((l, h) => l + u[h]), normal: u, radius: s[6], height: s[7] - 1 };
+    }
+  ), n.hasLayerHeightProfile = !!i("Metadata/layer_heights_profile.txt")?.trim(), n.hasCustomGcodePerLayer = !!i("Metadata/custom_gcode_per_layer.xml")?.trim(), n;
+}
+const et = Symbol("part not in job");
+function X(t, e, i, n, o, r) {
+  if (n > 16) return;
+  const c = o(e)?.objects.get(t);
+  if (c) {
+    if (c.components) {
+      for (const a of c.components) X(a.objectid, a.path || e, ct(a.transform, i), n + 1, o, r);
+      return;
+    }
+    c.mesh && r(c.mesh, i);
+  }
+}
+function at(t, e) {
+  let i = 0;
+  for (const c of t) X(c.objectid, c.path, c.xf, c.depth, e, (a) => {
+    i += a.tris.length * 3;
+  });
+  const n = new Float32Array(i), o = it();
+  let r = 0;
+  for (const c of t) X(c.objectid, c.path, c.xf, c.depth, e, ({ verts: a, tris: s, paint: p }, u) => {
+    const l = r / 9;
+    for (let h = 0; h < s.length; h++) {
+      const m = s[h] * 3, w = a[m], M = a[m + 1], S = a[m + 2];
+      n[r] = w * u[0] + M * u[3] + S * u[6] + u[9], n[r + 1] = w * u[1] + M * u[4] + S * u[7] + u[10], n[r + 2] = w * u[2] + M * u[5] + S * u[8] + u[11], r += 3;
+    }
+    for (const [, h] of G)
+      for (const [m, w] of p[h]) o[h].set(l + m, w);
+  });
+  return { sink: n, paintSink: o };
+}
+function lt({ sink: t, paintSink: e }, i, n) {
+  if (t.length < 9) return null;
+  let o = t;
+  const r = [];
+  if (i.length) {
+    const h = /* @__PURE__ */ new Set();
+    for (let m = 0; m < i.length; m++) {
+      const w = i[m], M = w.firstTriangle * 9, S = Math.min(t.length, (w.lastTriangle + 1) * 9);
+      if (!(M >= S)) {
+        for (let A = w.firstTriangle; A <= w.lastTriangle; A++) h.add(A);
+        r.push({ volume: m, kind: w.kind, tris: t.slice(M, S) });
+      }
+    }
+    if (h.size) {
+      const m = new Float32Array(t.length - [...h].filter((M) => M < t.length / 9).length * 9);
+      let w = 0;
+      for (let M = 0; M < t.length / 9; M++)
+        h.has(M) || (m.set(t.subarray(M * 9, M * 9 + 9), w), w += 9);
+      o = m;
+    }
+  }
+  let c = 1 / 0, a = 1 / 0, s = -1 / 0, p = -1 / 0;
+  for (let h = 0; h < o.length; h += 3) {
+    const m = o[h], w = o[h + 1];
+    m < c && (c = m), m > s && (s = m), w < a && (a = w), w > p && (p = w);
+  }
+  let u = e;
+  jt(e) && (u = null);
+  const l = { tris: o, paint: u, modifiers: r, bbox: { minX: c, minY: a, maxX: s, maxY: p } };
+  return n && (l.baked = St(o)), l;
+}
+async function vt(t) {
+  const e = /* @__PURE__ */ new Map();
+  await Promise.all(t.members.map(async (o) => {
+    e.set(o.path, W(await st(o.data, o.entry)));
+  }));
+  const i = new Set(t.names), n = (o) => {
+    const r = R(o);
+    if (e.has(r)) return e.get(r);
+    if (i.has(r)) throw et;
+    return null;
+  };
+  return {
+    items: t.items.map((o) => {
+      try {
+        return { index: o.index, built: lt(at(o.refs, n), o.volumeRecords, t.bake) };
+      } catch (r) {
+        if (r === et) return { index: o.index, local: !0 };
+        throw r;
+      }
+    })
+  };
+}
+const Rt = (t) => Promise.all(t.map(vt));
+async function Ft(t) {
+  const e = _t(t);
+  if (!e) {
+    const o = /* @__PURE__ */ new Map(), r = await Tt(t);
+    for (const c of Object.keys(r)) o.set(R(c), r[c]);
+    return { names: [...o.keys()], entry: () => null, read: async (c) => o.get(c) ?? null };
+  }
+  const i = /* @__PURE__ */ new Map();
+  for (const [o, r] of e) i.set(R(o), r);
+  const n = /* @__PURE__ */ new Map();
+  return {
+    names: [...i.keys()],
+    entry: (o) => i.get(o) ?? null,
+    read: (o) => {
+      const r = i.get(o);
+      return r ? (n.has(o) || n.set(o, st(rt(t, r), r)), n.get(o)) : Promise.resolve(null);
+    }
+  };
+}
+const nt = (t) => t.toLowerCase().endsWith(".model");
+async function Et(t, e = "model", { runJobs: i = Rt, bake: n = !1 } = {}) {
+  let o = new Uint8Array(t);
+  ArrayBuffer.isView(t) && (o = new Uint8Array(t.buffer, t.byteOffset, t.byteLength));
+  const r = await Ft(o), c = new TextDecoder(), a = /* @__PURE__ */ new Map();
+  await Promise.all(r.names.filter((j) => !nt(j)).map(async (j) => a.set(j, await r.read(j))));
+  let s = "3D/3dmodel.model";
+  const p = a.get("_rels/.rels");
+  if (p) {
+    for (const j of c.decode(p).match(/<Relationship\b[^>]*>/g) || [])
+      if ((D(j, "Type") || "").endsWith("/3dmodel")) {
+        s = R(D(j, "Target"));
+        break;
+      }
+  }
+  const u = Lt(a, c), l = await r.read(s), h = l && W(l);
+  if (!h && u.gcodePlates) return { objects: [], project: u };
+  if (!h) throw new Error(`3MF root model not found: ${s}`);
+  let m = h.items;
+  m.length || (m = [...h.objects.keys()].filter((j) => h.objects.get(j).mesh).map((j) => ({ objectid: j, path: s, transform: At })));
+  const w = [], M = /* @__PURE__ */ new Map(), S = [], A = (j) => {
+    const P = m[j];
+    return { index: j, refs: [{ objectid: P.objectid, path: P.path || s, xf: P.transform, depth: 0 }], volumeRecords: u.volumeMeta.get(P.objectid) || [] };
+  };
+  m.forEach((j, P) => {
+    const _ = j.path || s, x = u.volumeMeta.get(j.objectid) || [];
+    let g = [{ objectid: j.objectid, path: _, xf: j.transform, depth: 0 }];
+    if (R(_) === s) {
+      const f = h.objects.get(j.objectid);
+      f?.components && (g = f.components.map((d) => ({ objectid: d.objectid, path: d.path || _, xf: ct(d.transform, j.transform), depth: 1 })));
+    }
+    const z = [...new Set(g.map((f) => R(f.path)))];
+    if (z.some((f) => f === s || !r.entry(f))) {
+      S.push(A(P));
+      return;
+    }
+    let I = z.map((f) => M.get(f)).find(Boolean);
+    I || (I = { parts: /* @__PURE__ */ new Set(), items: [] }, w.push(I));
+    for (const f of z) {
+      const d = M.get(f);
+      if (d && d !== I) {
+        for (const E of d.parts)
+          I.parts.add(E), M.set(E, I);
+        I.items.push(...d.items), w.splice(w.indexOf(d), 1);
+      }
+      I.parts.add(f), M.set(f, I);
+    }
+    I.items.push({ index: P, refs: g, volumeRecords: x });
+  });
+  const k = new Array(m.length).fill(null), F = w.map((j) => ({
+    members: [...j.parts].map((P) => {
+      const _ = r.entry(P);
+      return { path: P, data: rt(o, _).slice(), entry: { method: _.method, size: _.size } };
+    }),
+    names: r.names,
+    items: j.items,
+    bake: n
+  })).sort((j, P) => P.members.reduce((_, x) => _ + x.data.length, 0) - j.members.reduce((_, x) => _ + x.data.length, 0));
+  for (const j of await i(F))
+    for (const P of j.items)
+      P.local ? S.push(A(P.index)) : k[P.index] = P.built;
+  if (S.length) {
+    const j = /* @__PURE__ */ new Map([[s, h]]);
+    for (const _ of r.names) nt(_) && _ !== s && j.set(_, W(await r.read(_)));
+    const P = (_) => j.get(R(_)) ?? null;
+    for (const _ of S) k[_.index] = lt(at(_.refs, P), _.volumeRecords, n);
+  }
+  const b = [];
+  return m.forEach((j, P) => {
+    const _ = k[P];
+    if (!_) return;
+    const x = (u.sla.supportPoints.get(P + 1) || []).map((d) => ({ ...d, position: tt(j.transform, d.position) })), g = (u.sla.drainHoles.get(P + 1) || []).map((d) => ({
+      ...d,
+      position: tt(j.transform, d.position),
+      normal: kt(j.transform, d.normal)
+    })), z = _.modifiers.map(({ volume: d, kind: E, tris: L }) => ({ id: `${j.objectid}:modifier:${d}`, kind: E, tris: L }));
+    let I = e;
+    m.length > 1 && (I = `${e}#${P + 1}`);
+    const f = { name: I, tris: _.tris, objectid: j.objectid, paint: _.paint, sla: { supportPoints: x, drainHoles: g, modifierVolumes: z }, bbox: _.bbox };
+    _.baked && (f.baked = _.baked), b.push(f);
+  }), { objects: b, project: u };
+}
+export {
+  Pt as a,
+  St as b,
+  xt as f,
+  Et as p,
+  vt as r
+};