three-slicer-viewer 0.3.1 → 0.3.2

package/dist/model_loaders-DxlFNFOu.js

@@ -0,0 +1,196 @@
+import * as P from "three";
+import { OBJLoader as k } from "three/examples/jsm/loaders/OBJLoader.js";
+import { PLYLoader as x } from "three/examples/jsm/loaders/PLYLoader.js";
+import { AMFLoader as S } from "three/examples/jsm/loaders/AMFLoader.js";
+import { p as M } from "./parse_3mf-BZISF3eW.js";
+import { makeParse3mfWorker as v } from "./make_worker.js";
+const _ = 80, y = 84, B = 50, D = (t) => y + t * B;
+let d = null, h = !1, W = 0;
+const w = /* @__PURE__ */ new Map();
+function $() {
+  if (h || typeof Worker > "u") return null;
+  if (d) return d;
+  try {
+    d = v(), d.onmessage = (t) => {
+      const { id: e, objects: s, project: r, error: n } = t.data || {}, c = w.get(e);
+      c && (w.delete(e), n ? c.reject(new Error(n)) : c.resolve({ objects: s, project: r }));
+    }, d.onerror = () => {
+      h = !0;
+      for (const [, t] of w) t.reject(new Error("3MF parse worker failed"));
+      w.clear(), d = null;
+    };
+  } catch {
+    h = !0, d = null;
+  }
+  return d;
+}
+async function b(t, e) {
+  const s = $();
+  if (!s) return M(t, e);
+  try {
+    const r = ++W, n = new Promise((c, i) => w.set(r, { resolve: c, reject: i }));
+    return s.postMessage({ id: r, buffer: t, baseName: e }), await n;
+  } catch {
+    return M(t, e);
+  }
+}
+const T = ["stl", "obj", "3mf", "amf", "ply"], X = ["gcode", "gco", "g"], A = /* @__PURE__ */ new Map();
+function H(t, e) {
+  for (const s of (Array.isArray(t) ? t : String(t).split(",")).map((r) => r.trim().toLowerCase()))
+    A.set(s, e), T.includes(s) || T.push(s);
+}
+function C(t) {
+  const e = t.lastIndexOf(".");
+  return e < 0 ? "" : t.slice(e + 1).toLowerCase();
+}
+function O(t) {
+  const e = new DataView(t);
+  if (t.byteLength >= y) {
+    const i = e.getUint32(_, !0);
+    if (t.byteLength === D(i)) {
+      const l = new Float32Array(i * 9);
+      let f = y, u = 0;
+      for (let o = 0; o < i; o++) {
+        f += 12;
+        for (let a = 0; a < 3; a++)
+          l[u++] = e.getFloat32(f, !0), l[u++] = e.getFloat32(f + 4, !0), l[u++] = e.getFloat32(f + 8, !0), f += 12;
+        f += 2;
+      }
+      return l;
+    }
+  }
+  const s = new TextDecoder().decode(t), r = /vertex\s+([-\d.eE+]+)\s+([-\d.eE+]+)\s+([-\d.eE+]+)/g, n = [];
+  let c;
+  for (; c = r.exec(s); ) n.push(+c[1], +c[2], +c[3]);
+  return n.length < 9 ? null : new Float32Array(n);
+}
+function j(t, e) {
+  const s = t?.attributes?.position;
+  if (!s || s.count < 3) return null;
+  const r = t.index, n = new P.Vector3(), c = Math.floor((r ? r.count : s.count) / 3), i = new Float32Array(c * 9);
+  let l = 0;
+  const f = (u) => {
+    n.fromBufferAttribute(s, u), e && n.applyMatrix4(e), i[l++] = n.x, i[l++] = n.y, i[l++] = n.z;
+  };
+  if (r)
+    for (let u = 0; u < c * 3; u++) f(r.getX(u));
+  else
+    for (let u = 0; u < c * 3; u++) f(u);
+  return i;
+}
+function F(t) {
+  t.updateMatrixWorld(!0);
+  const e = [];
+  return t.traverse((s) => {
+    s.isMesh && s.geometry && e.push({ geometry: s.geometry, matrix: s.matrixWorld });
+  }), e;
+}
+function L(t, e, s) {
+  const r = e.map((l) => j(l.geometry, l.matrix)).filter(Boolean);
+  if (!r.length) return [];
+  if (s && r.length > 1)
+    return r.map((l, f) => ({ name: `${t}#${f + 1}`, modelPos: l }));
+  if (r.length === 1) return [{ name: t, modelPos: r[0] }];
+  let n = 0;
+  for (const l of r) n += l.length;
+  const c = new Float32Array(n);
+  let i = 0;
+  for (const l of r)
+    c.set(l, i), i += l.length;
+  return [{ name: t, modelPos: c }];
+}
+async function V(t, e) {
+  const s = C(t);
+  switch (s) {
+    case "stl": {
+      const r = O(e);
+      if (!r) throw new Error("Failed to parse STL");
+      return [{ name: t, modelPos: r }];
+    }
+    case "obj": {
+      const r = new k().parse(new TextDecoder().decode(e));
+      return L(t, F(r), !1);
+    }
+    case "ply": {
+      const r = new x().parse(e), n = j(r, null);
+      if (!n) throw new Error("No PLY geometry");
+      return [{ name: t, modelPos: n }];
+    }
+    case "3mf": {
+      const { objects: r, project: n } = await b(e, t), c = r.map((i) => ({ name: i.name, modelPos: i.tris, objectid: i.objectid, paint: i.paint, bbox: i.bbox, project: n }));
+      if (!c.length && n.gcodePlates) return [{ name: t, gcodePlates: n.gcodePlates, project: n }];
+      if (!c.length) throw new Error("No mesh in 3MF");
+      return c;
+    }
+    case "amf": {
+      const r = new S().parse(e), n = L(t, F(r), !0);
+      if (!n.length) throw new Error("No mesh in AMF");
+      return n;
+    }
+    default: {
+      const r = A.get(s);
+      if (!r) throw new Error(`Unsupported format: .${s}`);
+      const n = await r(e, t);
+      if (!n?.length) throw new Error(`No mesh in .${s}`);
+      return n;
+    }
+  }
+}
+function q(t) {
+  return R(t)?.map((e) => I(t, e)) ?? null;
+}
+function I(t, e) {
+  const s = new Float32Array(e.length * 9);
+  let r = 0;
+  for (const n of e) {
+    const c = n * 9;
+    for (let i = 0; i < 9; i++) s[r++] = t[c + i];
+  }
+  return s;
+}
+function R(t) {
+  const e = Math.floor(t.length / 9);
+  if (e < 2) return null;
+  const s = 1e4, r = /* @__PURE__ */ new Map(), n = new Int32Array(e * 3);
+  for (let o = 0; o < e; o++)
+    for (let a = 0; a < 3; a++) {
+      const p = o * 9 + a * 3, m = `${Math.round(t[p] * s)},${Math.round(t[p + 1] * s)},${Math.round(t[p + 2] * s)}`;
+      let g = r.get(m);
+      g === void 0 && (g = r.size, r.set(m, g)), n[o * 3 + a] = g;
+    }
+  const c = new Int32Array(e);
+  for (let o = 0; o < e; o++) c[o] = o;
+  const i = (o) => {
+    for (; c[o] !== o; )
+      c[o] = c[c[o]], o = c[o];
+    return o;
+  }, l = (o, a) => {
+    o = i(o), a = i(a), o !== a && (c[a] = o);
+  }, f = /* @__PURE__ */ new Map();
+  for (let o = 0; o < e; o++)
+    for (let a = 0; a < 3; a++) {
+      const p = n[o * 3 + a], m = n[o * 3 + (a + 1) % 3], g = p < m ? p * 4294967296 + m : m * 4294967296 + p, E = f.get(g);
+      E === void 0 ? f.set(g, o) : l(o, E);
+    }
+  const u = /* @__PURE__ */ new Map();
+  for (let o = 0; o < e; o++) {
+    const a = i(o);
+    let p = u.get(a);
+    p || (p = [], u.set(a, p)), p.push(o);
+  }
+  return u.size < 2 ? null : [...u.values()].sort((o, a) => a.length - o.length);
+}
+export {
+  X as G,
+  _ as S,
+  y as a,
+  B as b,
+  T as c,
+  R as d,
+  I as e,
+  C as f,
+  q as g,
+  V as l,
+  H as r,
+  D as s
+};

package/dist/model_loaders.js

@@ -2,13 +2,16 @@ import "three";
 import "three/examples/jsm/loaders/OBJLoader.js";
 import "three/examples/jsm/loaders/PLYLoader.js";
 import "three/examples/jsm/loaders/AMFLoader.js";
-import "./parse_3mf-jEUAw8JM.js";
+import "./parse_3mf-BZISF3eW.js";
 import "./make_worker.js";
-import { c as a, f as d, l, r as n, d as f } from "./model_loaders-aHV5ix50.js";
+import { G as m, c as n, e as l, f as d, l as E, r as c, d as f, g as C } from "./model_loaders-DxlFNFOu.js";
 export {
-  a as SUPPORTED_EXT,
+  m as GCODE_EXTS,
+  n as SUPPORTED_EXT,
+  l as facetPositions,
   d as fileExt,
-  l as loadModel,
-  n as registerLoader,
-  f as splitConnectedComponents
+  E as loadModel,
+  c as registerLoader,
+  f as splitComponentFacets,
+  C as splitConnectedComponents
 };

package/dist/parse_3mf-BZISF3eW.js

@@ -0,0 +1,327 @@
+import { unzip as Y, unzipSync as H } from "three/examples/jsm/libs/fflate.module.js";
+import { S as W } from "./viewer_defaults-B7UUZ582.js";
+function q(t) {
+  return new Promise((o) => {
+    let s = !1;
+    const e = (r) => {
+      s || (s = !0, o(r));
+    };
+    try {
+      Y(t, (r, i) => e(r ? H(t) : i));
+    } catch {
+      e(H(t));
+    }
+  });
+}
+const L = [1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0];
+function K(t, o) {
+  const s = new Array(12);
+  for (let e = 0; e < 4; e++)
+    for (let r = 0; r < 3; r++)
+      s[e * 3 + r] = t[e * 3] * o[r] + t[e * 3 + 1] * o[3 + r] + t[e * 3 + 2] * o[6 + r] + (e === 3 ? o[9 + r] : 0);
+  return s;
+}
+function U(t) {
+  if (!t) return L;
+  const o = t.trim().split(/\s+/).map(Number);
+  return o.length === 12 && o.every(Number.isFinite) ? o : L;
+}
+const x = {};
+function f(t, o) {
+  const e = (x[o] || (x[o] = new RegExp(`\\b${o}\\s*=\\s*"([^"]*)"`))).exec(t);
+  return e ? e[1] : null;
+}
+const B = /<vertex\s+x="([^"]*)"\s+y="([^"]*)"\s+z="([^"]*)"/g, D = /<triangle\s+v1="([^"]*)"\s+v2="([^"]*)"\s+v3="([^"]*)"([^>]*)/g, C = [
+  ["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
+];
+function G() {
+  return { color: /* @__PURE__ */ new Map(), supports: /* @__PURE__ */ new Map(), seam: /* @__PURE__ */ new Map(), fuzzy: /* @__PURE__ */ new Map() };
+}
+function Q(t) {
+  return !t || C.every(([, o]) => t[o].size === 0);
+}
+function J(t, o, s) {
+  for (const [e, r] of C) {
+    if (!t.includes(e)) continue;
+    const i = f(t, e);
+    i && s[r].set(o, i);
+  }
+}
+function Z(t) {
+  const o = [];
+  B.lastIndex = 0;
+  let s;
+  for (; s = B.exec(t); ) o.push(+s[1], +s[2], +s[3]);
+  if (!o.length)
+    for (const i of t.match(/<vertex\b[^>]*>/g) || []) o.push(+f(i, "x"), +f(i, "y"), +f(i, "z"));
+  if (o.length < 9) return null;
+  const e = [], r = G();
+  for (D.lastIndex = 0; s = D.exec(t); ) {
+    const i = e.length / 3;
+    e.push(+s[1], +s[2], +s[3]), s[4].length > 2 && J(s[4], i, r);
+  }
+  if (!e.length)
+    for (const i of t.match(/<triangle\b[^>]*>/g) || []) {
+      const p = e.length / 3;
+      e.push(+f(i, "v1"), +f(i, "v2"), +f(i, "v3")), J(i, p, r);
+    }
+  return e.length ? { verts: o, tris: e, paint: r } : null;
+}
+function tt(t) {
+  const o = /* @__PURE__ */ new Map(), s = /<object\b([^>]*)>([\s\S]*?)<\/object>/g;
+  let e;
+  for (; e = s.exec(t); ) {
+    const p = f(e[1], "id");
+    if (!p) continue;
+    const u = e[2], n = [];
+    for (const a of u.match(/<component\b[^>]*>/g) || []) {
+      const c = f(a, "objectid");
+      c && n.push({ objectid: c, path: f(a, "p:path") || f(a, "path"), transform: U(f(a, "transform")) });
+    }
+    o.set(p, n.length ? { components: n } : { mesh: Z(u) });
+  }
+  const r = [], i = /<build\b[^>]*>([\s\S]*?)<\/build>/.exec(t);
+  if (i)
+    for (const p of i[1].match(/<item\b[^>]*>/g) || []) {
+      const u = f(p, "objectid");
+      u && r.push({ objectid: u, path: f(p, "p:path") || f(p, "path"), transform: U(f(p, "transform")) });
+    }
+  return { objects: o, items: r };
+}
+function k(t) {
+  const o = String(t).replace(/^\/+/, "");
+  return o.includes("%") ? decodeURIComponent(o) : o;
+}
+function R(t) {
+  const o = {};
+  for (const s of t.match(/<metadata\b[^>]*>/g) || []) {
+    const e = f(s, "key");
+    e && (o[e] = f(s, "value") ?? "");
+  }
+  return o;
+}
+function et(t) {
+  const o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), e = /<object\b([^>]*)>([\s\S]*?)<\/object>/g;
+  let r;
+  for (; r = e.exec(t); ) {
+    const u = f(r[1], "id");
+    if (u) {
+      const n = r[2];
+      o.set(u, R(n.replace(/<(?:part|volume)\b[\s\S]*?<\/(?:part|volume)>/g, "")));
+      const a = [];
+      for (const c of n.match(/<volume\b[\s\S]*?<\/volume>/g) || []) {
+        const d = R(c).volume_type, y = d === "SupportBlocker" ? "blocker" : d === "SupportEnforcer" ? "enforcer" : null, _ = Number(f(c, "firstid")), S = Number(f(c, "lastid"));
+        y && Number.isInteger(_) && Number.isInteger(S) && _ >= 0 && S >= _ && a.push({ firstTriangle: _, lastTriangle: S, kind: y });
+      }
+      a.length && s.set(u, a);
+    }
+  }
+  const i = [], p = /<plate\b[^>]*>([\s\S]*?)<\/plate>/g;
+  for (; r = p.exec(t); ) {
+    const u = r[1], n = R(u.replace(/<model_instance\b[\s\S]*?<\/model_instance>/g, "")), a = [];
+    for (const c of u.match(/<model_instance\b[\s\S]*?<\/model_instance>/g) || []) {
+      const d = R(c).object_id;
+      d && a.push(d);
+    }
+    i.push({ index: Math.max(0, (Number(n.plater_id) || i.length + 1) - 1), objectIds: a, gcodeFile: n.gcode_file || null });
+  }
+  return { objects: o, plates: i, volumes: s };
+}
+const nt = Object.freeze({
+  manualSupportPoints: "prepared-roundtrip",
+  drainHoles: "preserved-unsupported",
+  modifierVolumes: "prepared-mask-filtering",
+  uiEditing: "unavailable"
+});
+function V(t, o, s, e, r) {
+  const i = /* @__PURE__ */ new Map();
+  if (!t?.trim()) return i;
+  const p = t.trim().split(/\r?\n/), u = new RegExp(`^${o}_format_version=(\\d+)$`).exec(p[0]), n = u ? Number(u[1]) : 0;
+  for (const a of p.slice(u ? 1 : 0)) {
+    const c = /^object_id=(\d+)\|(.*)$/.exec(a);
+    if (!c || i.has(Number(c?.[1]))) continue;
+    const d = Number(c[1]), y = c[2].trim() ? c[2].trim().split(/\s+/).map(Number) : [], _ = s(n);
+    if (!_ || y.length % _ !== 0 || y.some((l) => !Number.isFinite(l))) {
+      e.push({ code: o === "support_points" ? "SLA_SUPPORT_POINT_COUNT" : "SLA_DRAIN_HOLE_COUNT", object: d }), i.set(d, []);
+      continue;
+    }
+    const S = [];
+    for (let l = 0; l < y.length; l += _) S.push(r(y.slice(l, l + _), n));
+    i.set(d, S);
+  }
+  return i;
+}
+function X(t, o) {
+  const [s, e, r] = o;
+  return [s * t[0] + e * t[3] + r * t[6] + t[9], s * t[1] + e * t[4] + r * t[7] + t[10], s * t[2] + e * t[5] + r * t[8] + t[11]];
+}
+function ot(t, o) {
+  const [s, e, r] = o, i = [s * t[0] + e * t[3] + r * t[6], s * t[1] + e * t[4] + r * t[7], s * t[2] + e * t[5] + r * t[8]], p = Math.hypot(...i);
+  return p ? i.map((u) => u / p) : i;
+}
+function st(t, o) {
+  const s = (n) => {
+    const a = t.get(n);
+    return a ? o.decode(a) : null;
+  }, e = {
+    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
+  }, r = s("Metadata/project_settings.config");
+  if (r)
+    try {
+      e.settings = JSON.parse(r);
+    } catch {
+      e.settings = null;
+    }
+  const i = s("Metadata/three_slicer_settings.json");
+  if (i) {
+    let n = null;
+    try {
+      n = JSON.parse(i);
+    } catch {
+      n = null;
+    }
+    const a = (c) => c && typeof c == "object" && !Array.isArray(c);
+    if (a(n)) {
+      a(n.viewer) && Object.keys(n.viewer).length && (e.viewerSettings = n.viewer);
+      let c = [];
+      a(n.plates) && (c = Object.entries(n.plates));
+      const d = c.filter(([y, _]) => /^\d+$/.test(y) && a(_) && Object.keys(_).length);
+      d.length && (e.plateSettings = Object.fromEntries(d.map(([y, _]) => [Number(y), _]))), Number.isInteger(n.plateCount) && n.plateCount >= 1 && (e.plateCount = n.plateCount);
+    }
+  }
+  const p = s("Metadata/model_settings.config");
+  if (p) {
+    const n = et(p);
+    e.objectMeta = n.objects, e.plates = n.plates, e.volumeMeta = n.volumes;
+  }
+  const u = e.plates.map((n) => ({ index: n.index, gcode: n.gcodeFile && s(k(n.gcodeFile)) })).filter((n) => n.gcode);
+  return u.length && (e.gcodePlates = u), e.sla.supportPoints = V(
+    s("Metadata/Slic3r_PE_sla_support_points.txt"),
+    "support_points",
+    (n) => n === 0 ? 3 : n === 1 ? 5 : 0,
+    e.sla.issues,
+    (n, a) => ({
+      position: n.slice(0, 3),
+      radius: a === 0 ? W : n[3],
+      type: a === 0 || n[4] === 2 ? "manual" : n[4] === 1 ? "island" : "slope"
+    })
+  ), e.sla.drainHoles = V(
+    s("Metadata/Slic3r_PE_sla_drain_holes.txt"),
+    "drain_holes",
+    (n) => n === 1 ? 8 : 0,
+    e.sla.issues,
+    (n) => {
+      const a = Math.hypot(n[3], n[4], n[5]), c = a ? n.slice(3, 6).map((d) => d / a) : n.slice(3, 6);
+      return { position: n.slice(0, 3).map((d, y) => d + c[y]), normal: c, radius: n[6], height: n[7] - 1 };
+    }
+  ), e.hasLayerHeightProfile = !!s("Metadata/layer_heights_profile.txt")?.trim(), e.hasCustomGcodePerLayer = !!s("Metadata/custom_gcode_per_layer.xml")?.trim(), e;
+}
+async function ct(t, o = "model") {
+  const s = ArrayBuffer.isView(t) ? new Uint8Array(t.buffer, t.byteOffset, t.byteLength) : new Uint8Array(t), e = await q(s), r = /* @__PURE__ */ new Map();
+  for (const l of Object.keys(e)) r.set(k(l), e[l]);
+  const i = new TextDecoder(), p = /* @__PURE__ */ new Map(), u = (l) => {
+    const w = k(l);
+    if (p.has(w)) return p.get(w);
+    const m = r.get(w), M = m ? tt(i.decode(m)) : null;
+    return p.set(w, M), M;
+  };
+  let n = "3D/3dmodel.model";
+  const a = r.get("_rels/.rels");
+  if (a) {
+    for (const l of i.decode(a).match(/<Relationship\b[^>]*>/g) || [])
+      if ((f(l, "Type") || "").endsWith("/3dmodel")) {
+        n = k(f(l, "Target"));
+        break;
+      }
+  }
+  const c = st(r, i), d = u(n);
+  if (!d && c.gcodePlates) return { objects: [], project: c };
+  if (!d) throw new Error(`3MF root model not found: ${n}`);
+  const y = [], _ = (l, w, m, M, P, N) => {
+    if (N > 16) return;
+    const T = u(w)?.objects.get(l);
+    if (!T) return;
+    if (T.components) {
+      for (const j of T.components) _(j.objectid, j.path || w, K(j.transform, m), M, P, N + 1);
+      return;
+    }
+    if (!T.mesh) return;
+    const { verts: E, tris: I, paint: v } = T.mesh, z = M.length / 9;
+    for (let j = 0; j < I.length; j++) {
+      const h = I[j] * 3, b = E[h], g = E[h + 1], A = E[h + 2];
+      M.push(
+        b * m[0] + g * m[3] + A * m[6] + m[9],
+        b * m[1] + g * m[4] + A * m[7] + m[10],
+        b * m[2] + g * m[5] + A * m[8] + m[11]
+      );
+    }
+    if (v) for (const [, j] of C)
+      for (const [h, b] of v[j]) P[j].set(z + h, b);
+  }, S = d.items.length ? d.items : [...d.objects.keys()].filter((l) => d.objects.get(l).mesh).map((l) => ({ objectid: l, path: n, transform: L }));
+  return S.forEach((l, w) => {
+    const m = [], M = G();
+    if (_(l.objectid, l.path || n, l.transform, m, M, 0), m.length < 9) return;
+    let P = new Float32Array(m);
+    const N = [], O = c.volumeMeta.get(l.objectid) || [];
+    if (O.length) {
+      const h = /* @__PURE__ */ new Set();
+      for (let b = 0; b < O.length; b++) {
+        const g = O[b], A = g.firstTriangle * 9, $ = Math.min(m.length, (g.lastTriangle + 1) * 9);
+        if (!(A >= $)) {
+          for (let F = g.firstTriangle; F <= g.lastTriangle; F++) h.add(F);
+          N.push({ id: `${l.objectid}:modifier:${b}`, kind: g.kind, tris: new Float32Array(m.slice(A, $)) });
+        }
+      }
+      if (h.size) {
+        const b = [];
+        for (let g = 0; g < m.length / 9; g++) h.has(g) || b.push(...m.slice(g * 9, g * 9 + 9));
+        P = new Float32Array(b);
+      }
+    }
+    const T = (c.sla.supportPoints.get(w + 1) || []).map((h) => ({ ...h, position: X(l.transform, h.position) })), E = (c.sla.drainHoles.get(w + 1) || []).map((h) => ({
+      ...h,
+      position: X(l.transform, h.position),
+      normal: ot(l.transform, h.normal)
+    }));
+    let I = 1 / 0, v = 1 / 0, z = -1 / 0, j = -1 / 0;
+    for (let h = 0; h < P.length; h += 3) {
+      const b = P[h], g = P[h + 1];
+      b < I && (I = b), b > z && (z = b), g < v && (v = g), g > j && (j = g);
+    }
+    y.push({
+      name: S.length > 1 ? `${o}#${w + 1}` : o,
+      tris: P,
+      objectid: l.objectid,
+      paint: Q(M) ? null : M,
+      sla: { supportPoints: T, drainHoles: E, modifierVolumes: N },
+      bbox: { minX: I, minY: v, maxX: z, maxY: j }
+    });
+  }), { objects: y, project: c };
+}
+export {
+  ct as p
+};

package/dist/parse_3mf.worker.js

@@ -1,4 +1,4 @@
-import { p as f } from "./parse_3mf-jEUAw8JM.js";
+import { p as f } from "./parse_3mf-BZISF3eW.js";
 self.onmessage = async (a) => {
   const { id: s, buffer: r, baseName: t } = a.data || {};
   try {