@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/transforms.js

@@ -0,0 +1,57 @@
+import { Pixels as a } from "./pixels.js";
+import { CLEAR as x } from "./blit.js";
+function p(t, e, o, n, u, i = !1) {
+  for (let h = 0; h < e.h * u; h++)
+    for (let f = 0; f < e.w * u; f++) {
+      const l = Math.floor(f / u), w = e.get(i ? e.w - 1 - l : l, Math.floor(h / u));
+      w !== x && w >= 0 && t.set(o + f, n + h, w);
+    }
+  return t;
+}
+function d(t, e = 0.86) {
+  const o = new a(t.w, t.h, x), n = (t.w - 1) / 2, u = (t.h - 1) / 2, i = Math.SQRT1_2 / e;
+  for (let h = 0; h < o.h; h++)
+    for (let f = 0; f < o.w; f++) {
+      const l = f - n, w = h - u, y = Math.round(n + (l + w) * i), M = Math.round(u + (w - l) * i);
+      y < 0 || M < 0 || y >= t.w || M >= t.h || o.set(f, h, t.get(y, M));
+    }
+  return o;
+}
+function m(t) {
+  const e = new a(t.h, t.w, x);
+  for (let o = 0; o < e.h; o++) for (let n = 0; n < e.w; n++) e.set(n, o, t.get(o, t.h - 1 - n));
+  return e;
+}
+function c(t) {
+  const e = new a(t.w, t.h, x);
+  for (let o = 0; o < t.h; o++) for (let n = 0; n < t.w; n++) e.set(n, o, t.get(t.w - 1 - n, t.h - 1 - o));
+  return e;
+}
+function P(t) {
+  const e = new a(t.w, t.h, x);
+  for (let o = 0; o < t.h; o++) for (let n = 0; n < t.w; n++) e.set(n, o, t.get(t.w - 1 - n, o));
+  return e;
+}
+function R(t) {
+  const e = new a(t.w, t.h);
+  for (let o = 0; o < t.h; o++) for (let n = 0; n < t.w; n++) e.set(n, o, t.get(n, t.h - 1 - o));
+  return e;
+}
+function s(t, e) {
+  const o = new a(t.w, t.h, x), n = -e * Math.PI / 180, u = (t.w - 1) / 2, i = (t.h - 1) / 2;
+  for (let h = 0; h < o.h; h++)
+    for (let f = 0; f < o.w; f++) {
+      const l = Math.round(u + (f - u) * Math.cos(n) - (h - i) * Math.sin(n)), w = Math.round(i + (f - u) * Math.sin(n) + (h - i) * Math.cos(n));
+      l < 0 || w < 0 || l >= t.w || w >= t.h || o.set(f, h, t.get(l, w));
+    }
+  return o;
+}
+export {
+  P as flipX,
+  R as flipY,
+  p as resampleBlit,
+  s as rotate,
+  c as turn180,
+  d as turn45,
+  m as turn90
+};

package/dist/kit/tune.js

@@ -0,0 +1,21 @@
+import { song as s } from "../music/compose.js";
+const r = { w: 4, h: 2, q: 1, e: 0.5, s: 0.25, t: 1 / 3 }, c = (o) => o.split(",").map((e) => e.trim()).filter(Boolean).reduce((e, n) => e + r[n.endsWith(".") ? n.slice(-2, -1) : n.slice(-1)] * (n.endsWith(".") ? 1.5 : 1), 0);
+function a(o, e) {
+  const n = e.map((t) => c(t.notes));
+  if (n.some((t) => Math.abs(t - n[0]) > 1e-6)) throw new Error(`Voices differ in length: ${n.join(" ")}`);
+  return s(o, e);
+}
+const f = (o, e, n, t = 100, i = 0) => ({
+  channel: o,
+  instrument: e,
+  notes: n,
+  velocity: t,
+  transpose: i
+}), m = (...o) => o.filter(Boolean).join(", "), h = (o, e) => Array(o).fill(e).join(", ");
+export {
+  r as LEN,
+  m as join,
+  h as times,
+  a as tune,
+  f as v
+};

package/dist/look-alike.js

@@ -0,0 +1,50 @@
+import { emptyBlock as x } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+const d = (e) => [e.birthMon, e.birthTime, ...e.xtra, e.solid, e.hitpt, e.scorePts, e.chHitPt, e.ntime, e.grav, e.obj, e.effect, e.eamt].join(",");
+function g(e, i) {
+  return i.map((a) => Array.from(e.pixels, (p) => `${a[p * 3]}.${a[p * 3 + 1]}.${a[p * 3 + 2]}`).join(" ")).join("|");
+}
+function w(e) {
+  const i = /* @__PURE__ */ new Map();
+  return Array.from(e.pixels, (a) => i.get(a) ?? (i.set(a, i.size), i.size - 1)).join(",");
+}
+function y({ blocks: e, palettes: i, used: a, pinned: p }) {
+  const f = [...a].filter((t) => e[t]).sort((t, o) => t - o), l = (t) => {
+    const o = /* @__PURE__ */ new Map();
+    return t.map((r) => o.get(r) ?? (o.set(r, o.size), o.size - 1));
+  }, n = new Map(f.map((t, o) => [t, o]));
+  let s = l(f.map((t) => g(e[t], i) + "#" + d(e[t])));
+  for (; ; ) {
+    const t = l(f.map((r, h) => `${s[h]}:${s[n.get(e[r].nextBl) ?? -1] ?? -1}:${s[n.get(e[r].touchBl) ?? -1] ?? -1}`)), o = new Set(t).size === new Set(s).size;
+    if (s = t, o) break;
+  }
+  const u = /* @__PURE__ */ new Map();
+  f.forEach((t, o) => u.set(s[o], [...u.get(s[o]) ?? [], t]));
+  const c = { groups: [], pinnedGroups: [], colorVariants: [] };
+  for (const t of u.values()) {
+    if (t.length < 2) continue;
+    const o = t.filter((r) => p.has(r));
+    if (o.length > 1) c.pinnedGroups.push(t);
+    else {
+      const r = o[0] ?? t[0];
+      c.groups.push({ keep: r, fold: t.filter((h) => h !== r) });
+    }
+  }
+  const m = /* @__PURE__ */ new Map();
+  for (const t of f) {
+    if (e[t].pixels.every((r) => r === e[t].pixels[0])) continue;
+    const o = w(e[t]);
+    m.set(o, [...m.get(o) ?? [], t]);
+  }
+  for (const t of m.values()) new Set(t.map((o) => g(e[o], i))).size > 1 && c.colorVariants.push(t);
+  return c;
+}
+function z(e, i, a) {
+  const p = e.map((n, s) => s);
+  for (const n of a) for (const s of n.fold) p[s] = n.keep;
+  const f = new Set(a.flatMap((n) => n.fold));
+  return { blocks: e.map((n, s) => f.has(s) ? x(s) : { ...n, nextBl: p[n.nextBl] ?? n.nextBl, touchBl: p[n.touchBl] ?? n.touchBl }), maps: i.map((n) => ({ ...n, blocks: n.blocks.map((s) => p[s] ?? s) })), to: p };
+}
+export {
+  z as applyFold,
+  y as findLookAlikes
+};

package/dist/menu-version.js

@@ -0,0 +1,4 @@
+import { stampMenuVersion as r } from "./kit/menuVersion.js";
+export {
+  r as stampMenuVersion
+};

package/dist/mesh/colorBodies.js

@@ -0,0 +1,137 @@
+import { decimate as _ } from "./decimate.js";
+import { tetraMesh as z } from "./tetraMesh.js";
+const V = 1e-4, F = (l, n) => Math.hypot(l[0] - n[0], l[1] - n[1], l[2] - n[2]);
+function O(l, n = 4, c = 40) {
+  const { positions: t, indices: g, colors: r } = l;
+  if (!r) throw new Error("The mesh has no colors");
+  const s = /* @__PURE__ */ new Map();
+  for (let o = 0; o < g.length / 3; o++) {
+    const e = g[o * 3] * 3, i = g[o * 3 + 1] * 3, u = g[o * 3 + 2] * 3, M = (t[i + 1] - t[e + 1]) * (t[u + 2] - t[e + 2]) - (t[i + 2] - t[e + 2]) * (t[u + 1] - t[e + 1]), E = (t[i + 2] - t[e + 2]) * (t[u] - t[e]) - (t[i] - t[e]) * (t[u + 2] - t[e + 2]), I = (t[i] - t[e]) * (t[u + 1] - t[e + 1]) - (t[i + 1] - t[e + 1]) * (t[u] - t[e]), p = Math.hypot(M, E, I) / 2, w = [r[o * 3], r[o * 3 + 1], r[o * 3 + 2]], y = (w[0] >> 4) * 256 + (w[1] >> 4) * 16 + (w[2] >> 4), m = s.get(y) ?? { rgb: [0, 0, 0], area: 0 };
+    for (let b = 0; b < 3; b++) m.rgb[b] += w[b] * p;
+    m.area += p, s.set(y, m);
+  }
+  const a = [...s.values()].map((o) => ({ rgb: o.rgb.map((e) => e / o.area), area: o.area })), f = a.reduce((o, e) => o + e.area, 0), d = a.filter((o) => o.area > f * 4e-3), h = [d.reduce((o, e) => e.area > o.area ? e : o).rgb];
+  for (; h.length < n; ) {
+    let o;
+    for (const e of d) {
+      const i = Math.min(...h.map((u) => F(u, e.rgb))) * (1 + Math.sqrt(e.area / f));
+      (!o || i > o.score) && (o = { rgb: e.rgb, score: i });
+    }
+    if (!o || Math.min(...h.map((e) => F(e, o.rgb))) < c) break;
+    h.push(o.rgb);
+  }
+  for (let o = 0; o < 6; o++) {
+    const e = h.map(() => [0, 0, 0, 0]);
+    for (const i of a) {
+      let u = 0;
+      for (let M = 1; M < h.length; M++) F(h[M], i.rgb) < F(h[u], i.rgb) && (u = M);
+      for (let M = 0; M < 3; M++) e[u][M] += i.rgb[M] * i.area;
+      e[u][3] += i.area;
+    }
+    e.forEach((i, u) => {
+      i[3] > 0 && (h[u] = [i[0] / i[3], i[1] / i[3], i[2] / i[3]]);
+    });
+  }
+  return h.map((o) => o.map(Math.round));
+}
+function C(l, n, c, t, g) {
+  let r = 0;
+  c[0] = 0, t[0] = -1 / 0, t[1] = 1 / 0;
+  for (let s = 1; s < n; s++) {
+    let a;
+    for (; a = (l[s] + s * s - (l[c[r]] + c[r] * c[r])) / (2 * s - 2 * c[r]), a <= t[r] && r > 0; )
+      r--;
+    l[s] === 1 / 0 && l[c[r]] === 1 / 0 || (r++, c[r] = s, t[r] = a, t[r + 1] = 1 / 0);
+  }
+  r = 0;
+  for (let s = 0; s < n; s++) {
+    for (; t[r + 1] < s; ) r++;
+    g[s] = (s - c[r]) ** 2 + l[c[r]];
+  }
+}
+function G(l, n, c) {
+  const { positions: t, indices: g, colors: r } = l, s = new Uint8Array(t.length / 3);
+  for (let p = 0; p < g.length / 3; p++) {
+    const w = [r[p * 3], r[p * 3 + 1], r[p * 3 + 2]];
+    let y = 0;
+    for (let m = 1; m < n.length; m++) F(n[m], w) < F(n[y], w) && (y = m);
+    for (let m = 0; m < 3; m++) s[g[p * 3 + m]] = y;
+  }
+  const { cell: a } = c, f = Math.ceil((c.max[0] - c.min[0]) / a) + 3, d = Math.ceil((c.max[1] - c.min[1]) / a) + 3, h = Math.ceil((c.max[2] - c.min[2]) / a) + 3, o = (p, w, y) => p + f * (w + d * y), e = Math.max(f, d, h), [i, u] = [new Float64Array(e), new Float64Array(e)], [M, E] = [new Int32Array(e), new Float64Array(e + 1)], I = n.map((p, w) => {
+    const y = new Float64Array(f * d * h).fill(1 / 0);
+    for (let m = 0; m < s.length; m++) {
+      if (s[m] !== w) continue;
+      const b = Math.round((t[m * 3] - c.min[0]) / a) + 1, A = Math.round((t[m * 3 + 1] - c.min[1]) / a) + 1, q = Math.round((t[m * 3 + 2] - c.min[2]) / a) + 1;
+      b >= 0 && A >= 0 && q >= 0 && b < f && A < d && q < h && (y[o(b, A, q)] = 0);
+    }
+    for (const [m, b, A, q, j] of [
+      [0, f, d, h, 1],
+      [1, d, f, h, f],
+      [2, h, f, d, f * d]
+    ])
+      for (let k = 0; k < A * q; k++) {
+        const T = m === 0 ? o(0, k % d, Math.floor(k / d)) : m === 1 ? o(k % f, 0, Math.floor(k / f)) : o(k % f, Math.floor(k / f), 0);
+        for (let x = 0; x < b; x++) i[x] = y[T + x * j];
+        C(i, b, M, E, u);
+        for (let x = 0; x < b; x++) y[T + x * j] = u[x];
+      }
+    return y;
+  });
+  return (p, w, y, m) => {
+    const b = I[m], A = Math.min(f - 1.001, Math.max(0, (p - c.min[0]) / a + 1)), q = Math.min(d - 1.001, Math.max(0, (w - c.min[1]) / a + 1)), j = Math.min(h - 1.001, Math.max(0, (y - c.min[2]) / a + 1)), k = Math.floor(A), T = Math.floor(q), x = Math.floor(j), [L, P, S] = [A - k, q - T, j - x];
+    let U = 0;
+    for (let v = 0; v < 2; v++)
+      for (let B = 0; B < 2; B++)
+        for (let D = 0; D < 2; D++) U += Math.sqrt(b[o(k + D, T + B, x + v)]) * (D ? L : 1 - L) * (B ? P : 1 - P) * (v ? S : 1 - S);
+    return U * a;
+  };
+}
+const H = (l) => {
+  const n = l.positions;
+  let c = 0;
+  for (let t = 0; t < l.indices.length; t += 3) {
+    const g = l.indices[t] * 3, r = l.indices[t + 1] * 3, s = l.indices[t + 2] * 3;
+    c += (n[g] * (n[r + 1] * n[s + 2] - n[r + 2] * n[s + 1]) - n[g + 1] * (n[r] * n[s + 2] - n[r + 2] * n[s]) + n[g + 2] * (n[r] * n[s + 1] - n[r + 1] * n[s])) / 6;
+  }
+  return c;
+}, J = (l) => {
+  const n = l.positions;
+  let c = 0;
+  for (let t = 0; t < l.indices.length; t += 3) {
+    const g = l.indices[t] * 3, r = l.indices[t + 1] * 3, s = l.indices[t + 2] * 3, a = n[r] - n[g], f = n[r + 1] - n[g + 1], d = n[r + 2] - n[g + 2], h = n[s] - n[g], o = n[s + 1] - n[g + 1], e = n[s + 2] - n[g + 2];
+    c += Math.hypot(f * e - d * o, d * h - a * e, a * o - f * h) / 2;
+  }
+  return c;
+};
+function Q(l, n, c, t) {
+  const g = G(l, n, t), r = (a) => {
+    const f = [];
+    return n.forEach((d, h) => {
+      try {
+        const o = z((e, i, u) => {
+          const M = c(e, i, u) - a;
+          if (M > 8 * t.cell) return M;
+          let E = 1 / 0;
+          for (let I = 0; I < n.length; I++) I !== h && (E = Math.min(E, g(e, i, u, I) + I * V));
+          return Math.max(M, g(e, i, u, h) + h * V - E);
+        }, t);
+        o.indices.length && f.push({ color: d, mesh: o });
+      } catch (o) {
+        if (!/surface leaves the box/.test(String(o))) throw o;
+      }
+    }), f;
+  };
+  let s = r(0);
+  if (t.volume) {
+    const a = s.reduce((f, d) => f + H(d.mesh), 0);
+    if (Math.abs(a / t.volume - 1) > 4e-3) {
+      const f = r((t.volume - a) / J(l));
+      f.length >= s.length && (s = f);
+    }
+  }
+  return t.simplify ? s.map((a) => ({ color: a.color, mesh: _(a.mesh, { maxError: t.simplify }) })) : s;
+}
+export {
+  Q as colorBodies,
+  O as pickPalette
+};

package/dist/mesh/decimate.js

@@ -0,0 +1,207 @@
+function ot(p, r, i, f, n, c, u) {
+  p[r] += u * i * i, p[r + 1] += u * i * f, p[r + 2] += u * i * n, p[r + 3] += u * i * c, p[r + 4] += u * f * f, p[r + 5] += u * f * n, p[r + 6] += u * f * c, p[r + 7] += u * n * n, p[r + 8] += u * n * c, p[r + 9] += u * c * c;
+}
+function V(p, r, i, f) {
+  return p[0] * r * r + 2 * p[1] * r * i + 2 * p[2] * r * f + 2 * p[3] * r + p[4] * i * i + 2 * p[5] * i * f + 2 * p[6] * i + p[7] * f * f + 2 * p[8] * f + p[9];
+}
+class mt {
+  items = [];
+  get size() {
+    return this.items.length;
+  }
+  /** Adds many at once and orders them in one pass. */
+  fill(r) {
+    const i = this.items;
+    for (const f of r) i.push(f);
+    for (let f = (i.length >> 1) - 1; f >= 0; f--) this.down(f);
+  }
+  down(r) {
+    const i = this.items, f = i[r];
+    let n = r;
+    for (; ; ) {
+      let c = n * 2 + 1;
+      if (c >= i.length || (c + 1 < i.length && i[c + 1].cost < i[c].cost && c++, i[c].cost >= f.cost)) break;
+      i[n] = i[c], n = c;
+    }
+    i[n] = f;
+  }
+  push(r) {
+    const i = this.items;
+    let f = i.push(r) - 1;
+    for (; f > 0; ) {
+      const n = f - 1 >> 1;
+      if (i[n].cost <= r.cost) break;
+      i[f] = i[n], f = n;
+    }
+    i[f] = r;
+  }
+  pop() {
+    const r = this.items, i = r[0], f = r.pop();
+    if (f && r.length) {
+      let n = 0;
+      for (; ; ) {
+        let c = n * 2 + 1;
+        if (c >= r.length || (c + 1 < r.length && r[c + 1].cost < r[c].cost && c++, r[c].cost >= f.cost)) break;
+        r[n] = r[c], n = c;
+      }
+      r[n] = f;
+    }
+    return i;
+  }
+}
+function yt(p, r) {
+  const i = p.positions.length / 3, f = p.indices.length / 3, n = Float64Array.from(p.positions), c = Int32Array.from(p.indices), u = p.colors, lt = r.colorStep ?? 30, G = new Float64Array(i * 10), nt = new Uint8Array(f).fill(1), T = new Float64Array(f * 3), W = new Uint8Array(i).fill(1), L = new Int32Array(i), B = Array.from({ length: i }, () => []);
+  for (let o = 0; o < f; o++) for (let t = 0; t < 3; t++) B[c[o * 3 + t]].push(o);
+  const b = new Float64Array(4), N = (o, t = -1, s) => {
+    const a = c[o * 3] * 3, l = c[o * 3 + 1] * 3, e = c[o * 3 + 2] * 3;
+    let h = n[a], m = n[a + 1], A = n[a + 2], I = n[l], C = n[l + 1], O = n[l + 2], d = n[e], j = n[e + 1], D = n[e + 2];
+    if (s) {
+      const z = t * 3;
+      a === z ? [h, m, A] = [s[0], s[1], s[2]] : l === z ? [I, C, O] = [s[0], s[1], s[2]] : e === z && ([d, j, D] = [s[0], s[1], s[2]]);
+    }
+    const w = I - h, g = C - m, v = O - A, F = d - h, M = j - m, x = D - A, U = g * x - v * M, E = v * F - w * x, P = w * M - g * F, S = Math.sqrt(U * U + E * E + P * P);
+    return S < 1e-12 ? b.fill(0) : (b[0] = U / S, b[1] = E / S, b[2] = P / S, b[3] = S / 2), b;
+  }, at = (o, t, s, a) => {
+    const [l, e, h] = N(o);
+    if (!(!l && !e && !h))
+      for (const m of [c[o * 3], c[o * 3 + 1], c[o * 3 + 2]])
+        ot(a, m * 10, l, e, h, -(l * n[t * 3] + e * n[t * 3 + 1] + h * n[t * 3 + 2]), s);
+  };
+  for (let o = 0; o < f; o++)
+    at(o, c[o * 3], 1, G), T[o * 3] = b[0], T[o * 3 + 1] = b[1], T[o * 3 + 2] = b[2];
+  const X = new Int32Array(i);
+  if (u) {
+    const o = /* @__PURE__ */ new Map();
+    for (let t = 0; t < f; t++) {
+      const s = u[t * 3] >> 3 << 10 | u[t * 3 + 1] >> 3 << 5 | u[t * 3 + 2] >> 3;
+      let a = o.get(s);
+      a === void 0 && o.set(s, a = Math.min(o.size, 30));
+      for (let l = 0; l < 3; l++) X[c[t * 3 + l]] |= 1 << a;
+    }
+  }
+  if (u) {
+    const o = /* @__PURE__ */ new Map();
+    for (let t = 0; t < f; t++)
+      for (let s = 0; s < 3; s++) {
+        const a = c[t * 3 + s], l = c[t * 3 + (s + 1) % 3], e = Math.min(a, l) * i + Math.max(a, l), h = o.get(e);
+        if (h === void 0) {
+          o.set(e, t);
+          continue;
+        }
+        if (Math.hypot(u[t * 3] - u[h * 3], u[t * 3 + 1] - u[h * 3 + 1], u[t * 3 + 2] - u[h * 3 + 2]) <= lt)
+          continue;
+        const m = n[l * 3] - n[a * 3], A = n[l * 3 + 1] - n[a * 3 + 1], I = n[l * 3 + 2] - n[a * 3 + 2], C = Math.hypot(m, A, I) || 1;
+        for (const O of [t, h]) {
+          const [d, j, D] = N(O);
+          let w = A * D - I * j, g = I * d - m * D, v = m * j - A * d;
+          const F = Math.hypot(w, g, v);
+          if (F < 1e-12) continue;
+          w /= F, g /= F, v /= F;
+          const M = -(w * n[a * 3] + g * n[a * 3 + 1] + v * n[a * 3 + 2]);
+          ot(G, a * 10, w, g, v, M, 4 * C), ot(G, l * 10, w, g, v, M, 4 * C);
+        }
+      }
+  }
+  const ht = r.maxError * r.maxError, Q = new mt(), J = new Float64Array(10), H = new Int32Array(i);
+  let k = 0;
+  const Y = (o, t = []) => {
+    k++, t.length = 0;
+    for (const s of B[o])
+      for (let a = 0; a < 3; a++) {
+        const l = c[s * 3 + a];
+        l !== o && H[l] !== k && (H[l] = k, t.push(l));
+      }
+    return t;
+  }, K = [], R = [], Z = [], y = new Float64Array(3), pt = (o, t) => {
+    for (let z = 0; z < 10; z++) J[z] = G[o * 10 + z] + G[t * 10 + z];
+    const s = n[o * 3], a = n[o * 3 + 1], l = n[o * 3 + 2], e = n[t * 3], h = n[t * 3 + 1], m = n[t * 3 + 2], A = Math.sqrt((s - e) ** 2 + (a - h) ** 2 + (l - m) ** 2), I = (s + e) / 2, C = (a + h) / 2, O = (l + m) / 2;
+    let d = V(J, I, C, O);
+    y[0] = I, y[1] = C, y[2] = O;
+    const j = V(J, s, a, l);
+    j < d && ([d, y[0], y[1], y[2]] = [j, s, a, l]);
+    const D = V(J, e, h, m);
+    D < d && ([d, y[0], y[1], y[2]] = [D, e, h, m]);
+    const [w, g, v, F, M, x, U, E, P] = J, S = w * (M * E - x * x) - g * (g * E - x * v) + v * (g * x - M * v);
+    if (Math.abs(S) > 1e-9) {
+      const z = -(F * (M * E - x * x) - g * (U * E - x * P) + v * (U * x - M * P)) / S, q = -(w * (U * E - x * P) - F * (g * E - x * v) + v * (g * P - U * v)) / S, tt = -(w * (M * P - U * x) - g * (g * P - U * v) + F * (g * x - M * v)) / S;
+      if ((z - I) ** 2 + (q - C) ** 2 + (tt - O) ** 2 <= A * A) {
+        const ft = V(J, z, q, tt);
+        ft < d && ([d, y[0], y[1], y[2]] = [ft, z, q, tt]);
+      }
+    }
+    return Math.max(0, d);
+  }, st = (o, t, s = void 0) => {
+    const a = pt(o, t);
+    if (a > ht) return;
+    const l = { cost: a, a: o, b: t, va: L[o], vb: L[t], x: y[0], y: y[1], z: y[2] };
+    s ? s.push(l) : Q.push(l);
+  }, et = [];
+  for (let o = 0; o < i; o++) for (const t of Y(o, R)) t > o && st(o, t, et);
+  Q.fill(et);
+  let ct = f;
+  const ut = r.minTriangles ?? 4;
+  for (; Q.size && ct > ut; ) {
+    const o = Q.pop(), { a: t, b: s } = o;
+    if (!W[t] || !W[s] || L[t] !== o.va || L[s] !== o.vb || X[t] !== X[s]) continue;
+    y[0] = o.x, y[1] = o.y, y[2] = o.z, K.length = 0;
+    for (const e of B[t]) (c[e * 3] === s || c[e * 3 + 1] === s || c[e * 3 + 2] === s) && K.push(e);
+    if (K.length !== 2) continue;
+    Y(t, R), Y(s, Z), k++;
+    for (const e of R) H[e] = k;
+    let a = 0;
+    for (const e of Z) H[e] === k && a++;
+    if (a !== 2) continue;
+    let l = !0;
+    for (let e = 0; e < 2 && l; e++) {
+      const h = e ? s : t;
+      for (const m of B[h]) {
+        if (m === K[0] || m === K[1]) continue;
+        const A = N(m, h, y);
+        if (A[3] === 0 || T[m * 3] * A[0] + T[m * 3 + 1] * A[1] + T[m * 3 + 2] * A[2] < 0.25) {
+          l = !1;
+          break;
+        }
+      }
+    }
+    if (l) {
+      for (const e of K) {
+        nt[e] = 0;
+        for (let h = 0; h < 3; h++) {
+          const m = B[c[e * 3 + h]];
+          m[m.indexOf(e)] = m[m.length - 1], m.pop();
+        }
+      }
+      ct -= 2;
+      for (const e of B[s]) {
+        for (let h = 0; h < 3; h++) c[e * 3 + h] === s && (c[e * 3 + h] = t);
+        B[t].push(e);
+      }
+      B[s] = [], n[t * 3] = y[0], n[t * 3 + 1] = y[1], n[t * 3 + 2] = y[2];
+      for (const e of B[t])
+        N(e), T[e * 3] = b[0], T[e * 3 + 1] = b[1], T[e * 3 + 2] = b[2];
+      W[s] = 0;
+      for (let e = 0; e < 10; e++) G[t * 10 + e] += G[s * 10 + e];
+      L[t]++, k++, H[t] = k, H[s] = k;
+      for (const e of [R, Z])
+        for (const h of e)
+          H[h] !== k && (H[h] = k, st(t, h));
+    }
+  }
+  const _ = new Int32Array(i).fill(-1), $ = [], rt = [], it = [];
+  for (let o = 0; o < f; o++)
+    if (nt[o]) {
+      for (let t = 0; t < 3; t++) {
+        const s = c[o * 3 + t];
+        _[s] < 0 && (_[s] = $.length / 3, $.push(n[s * 3], n[s * 3 + 1], n[s * 3 + 2])), rt.push(_[s]);
+      }
+      u && it.push(u[o * 3], u[o * 3 + 1], u[o * 3 + 2]);
+    }
+  return {
+    positions: Float32Array.from($),
+    indices: Uint32Array.from(rt),
+    ...u ? { colors: Uint8Array.from(it) } : {}
+  };
+}
+export {
+  yt as decimate
+};

package/dist/mesh/meshCheck.js

@@ -0,0 +1,51 @@
+function G(D) {
+  const { positions: e, indices: s } = D, E = s.length / 3, h = e.length / 3, o = new Float64Array(s.length), i = new Float64Array(s.length), r = Int32Array.from({ length: h }, (t, n) => n), I = (t) => {
+    for (; r[t] !== t; ) t = r[t] = r[r[t]];
+    return t;
+  };
+  let F = 0, j = 0, k = 0;
+  for (let t = 0; t < E; t++) {
+    const n = s[t * 3], z = s[t * 3 + 1], A = s[t * 3 + 2];
+    for (let c = 0; c < 3; c++) {
+      const u = s[t * 3 + c], w = s[t * 3 + (c + 1) % 3];
+      o[t * 3 + c] = Math.min(u, w) * h + Math.max(u, w), i[t * 3 + c] = u * h + w, r[I(u)] = I(w);
+    }
+    const [l, a, f] = [e[n * 3], e[n * 3 + 1], e[n * 3 + 2]], [g, d, y] = [e[z * 3], e[z * 3 + 1], e[z * 3 + 2]], [p, x, m] = [e[A * 3], e[A * 3 + 1], e[A * 3 + 2]];
+    F += (l * (d * m - y * x) - a * (g * m - y * p) + f * (g * x - d * p)) / 6;
+    const T = (d - a) * (m - f) - (y - f) * (x - a), _ = (y - f) * (p - l) - (g - l) * (m - f), B = (g - l) * (x - a) - (d - a) * (p - l), C = Math.sqrt(T * T + _ * _ + B * B);
+    j += C / 2, C < 1e-12 && k++;
+  }
+  o.sort(), i.sort();
+  let q = 0;
+  for (let t = 0; t < o.length; ) {
+    let n = t;
+    for (; n < o.length && o[n] === o[t]; ) n++;
+    n - t !== 2 && q++, t = n;
+  }
+  let P = 0;
+  for (let t = 1; t < i.length; t++) i[t] === i[t - 1] && i[t] !== i[t - 2] && P++;
+  const S = /* @__PURE__ */ new Set(), M = /* @__PURE__ */ new Map();
+  for (let t = 0; t < s.length; t++) {
+    const n = I(s[t]);
+    S.add(n), t % 3 === 0 && M.set(n, (M.get(n) ?? 0) + 1);
+  }
+  const b = [1 / 0, 1 / 0, 1 / 0], v = [-1 / 0, -1 / 0, -1 / 0];
+  for (let t = 0; t < e.length; t++)
+    b[t % 3] = Math.min(b[t % 3], e[t]), v[t % 3] = Math.max(v[t % 3], e[t]);
+  return {
+    triangles: E,
+    vertices: h,
+    badEdges: q,
+    flippedEdges: P,
+    degenerate: k,
+    pieces: S.size,
+    pieceTriangles: [...M.values()].sort((t, n) => n - t),
+    min: b,
+    max: v,
+    volume: F,
+    area: j
+  };
+}
+export {
+  G as inspectMesh
+};

package/dist/mesh/overhang.js

@@ -0,0 +1,41 @@
+import { inspectMesh as z } from "./meshCheck.js";
+import { tetraMesh as b } from "./tetraMesh.js";
+function B(g, c = 45, s = 0.4) {
+  const { positions: i, indices: e } = g, h = -Math.sin(c * Math.PI / 180);
+  let u = 0, d = 0;
+  for (let r = 0; r < e.length; r += 3) {
+    const a = e[r] * 3, x = e[r + 1] * 3, p = e[r + 2] * 3, k = i[x] - i[a], t = i[x + 1] - i[a + 1], o = i[x + 2] - i[a + 2], n = i[p] - i[a], l = i[p + 1] - i[a + 1], m = i[p + 2] - i[a + 2], f = t * m - o * l, y = o * n - k * m, M = k * l - t * n, w = Math.hypot(f, y, M);
+    d += w / 2;
+    const j = (i[a + 2] + i[x + 2] + i[p + 2]) / 3;
+    w > 0 && M / w < h && j > s && (u += w / 2);
+  }
+  return { area: u, share: d ? u / d : 0 };
+}
+function F(g, c) {
+  const { cell: s } = c, i = Math.ceil((c.max[0] - c.min[0]) / s) + 1, e = Math.ceil((c.max[1] - c.min[1]) / s) + 1, h = Math.ceil((c.max[2] - c.min[2]) / s) + 1, u = (t, o, n) => t + i * (o + e * n), d = new Float32Array(i * e * h);
+  for (let t = 0; t < h; t++)
+    for (let o = 0; o < e; o++) for (let n = 0; n < i; n++) d[u(n, o, t)] = g(c.min[0] + n * s, c.min[1] + o * s, c.min[2] + t * s);
+  const r = (t, o, n) => t >= 0 && o >= 0 && n >= 0 && t < i && o < e && n < h && d[u(t, o, n)] < 0, a = new Uint8Array(i * e * h);
+  let x = !1;
+  for (let t = 1; t < h; t++)
+    for (let o = 0; o < e; o++)
+      for (let n = 0; n < i; n++)
+        if (r(n, o, t) && !(c.min[2] + t * s < 0.4) && !(r(n, o, t - 1) || r(n - 1, o, t - 1) || r(n + 1, o, t - 1) || r(n, o - 1, t - 1) || r(n, o + 1, t - 1)))
+          for (let l = -1; l <= 1; l++)
+            for (let m = -1; m <= 1; m++)
+              for (let f = t - 1; f >= 0; f--) {
+                const y = n + m, M = o + l;
+                if (y < 0 || M < 0 || y >= i || M >= e || d[u(y, M, f)] < c.gap) break;
+                a[u(y, M, f)] = 1, x = !0;
+              }
+  if (!x) return;
+  const p = (t, o, n) => {
+    const l = Math.round((t - c.min[0]) / s), m = Math.round((o - c.min[1]) / s), f = Math.round((n - c.min[2]) / s);
+    return l >= 0 && m >= 0 && f >= 0 && l < i && m < e && f < h && a[u(l, m, f)] ? -1 : 1;
+  }, k = b((t, o, n) => Math.max(p(t, o, n), -n), { min: c.min, max: c.max, cell: s });
+  return z(k).triangles ? k : void 0;
+}
+export {
+  B as overhang,
+  F as supportBody
+};

package/dist/mesh/sampledField.js

@@ -0,0 +1,12 @@
+function C(w, n) {
+  const { cell: t } = n, a = Math.ceil((n.max[0] - n.min[0]) / t) + 10, i = Math.ceil((n.max[1] - n.min[1]) / t) + 10, f = Math.ceil((n.max[2] - n.min[2]) / t) + 10, y = n.min[0] - 3 * t, z = n.min[1] - 3 * t, g = n.min[2] - 3 * t, c = new Float32Array(a * i * f);
+  for (let m = 0; m < f; m++)
+    for (let x = 0; x < i; x++) for (let l = 0; l < a; l++) c[l + a * (x + i * m)] = w(y + l * t, z + x * t, g + m * t);
+  return (m, x, l) => {
+    const u = Math.min(a - 1.0001, Math.max(0, (m - y) / t)), d = Math.min(i - 1.0001, Math.max(0, (x - z) / t)), j = Math.min(f - 1.0001, Math.max(0, (l - g) / t)), k = Math.floor(u), p = Math.floor(d), F = Math.floor(j), s = u - k, e = d - p, v = j - F, o = k + a * (p + i * F), r = 1, h = a, M = a * i, A = c[o] * (1 - s) + c[o + r] * s, b = c[o + h] * (1 - s) + c[o + h + r] * s, q = c[o + M] * (1 - s) + c[o + M + r] * s, B = c[o + h + M] * (1 - s) + c[o + h + M + r] * s;
+    return (A * (1 - e) + b * e) * (1 - v) + (q * (1 - e) + B * e) * v;
+  };
+}
+export {
+  C as sampledField
+};

package/dist/mesh/stl.js

@@ -0,0 +1,36 @@
+function L(f, l = {}) {
+  const { positions: t, indices: c, colors: a } = f, i = c.length / 3, w = new Uint8Array(84 + i * 50), y = new DataView(w.buffer), s = new TextEncoder().encode((l.name ?? "mesh").slice(0, 79));
+  w.set(s, 0), y.setUint32(80, i, !0);
+  for (let e = 0; e < i; e++) {
+    const n = c[e * 3] * 3, o = c[e * 3 + 1] * 3, r = c[e * 3 + 2] * 3, g = t[o] - t[n], h = t[o + 1] - t[n + 1], p = t[o + 2] - t[n + 2], u = t[r] - t[n], F = t[r + 1] - t[n + 1], m = t[r + 2] - t[n + 2];
+    let b = h * m - p * F, d = p * u - g * m, U = g * F - h * u;
+    const z = Math.hypot(b, d, U) || 1;
+    b /= z, d /= z, U /= z;
+    const v = 84 + e * 50, A = [b, d, U, t[n], t[n + 1], t[n + 2], t[o], t[o + 1], t[o + 2], t[r], t[r + 1], t[r + 2]];
+    for (let x = 0; x < 12; x++) y.setFloat32(v + x * 4, A[x], !0);
+    a && y.setUint16(v + 48, 32768 | (a[e * 3] >> 3 | a[e * 3 + 1] >> 3 << 5 | a[e * 3 + 2] >> 3 << 10), !0);
+  }
+  return w;
+}
+function S(f) {
+  const l = new DataView(f.buffer, f.byteOffset, f.byteLength), t = l.getUint32(80, !0);
+  if (f.byteLength !== 84 + t * 50) throw new Error("Not a binary STL: its size does not match its triangle count");
+  const c = [], a = new Uint32Array(t * 3), i = new Uint8Array(t * 3);
+  let w = !1;
+  const y = /* @__PURE__ */ new Map();
+  for (let s = 0; s < t; s++) {
+    const e = 84 + s * 50;
+    for (let o = 0; o < 3; o++) {
+      const r = l.getFloat32(e + 12 + o * 12, !0), g = l.getFloat32(e + 16 + o * 12, !0), h = l.getFloat32(e + 20 + o * 12, !0), p = `${r},${g},${h}`;
+      let u = y.get(p);
+      u === void 0 && (u = c.length / 3, c.push(r, g, h), y.set(p, u)), a[s * 3 + o] = u;
+    }
+    const n = l.getUint16(e + 48, !0);
+    n & 32768 && (w = !0, i[s * 3] = (n & 31) << 3 | 4, i[s * 3 + 1] = (n >> 5 & 31) << 3 | 4, i[s * 3 + 2] = (n >> 10 & 31) << 3 | 4);
+  }
+  return { positions: Float32Array.from(c), indices: a, ...w ? { colors: i } : {} };
+}
+export {
+  S as readStl,
+  L as writeStl
+};