three-slicer-viewer 0.2.5 → 0.3.1

package/dist/toolpath.js

@@ -1,4 +1,7 @@
-const _ = {
+import { U as St, b as It, a as kt } from "./viewer_defaults-B7UUZ582.js";
+import { r as bt, S as nt, R as et, t as Tt } from "./toolpath_encoding-BuYs95qZ.js";
+import { T as Pt } from "./theme-2oyfMuvf.js";
+const O = {
   0: [0.35, 0.38, 0.44],
   // travel
   1: [0.98, 0.45, 0.16],
@@ -23,7 +26,7 @@ const _ = {
   // ironing
   11: [0.58, 0.5, 0.88]
   // prime tower
-}, Mt = {
+}, Ot = {
   0: "Travel",
   1: "Wall",
   2: "Sparse",
@@ -36,7 +39,7 @@ const _ = {
   9: "Bridge",
   10: "Ironing",
   11: "Prime"
-}, dt = [
+}, gt = [
   [0.9, 0.26, 0.3],
   [0.27, 0.6, 0.93],
   [0.36, 0.78, 0.42],
@@ -46,17 +49,17 @@ const _ = {
   [0.95, 0.5, 0.72],
   [0.6, 0.6, 0.64]
 ];
-function St(t) {
+function Lt(t) {
   const e = /^#?([0-9a-f]{6})$/i.exec(String(t ?? "").trim());
-  if (!e) return [0.5, 0.5, 0.5];
+  if (!e) return Lt(St);
   const n = parseInt(e[1], 16);
   return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
 }
-function et(t) {
+function ot(t) {
   const e = (n) => Math.max(0, Math.min(255, Math.round((Number(n) || 0) * 255)));
   return e(t?.[0]) * 65536 + e(t?.[1]) * 256 + e(t?.[2]);
 }
-const At = [
+const xt = [
   [0.043, 0.173, 0.478],
   [0.055, 0.325, 0.639],
   [0.067, 0.478, 0.8],
@@ -69,85 +72,85 @@ const At = [
   [0.988, 0.663, 0.012],
   [0.58, 0.149, 0.086]
 ];
-function Nt(t, e, n, r = At) {
+function _t(t, e, n, r = xt) {
   const o = r.length - 1;
   if (o < 0) return [0, 0, 0];
   if (!Number.isFinite(t) || !Number.isFinite(e) || !Number.isFinite(n) || n <= e || t <= e) return r[0];
   if (t >= n) return r[o];
-  const i = (t - e) / (n - e) * o, f = Math.min(o - 1, Math.floor(i)), u = i - f, l = r[f], h = r[f + 1];
-  return [l[0] + (h[0] - l[0]) * u, l[1] + (h[1] - l[1]) * u, l[2] + (h[2] - l[2]) * u];
+  const i = (t - e) / (n - e) * o, f = Math.min(o - 1, Math.floor(i)), u = i - f, l = r[f], m = r[f + 1];
+  return [l[0] + (m[0] - l[0]) * u, l[1] + (m[1] - l[1]) * u, l[2] + (m[2] - l[2]) * u];
 }
-const nt = 8, It = 0.2, bt = 15, kt = 4, ot = {};
-for (const t of Object.keys(_)) ot[t] = et(_[t]);
-function Pt(t) {
+const rt = {};
+for (const t of Object.keys(O)) rt[t] = ot(O[t]);
+function Vt(t) {
   const e = new Float32Array(t.length);
   for (let n = 0; n < t.length; n++) {
     const r = Number(t[n]?.z) || 0, o = n > 0 && Number(t[n - 1]?.z) || 0, i = n > 0 ? r - o : r;
-    e[n] = i > 1e-6 ? i : It;
+    e[n] = i > 1e-6 ? i : kt;
   }
   return e;
 }
-const rt = (t) => t?.paths?.length ? t.paths : null, gt = (t) => {
-  const e = rt(t);
+const it = (t) => t?.paths?.length ? t.paths : null, wt = (t) => {
+  const e = it(t);
   return e ? Math.floor(e.length / nt) : 0;
 };
-function Vt(t, e) {
-  const n = Array.isArray(t) ? t : [], r = n.length, o = Number(e) > 0 ? Number(e) : 0.4, i = Pt(n), f = new Uint32Array(r + 1), u = new Uint32Array(r + 1), l = new Uint32Array(r + 1);
-  let h = 0, c = 0, m = 0;
-  for (let p = 0; p < r; p++) {
-    const U = rt(n[p]), w = gt(n[p]);
-    for (let G = 0; G < w; G++)
-      U[G * nt + 3] & bt ? h++ : c++;
-    m += w, f[p + 1] = h, u[p + 1] = c, l[p + 1] = m;
+function Rt(t, e) {
+  const n = Array.isArray(t) ? t : [], r = n.length, o = Number(e) > 0 ? Number(e) : It, i = Vt(n), f = new Uint32Array(r + 1), u = new Uint32Array(r + 1), l = new Uint32Array(r + 1);
+  let m = 0, c = 0, h = 0;
+  for (let y = 0; y < r; y++) {
+    const U = it(n[y]), w = wt(n[y]);
+    for (let D = 0; D < w; D++)
+      bt(U[D * nt + 3]) === et.TRAVEL ? c++ : m++;
+    h += w, f[y + 1] = m, u[y + 1] = c, l[y + 1] = h;
   }
-  const s = h * 2, b = new Float32Array(s * 4), L = new Float32Array(s * 4), y = new Uint32Array(s * 2), O = new Uint8Array(s), M = new Uint8Array(s), z = new Float32Array(s), S = new Float32Array(s), B = new Int32Array(s), g = new Float32Array(c * 6), C = new Float32Array(m * 3), a = new Uint8Array(m), v = new Float64Array(16);
-  let A = !1, N = 0, I = 1 / 0, P = 1 / 0, V = 1 / 0, J = -1 / 0, Q = -1 / 0, R = -1 / 0, x = 0, st = 0, at = 0, W = 0;
-  for (let p = 0; p < r; p++) {
-    const U = n[p], w = rt(U), G = gt(U), lt = U?.widths, E = i[p], ct = E / 2;
-    for (let X = 0; X < G; X++) {
-      const k = X * nt, Z = w[k], q = w[k + 1], $ = w[k + 2], D = w[k + 4], Y = w[k + 5], H = w[k + 6], ft = w[k + 3] | 0, K = ft & bt, Lt = ft >>> kt;
-      if (Number.isFinite(Z + q + $ + D + Y + H) || (A = !0), a[W] = K === 0 ? 0 : 1, C[W * 3] = D, C[W * 3 + 1] = Y, C[W * 3 + 2] = H, W++, K === 0) {
-        const d = at * 6;
-        g[d] = Z, g[d + 1] = q, g[d + 2] = $, g[d + 3] = D, g[d + 4] = Y, g[d + 5] = H, at++;
+  const a = m * 2, b = new Float32Array(a * 4), x = new Float32Array(a * 4), v = new Uint32Array(a * 2), _ = new Uint8Array(a), F = new Uint8Array(a), V = new Float32Array(a), M = new Float32Array(a), W = new Int32Array(a), g = new Float32Array(c * 6), C = new Float32Array(h * 3), s = new Uint8Array(h), p = new Float64Array(16);
+  let A = !1, S = 0, I = 1 / 0, T = 1 / 0, z = 1 / 0, $ = -1 / 0, J = -1 / 0, Q = -1 / 0, L = 0, st = 0, lt = 0, B = 0;
+  for (let y = 0; y < r; y++) {
+    const U = n[y], w = it(U), D = wt(U), ct = U?.widths, E = i[y], ft = E / 2;
+    for (let j = 0; j < D; j++) {
+      const k = j * nt, X = w[k], Z = w[k + 1], q = w[k + 2], G = w[k + 4], Y = w[k + 5], H = w[k + 6], ut = w[k + 3] | 0, R = bt(ut), Nt = Tt(ut);
+      if (Number.isFinite(X + Z + q + G + Y + H) || (A = !0), s[B] = R === et.TRAVEL ? 0 : 1, C[B * 3] = G, C[B * 3 + 1] = Y, C[B * 3 + 2] = H, B++, R === et.TRAVEL) {
+        const d = lt * 6;
+        g[d] = X, g[d + 1] = Z, g[d + 2] = q, g[d + 3] = G, g[d + 4] = Y, g[d + 5] = H, lt++;
         continue;
       }
-      const tt = lt ? Number(lt[X]) : NaN, ut = Number.isFinite(tt) && tt > 0 ? tt : o, ht = D - Z, mt = Y - q, Ct = Math.atan2(mt, ht), vt = Math.hypot(ht, mt, H - $);
-      Number.isFinite(vt) && (v[K] += vt);
-      const Ft = ot[K] ?? ot[1];
-      for (const [d, T, yt] of [[Z, q, $], [D, Y, H]]) {
-        const F = x * 4;
-        b[F] = d, b[F + 1] = T, b[F + 2] = yt - ct, b[F + 3] = 0, L[F] = E, L[F + 1] = ut, L[F + 2] = Ct, L[F + 3] = Ft, y[x * 2] = st, y[x * 2 + 1] = p, O[x] = K, M[x] = Lt, z[x] = ut, S[x] = E, B[x] = p, x++;
-        const j = yt - ct;
-        d < I && (I = d), d > J && (J = d), T < P && (P = T), T > Q && (Q = T), j < V && (V = j), j > R && (R = j);
-        const pt = Math.max(Math.abs(d), Math.abs(T), Math.abs(j));
-        pt > N && (N = pt);
+      const tt = ct ? Number(ct[j]) : NaN, mt = Number.isFinite(tt) && tt > 0 ? tt : o, ht = G - X, pt = Y - Z, Ft = Math.atan2(pt, ht), vt = Math.hypot(ht, pt, H - q);
+      Number.isFinite(vt) && (p[R] += vt);
+      const Mt = rt[R] ?? rt[1];
+      for (const [d, P, yt] of [[X, Z, q], [G, Y, H]]) {
+        const N = L * 4;
+        b[N] = d, b[N + 1] = P, b[N + 2] = yt - ft, b[N + 3] = 0, x[N] = E, x[N + 1] = mt, x[N + 2] = Ft, x[N + 3] = Mt, v[L * 2] = st, v[L * 2 + 1] = y, _[L] = R, F[L] = Nt, V[L] = mt, M[L] = E, W[L] = y, L++;
+        const K = yt - ft;
+        d < I && (I = d), d > $ && ($ = d), P < T && (T = P), P > J && (J = P), K < z && (z = K), K > Q && (Q = K);
+        const dt = Math.max(Math.abs(d), Math.abs(P), Math.abs(K));
+        dt > S && (S = dt);
       }
       st++;
     }
   }
-  const xt = s > 0 && Number.isFinite(I) ? { min: [I, P, V], max: [J, Q, R] } : null;
+  const Ct = a > 0 && Number.isFinite(I) ? { min: [I, T, z], max: [$, J, Q] } : null;
   return {
     position: b,
-    hwa: L,
-    segIndex: y,
-    nV: s,
-    nSeg: h,
+    hwa: x,
+    segIndex: v,
+    nV: a,
+    nSeg: m,
     layerSegPrefix: f,
     travelPos: g,
     travelPrefix: u,
     nTrav: c,
     movePos: C,
-    moveKind: a,
+    moveKind: s,
     movePrefix: l,
     layerCount: r,
-    maxAbs: N,
+    maxAbs: S,
     hasNaN: A,
-    typeLengths: v,
-    bbox: xt,
-    meta: { vType: O, vTool: M, vWidth: z, vHeight: S, vLayer: B }
+    typeLengths: p,
+    bbox: Ct,
+    meta: { vType: _, vTool: F, vWidth: V, vHeight: M, vLayer: W }
   };
 }
-function Wt(t) {
+function Kt(t) {
   const e = t ?? [];
   let n = 0;
   for (let o = 0; o < 16; o++) n += Number(e[o]) || 0;
@@ -155,24 +158,24 @@ function Wt(t) {
   const r = [];
   for (let o = 0; o < 16; o++) {
     const i = Number(e[o]) || 0;
-    i <= 0 || r.push({ type: o, label: Mt[o] ?? String(o), pct: i / n * 100, color: _[o] ?? _[1] });
+    i <= 0 || r.push({ type: o, label: Ot[o] ?? String(o), pct: i / n * 100, color: O[o] ?? O[1] });
   }
   return r.sort((o, i) => i.pct - o.pct);
 }
-const it = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
-function Ut(t, e) {
-  return it(t, e);
+const at = (t, e) => e >= 0 && e < t.layerCount ? t.movePrefix[e + 1] - t.movePrefix[e] : 0;
+function jt(t, e) {
+  return at(t, e);
 }
-function Gt(t, e, n) {
+function Xt(t, e, n) {
   const r = Math.min(n, t.layerCount - 1);
-  for (let o = r; o >= e; o--) if (it(t, o) > 0) return o;
+  for (let o = r; o >= e; o--) if (at(t, o) > 0) return o;
   return e;
 }
-function Dt(t, e, n) {
-  const r = it(t, e), o = Math.max(0, Math.min(Number(n) || 0, r)), i = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
+function Zt(t, e, n) {
+  const r = at(t, e), o = Math.max(0, Math.min(Number(n) || 0, r)), i = e >= 0 && e < t.layerCount ? t.movePrefix[e] : 0;
   let f = 0, u = 0;
-  for (let h = 0; h < o; h++)
-    t.moveKind[i + h] === 0 ? u++ : f++;
+  for (let m = 0; m < o; m++)
+    t.moveKind[i + m] === 0 ? u++ : f++;
   if (o === 0) return { point: null, segCount: 0, travCount: 0, onTravel: !1 };
   const l = i + o - 1;
   return {
@@ -182,7 +185,7 @@ function Dt(t, e, n) {
     onTravel: t.moveKind[l] === 0
   };
 }
-const wt = [
+const At = [
   { key: "feature", label: "Feature type", cont: !1, unit: "" },
   { key: "speed", label: "Speed", cont: !0, unit: "mm/s" },
   { key: "height", label: "Layer Height", cont: !0, unit: "mm" },
@@ -194,7 +197,7 @@ const wt = [
   //  extruder index is a label, and a heatmap over it would imply tool 2 sits "between" tools 1 and 3.
   { key: "filament", label: "Filament", cont: !1, unit: "" }
 ];
-function Tt(t, e, n, r) {
+function Wt(t, e, n, r) {
   const o = e.vType[n], i = e.vLayer[n], f = i === 0;
   switch (t) {
     case "height":
@@ -211,30 +214,30 @@ function Tt(t, e, n, r) {
       return 0;
   }
 }
-function Yt(t, e, n) {
-  const { meta: r, nV: o } = t, i = new Float32Array(o * 4), f = wt.find((c) => c.key === e) || wt[0];
+function qt(t, e, n) {
+  const { meta: r, nV: o } = t, i = new Float32Array(o * 4), f = At.find((c) => c.key === e) || At[0];
   if (!f.cont) {
-    const c = (n?.toolColors ?? []).map(St), m = f.key === "filament" ? (s) => {
-      const b = r.vTool ? r.vTool[s] : 0;
-      return c[b] || dt[b % dt.length];
-    } : (s) => _[r.vType[s]] || _[1];
-    for (let s = 0; s < o; s++) i[s * 4] = et(m(s));
+    const c = (n?.toolColors ?? []).map(Lt), h = f.key === "filament" ? (a) => {
+      const b = r.vTool ? r.vTool[a] : 0;
+      return c[b] || gt[b % gt.length];
+    } : (a) => O[r.vType[a]] || O[1];
+    for (let a = 0; a < o; a++) i[a * 4] = ot(h(a));
     return { color: i, min: 0, max: 0, viewType: e, label: f.label, unit: f.unit, cont: !1 };
   }
   let u = 1 / 0, l = -1 / 0;
-  const h = new Float32Array(o);
+  const m = new Float32Array(o);
   for (let c = 0; c < o; c++) {
-    const m = Tt(e, r, c, n), s = Number.isFinite(m) ? m : 0;
-    h[c] = s, s < u && (u = s), s > l && (l = s);
+    const h = Wt(e, r, c, n), a = Number.isFinite(h) ? h : 0;
+    m[c] = a, a < u && (u = a), a > l && (l = a);
   }
   Number.isFinite(u) || (u = 0, l = 1);
   for (let c = 0; c < o; c++) {
-    const m = Nt(h[c], u, l, At);
-    i[c * 4] = et(m);
+    const h = _t(m[c], u, l, xt);
+    i[c * 4] = ot(h);
   }
   return { color: i, min: u, max: l, viewType: e, label: f.label, unit: f.unit, cont: !0 };
 }
-const _t = `
+const zt = `
 precision highp float;
 
 uniform mat4 projectionMatrix;
@@ -294,7 +297,7 @@ void main() {
   vColor = unpackColor(iColor);
   gl_Position = projectionMatrix * modelViewMatrix * vec4(world, 1.0);
 }
-`, Ot = `
+`, Bt = `
 precision highp float;
 
 in vec3 vColor;
@@ -310,7 +313,7 @@ void main() {
   float lambert = max(dot(n, normalize(vec3(0.35, 0.35, 1.0))), 0.0);
   fragColor = vec4(vColor * (0.55 + 0.45 * lambert), 1.0);
 }
-`, zt = new Float32Array([
+`, Ut = new Float32Array([
   0,
   0,
   0,
@@ -329,7 +332,7 @@ void main() {
   1,
   3
   // end ring
-]), Bt = (() => {
+]), Dt = (() => {
   const t = [];
   for (let e = 0; e < 4; e++) {
     const n = e, r = (e + 1) % 4, o = 4 + (e + 1) % 4, i = 4 + e;
@@ -337,72 +340,72 @@ void main() {
   }
   return t;
 })();
-function Ht(t, e) {
-  const { nSeg: n, nV: r, position: o, hwa: i, travelPos: f, travelPrefix: u, layerCount: l, meta: h } = e, c = new Float32Array(n * 3), m = new Float32Array(n * 3), s = new Float32Array(n * 2), b = new Float32Array(n), L = new Float32Array(n);
-  for (let a = 0; a < n; a++) {
-    const v = a * 2 * 4, A = (a * 2 + 1) * 4;
-    c[a * 3] = o[v], c[a * 3 + 1] = o[v + 1], c[a * 3 + 2] = o[v + 2], m[a * 3] = o[A], m[a * 3 + 1] = o[A + 1], m[a * 3 + 2] = o[A + 2], s[a * 2] = i[v], s[a * 2 + 1] = i[v + 1], b[a] = i[v + 3], L[a] = h.vLayer[a * 2];
+function $t(t, e) {
+  const { nSeg: n, nV: r, position: o, hwa: i, travelPos: f, travelPrefix: u, layerCount: l, meta: m } = e, c = new Float32Array(n * 3), h = new Float32Array(n * 3), a = new Float32Array(n * 2), b = new Float32Array(n), x = new Float32Array(n);
+  for (let s = 0; s < n; s++) {
+    const p = s * 2 * 4, A = (s * 2 + 1) * 4;
+    c[s * 3] = o[p], c[s * 3 + 1] = o[p + 1], c[s * 3 + 2] = o[p + 2], h[s * 3] = o[A], h[s * 3 + 1] = o[A + 1], h[s * 3 + 2] = o[A + 2], a[s * 2] = i[p], a[s * 2 + 1] = i[p + 1], b[s] = i[p + 3], x[s] = m.vLayer[s * 2];
   }
-  const y = new t.InstancedBufferGeometry();
-  y.setAttribute("tpl", new t.BufferAttribute(zt, 2)), y.setIndex(Bt), y.setAttribute("iStart", new t.InstancedBufferAttribute(c, 3)), y.setAttribute("iEnd", new t.InstancedBufferAttribute(m, 3)), y.setAttribute("iHW", new t.InstancedBufferAttribute(s, 2));
-  const O = new t.InstancedBufferAttribute(b, 1);
-  y.setAttribute("iColor", O), y.setAttribute("iLayer", new t.InstancedBufferAttribute(L, 1)), y.instanceCount = n, y.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
-  const M = new t.RawShaderMaterial({
-    vertexShader: _t,
-    fragmentShader: Ot,
+  const v = new t.InstancedBufferGeometry();
+  v.setAttribute("tpl", new t.BufferAttribute(Ut, 2)), v.setIndex(Dt), v.setAttribute("iStart", new t.InstancedBufferAttribute(c, 3)), v.setAttribute("iEnd", new t.InstancedBufferAttribute(h, 3)), v.setAttribute("iHW", new t.InstancedBufferAttribute(a, 2));
+  const _ = new t.InstancedBufferAttribute(b, 1);
+  v.setAttribute("iColor", _), v.setAttribute("iLayer", new t.InstancedBufferAttribute(x, 1)), v.instanceCount = n, v.boundingSphere = new t.Sphere(new t.Vector3(0, 0, 0), (e.maxAbs || 1) * 2);
+  const F = new t.RawShaderMaterial({
+    vertexShader: zt,
+    fragmentShader: Bt,
     glslVersion: t.GLSL3,
     side: t.DoubleSide,
     uniforms: { uLayerLo: { value: 0 }, uLayerHi: { value: Math.max(0, l - 1) } }
-  }), z = new t.Mesh(y, M);
-  z.frustumCulled = !1;
-  const S = new t.BufferGeometry();
-  S.setAttribute("position", new t.BufferAttribute(f, 3));
-  const B = new t.LineBasicMaterial({ color: 5923440, transparent: !0, opacity: 0.6 }), g = new t.LineSegments(S, B);
+  }), V = new t.Mesh(v, F);
+  V.frustumCulled = !1;
+  const M = new t.BufferGeometry();
+  M.setAttribute("position", new t.BufferAttribute(f, 3));
+  const W = new t.LineBasicMaterial({ color: Pt.travel, transparent: !0, opacity: 0.6 }), g = new t.LineSegments(M, W);
   g.visible = !1, g.frustumCulled = !1;
-  const C = (a, v) => {
-    const A = Math.max(0, l - 1), N = Math.max(0, Math.min(a | 0, A)), I = Math.max(N, Math.min(v | 0, A));
-    M.uniforms.uLayerLo.value = N, M.uniforms.uLayerHi.value = I;
-    const P = u[N] * 2, V = u[I + 1] * 2;
-    S.setDrawRange(P, Math.max(0, V - P));
+  const C = (s, p) => {
+    const A = Math.max(0, l - 1), S = Math.max(0, Math.min(s | 0, A)), I = Math.max(S, Math.min(p | 0, A));
+    F.uniforms.uLayerLo.value = S, F.uniforms.uLayerHi.value = I;
+    const T = u[S] * 2, z = u[I + 1] * 2;
+    M.setDrawRange(T, Math.max(0, z - T));
   };
   return C(0, l - 1), {
-    mesh: z,
+    mesh: V,
     travLines: g,
     setLayerRange: C,
-    setVisibleLayers: (a) => C(0, (a | 0) - 1),
-    setTravelVisible: (a) => {
-      g.visible = !!a;
+    setVisibleLayers: (s) => C(0, (s | 0) - 1),
+    setTravelVisible: (s) => {
+      g.visible = !!s;
     },
     /** color is Float32Array(nV*4) with the packed value in .r — computeColors' output shape. One instance
      *  takes the colour of its first vertex; the two agree, since a segment is one colour. */
-    setColors: (a) => {
-      if (!(!a || a.length < r * 4)) {
-        for (let v = 0; v < n; v++) b[v] = a[v * 2 * 4];
-        O.needsUpdate = !0;
+    setColors: (s) => {
+      if (!(!s || s.length < r * 4)) {
+        for (let p = 0; p < n; p++) b[p] = s[p * 2 * 4];
+        _.needsUpdate = !0;
       }
     },
     dispose: () => {
-      y.dispose(), M.dispose(), S.dispose(), B.dispose();
+      v.dispose(), F.dispose(), M.dispose(), W.dispose();
     },
     nSeg: n,
     layerCount: l
   };
 }
 export {
-  At as DEFAULT_RANGES_COLORS,
-  dt as TOOL_COLOR,
-  _ as TYPE_COLOR,
-  Mt as TYPE_LABEL,
-  Bt as VERTEX_DATA,
-  wt as VIEW_TYPES,
-  Vt as buildSegmentData,
-  Yt as computeColors,
-  St as hexToRgb,
-  Ut as layerMoveCount,
-  Ht as makeToolpath,
-  Dt as moveCursor,
-  et as packColor,
-  Nt as rangeColorAt,
-  Wt as roleRatios,
-  Gt as topMoveLayer
+  xt as DEFAULT_RANGES_COLORS,
+  gt as TOOL_COLOR,
+  O as TYPE_COLOR,
+  Ot as TYPE_LABEL,
+  Dt as VERTEX_DATA,
+  At as VIEW_TYPES,
+  Rt as buildSegmentData,
+  qt as computeColors,
+  Lt as hexToRgb,
+  jt as layerMoveCount,
+  $t as makeToolpath,
+  Zt as moveCursor,
+  ot as packColor,
+  _t as rangeColorAt,
+  Kt as roleRatios,
+  Xt as topMoveLayer
 };

package/dist/toolpath_encoding-BuYs95qZ.js

@@ -0,0 +1,23 @@
+const o = 8;
+const s = Object.freeze({
+  TRAVEL: 0,
+  WALL: 1,
+  SPARSE: 2,
+  SOLID: 3,
+  SKIRT: 4,
+  SUPPORT: 5,
+  RAFT: 6,
+  // the SLA stream puts its pad here, as it puts support trees on SUPPORT
+  GAP: 7,
+  THIN: 8,
+  BRIDGE: 9,
+  IRONING: 10,
+  PRIME: 11
+}), S = (O, R) => O + (R << 4), T = (O) => O & 15, t = (O) => O >>> 4;
+export {
+  s as R,
+  o as S,
+  S as e,
+  T as r,
+  t
+};

package/dist/viewer_defaults-B7UUZ582.js

@@ -0,0 +1,28 @@
+const a = Object.freeze({ width: 200, depth: 200 }), d = 0.42, s = 0.2, E = 1.75, c = "#888888", _ = 0.4, e = 16, t = Object.freeze([
+  "#6aa0dc",
+  "#e08a2b",
+  "#e0473b",
+  "#3bb0e0",
+  "#7ad14a",
+  "#b06ad1",
+  "#d1c34a",
+  "#4ad1a8",
+  "#d16a9a",
+  "#6a7ad1",
+  "#8fd16a",
+  "#d18f6a",
+  "#6ad1d1",
+  "#c74ad1",
+  "#a8a8a8",
+  "#4a6ad1"
+]);
+export {
+  E as D,
+  e as M,
+  _ as S,
+  c as U,
+  s as a,
+  d as b,
+  a as c,
+  t as d
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "three-slicer-viewer",
-  "version": "0.2.5",
-  "description": "The three-slicer viewer without the slicer \u2014 model loading, G-code parsing, GPU toolpath rendering and the settings transforms, under MIT. Plug a slicer in through the `slicer` prop.",
+  "version": "0.3.1",
+  "description": "The three-slicer viewer without the slicer — model loading, G-code parsing, GPU toolpath rendering and the settings transforms, under MIT. Plug a slicer in through the `slicer` prop.",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -51,15 +51,40 @@
     "dist",
     "src/data.js",
     "src/settings",
-    "types"
+    "types",
+    "!**/.omc"
   ],
   "keywords": [
     "3d-printing",
+    "3d-printer",
+    "viewer",
     "gcode",
+    "gcode-viewer",
     "toolpath",
+    "stl",
+    "obj",
+    "3mf",
+    "amf",
+    "ply",
+    "sl1",
+    "sla",
+    "resin",
     "three",
-    "viewer"
+    "three.js",
+    "threejs",
+    "react",
+    "webgl",
+    "model-viewer",
+    "three-slicer"
   ],
+  "homepage": "https://slicer.kimgh06.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kimgh06/three-slicer-viewer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kimgh06/three-slicer-viewer/issues"
+  },
   "peerDependencies": {
     "three": "^0.160.0",
     "react": ">=18",
@@ -76,8 +101,15 @@
       "optional": true
     }
   },
+  "devDependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "three": "^0.160.0",
+    "vite": "^5.4.11"
+  },
   "scripts": {
     "build": "vite build && cp src/make_worker.js dist/make_worker.js",
-    "prepublishOnly": "npm run build && node test_version_lockstep.mjs && node test_toolpath_contract.mjs"
+    "prepublishOnly": "npm run build && node tests/test_version_lockstep.mjs && node tests/test_toolpath_contract.mjs",
+    "test": "for f in tests/test_*.mjs; do node $f || exit 1; done"
   }
 }

package/src/settings/index.js

@@ -1,2 +1,4 @@
 // three-slicer-viewer/settings — the catalog-free settings surface. See settings_core.js.
 export * from './settings_core.js'
+// The derivation's own fallbacks, for callers that need the same numbers (frozen; see kernel_defaults.js).
+export { FFF_FALLBACKS, SLA_FALLBACKS, AUTO_LINE_WIDTH, BED_FALLBACK, MACHINE_LIMITS } from './kernel_defaults.js'