@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/mesh/surfaceNets.js

@@ -0,0 +1,79 @@
+import { inspectMesh as B } from "./meshCheck.js";
+const D = [
+  [0, 1],
+  [2, 3],
+  [4, 5],
+  [6, 7],
+  [0, 2],
+  [1, 3],
+  [4, 6],
+  [5, 7],
+  [0, 4],
+  [1, 5],
+  [2, 6],
+  [3, 7]
+];
+function G(E, f, A, j = 0) {
+  const { cell: s } = f, c = Math.ceil((f.max[0] - f.min[0]) / s) + 6, l = Math.ceil((f.max[1] - f.min[1]) / s) + 6, u = Math.ceil((f.max[2] - f.min[2]) / s) + 6, b = f.min[0] - 3 * s + A[0] * s, g = f.min[1] - 3 * s + A[1] * s, z = f.min[2] - 3 * s + A[2] * s, d = new Float32Array(c * l * u);
+  for (let n = 0; n < u; n++)
+    for (let t = 0; t < l; t++)
+      for (let e = 0; e < c; e++) {
+        let o = E(b + e * s, g + t * s, z + n * s);
+        const h = (i, p) => i <= 1 || i >= p - 2;
+        if (o < 0 && (h(e, c) || h(t, l) || h(n, u)))
+          throw new Error(
+            `surfaceNets: the surface leaves the box at ${e},${t},${n} of ${c},${l},${u} (${b + e * s}, ${g + t * s}, ${z + n * s}) value ${o}`
+          );
+        (e === 0 || t === 0 || n === 0 || e === c - 1 || t === l - 1 || n === u - 1) && (o = Math.max(o, 1e-6)), d[e + c * (t + l * n)] = o === 0 ? 1e-9 : o;
+      }
+  const M = (n, t, e) => n + c * (t + l * e);
+  for (let n = 0; n < j; n++) {
+    const t = d.slice();
+    for (let e = 1; e < u - 1; e++)
+      for (let o = 1; o < l - 1; o++)
+        for (let h = 1; h < c - 1; h++) {
+          const i = M(h, o, e);
+          d[i] = t[i] * 0.4 + (t[i - 1] + t[i + 1] + t[i - c] + t[i + c] + t[i - c * l] + t[i + c * l]) * 0.1;
+        }
+  }
+  const a = new Int32Array((c - 1) * (l - 1) * (u - 1)).fill(-1), m = (n, t, e) => n + (c - 1) * (t + (l - 1) * e), x = [], k = new Float32Array(8);
+  for (let n = 0; n < u - 1; n++)
+    for (let t = 0; t < l - 1; t++)
+      for (let e = 0; e < c - 1; e++) {
+        let o = 0;
+        for (let r = 0; r < 8; r++)
+          k[r] = d[M(e + (r & 1), t + (r >> 1 & 1), n + (r >> 2))], k[r] < 0 && o++;
+        if (o === 0 || o === 8) continue;
+        let h = 0, i = 0, p = 0, y = 0;
+        for (const [r, $] of D) {
+          const v = k[r], w = k[$];
+          if (v < 0 == w < 0) continue;
+          const N = v / (v - w);
+          h += (r & 1) + N * (($ & 1) - (r & 1)), i += (r >> 1 & 1) + N * (($ >> 1 & 1) - (r >> 1 & 1)), p += (r >> 2) + N * (($ >> 2) - (r >> 2)), y++;
+        }
+        a[m(e, t, n)] = x.length / 3, x.push(b + (e + h / y) * s, g + (t + i / y) * s, z + (n + p / y) * s);
+      }
+  const F = [], I = (n, t, e, o, h) => {
+    const i = (v, w) => (x[v * 3] - x[w * 3]) ** 2 + (x[v * 3 + 1] - x[w * 3 + 1]) ** 2 + (x[v * 3 + 2] - x[w * 3 + 2]) ** 2, [p, y, r, $] = h ? [n, o, e, t] : [n, t, e, o];
+    i(p, r) <= i(y, $) ? F.push(p, y, r, p, r, $) : F.push(p, y, $, y, r, $);
+  };
+  for (let n = 1; n < u - 1; n++)
+    for (let t = 1; t < l - 1; t++)
+      for (let e = 1; e < c - 1; e++) {
+        const o = d[M(e, t, n)] < 0;
+        o !== d[M(e + 1, t, n)] < 0 && I(a[m(e, t - 1, n - 1)], a[m(e, t, n - 1)], a[m(e, t, n)], a[m(e, t - 1, n)], !o), o !== d[M(e, t + 1, n)] < 0 && I(a[m(e - 1, t, n - 1)], a[m(e - 1, t, n)], a[m(e, t, n)], a[m(e, t, n - 1)], !o), o !== d[M(e, t, n + 1)] < 0 && I(a[m(e - 1, t - 1, n)], a[m(e, t - 1, n)], a[m(e, t, n)], a[m(e - 1, t, n)], !o);
+      }
+  return { positions: Float32Array.from(x), indices: Uint32Array.from(F) };
+}
+function S(E, f) {
+  let A, j = 1 / 0;
+  for (let s = 0; s < (f.attempts ?? 30); s++) {
+    const c = s * 0.137, l = G(E, { ...f, cell: f.cell * (1 + 0.013 * s) }, [c % 1, c * 1.7 % 1, c * 2.3 % 1], s >= 22 ? 2 : s >= 10 ? 1 : 0), u = B(l), b = u.badEdges + Math.max(0, u.pieces - (f.maxPieces ?? 1 / 0));
+    if (b === 0) return l;
+    b < j && ([A, j] = [l, b]);
+  }
+  return A;
+}
+export {
+  S as surfaceNets
+};

package/dist/mesh/tetraMesh.js

@@ -0,0 +1,62 @@
+const O = [
+  [0, 1, 3, 7],
+  [0, 3, 2, 7],
+  [0, 2, 6, 7],
+  [0, 6, 4, 7],
+  [0, 4, 5, 7],
+  [0, 5, 1, 7]
+];
+function U(N, x) {
+  const { cell: f } = x, h = Math.ceil((x.max[0] - x.min[0]) / f) + 5, m = Math.ceil((x.max[1] - x.min[1]) / f) + 5, p = Math.ceil((x.max[2] - x.min[2]) / f) + 5, A = x.min[0] - 2 * f, I = x.min[1] - 2 * f, j = x.min[2] - 2 * f, g = new Float32Array(h * m * p);
+  for (let t = 0; t < p; t++)
+    for (let n = 0; n < m; n++)
+      for (let o = 0; o < h; o++) {
+        let c = N(A + o * f, I + n * f, j + t * f);
+        if (c < 0 && (o <= 1 || n <= 1 || t <= 1 || o >= h - 2 || n >= m - 2 || t >= p - 2)) throw new Error("tetraMesh: the surface leaves the box");
+        (o === 0 || n === 0 || t === 0 || o === h - 1 || n === m - 1 || t === p - 1) && (c = Math.max(c, 1e-6)), g[o + h * (n + m * t)] = c === 0 || Math.abs(c) < 1e-9 ? c < 0 ? -1e-9 : 1e-9 : c;
+      }
+  const i = [], v = [], k = /* @__PURE__ */ new Map(), E = h * m * p, d = (t) => [A + t % h * f, I + Math.floor(t / h) % m * f, j + Math.floor(t / (h * m)) * f], M = (t, n) => {
+    t > n && ([t, n] = [n, t]);
+    let o = k.get(t * E + n);
+    if (o === void 0) {
+      const c = g[t], a = g[n], u = Math.min(0.99, Math.max(0.01, c / (c - a))), e = d(t), s = d(n);
+      o = i.length / 3, i.push(e[0] + (s[0] - e[0]) * u, e[1] + (s[1] - e[1]) * u, e[2] + (s[2] - e[2]) * u), k.set(t * E + n, o);
+    }
+    return o;
+  }, F = (t) => {
+    const n = [0, 0, 0];
+    for (const o of t) {
+      const c = d(o);
+      for (let a = 0; a < 3; a++) n[a] += c[a] / t.length;
+    }
+    return n;
+  }, z = (t, n, o, c, a) => {
+    const u = F(c), e = F(a), [s, l, r] = [i[n * 3] - i[t * 3], i[n * 3 + 1] - i[t * 3 + 1], i[n * 3 + 2] - i[t * 3 + 2]], [y, T, q] = [i[o * 3] - i[t * 3], i[o * 3 + 1] - i[t * 3 + 1], i[o * 3 + 2] - i[t * 3 + 2]];
+    (l * q - r * T) * (e[0] - u[0]) + (r * y - s * q) * (e[1] - u[1]) + (s * T - l * y) * (e[2] - u[2]) >= 0 ? v.push(t, n, o) : v.push(t, o, n);
+  }, w = new Int32Array(8);
+  for (let t = 0; t < p - 1; t++)
+    for (let n = 0; n < m - 1; n++)
+      for (let o = 0; o < h - 1; o++) {
+        const c = o + h * (n + m * t);
+        let a = 1 / 0, u = -1 / 0;
+        for (let e = 0; e < 8; e++)
+          w[e] = c + (e & 1) + h * ((e >> 1 & 1) + m * (e >> 2)), a = Math.min(a, g[w[e]]), u = Math.max(u, g[w[e]]);
+        if (!(a >= 0 || u < 0))
+          for (const e of O) {
+            const s = [], l = [];
+            for (const r of e) (g[w[r]] < 0 ? s : l).push(w[r]);
+            if (!(!s.length || !l.length))
+              if (s.length === 1 || l.length === 1) {
+                const r = s.length === 1 ? s[0] : l[0], y = s.length === 1 ? l : s;
+                z(M(r, y[0]), M(r, y[1]), M(r, y[2]), s, l);
+              } else {
+                const r = [M(s[0], l[0]), M(s[0], l[1]), M(s[1], l[1]), M(s[1], l[0])];
+                z(r[0], r[1], r[2], s, l), z(r[0], r[2], r[3], s, l);
+              }
+          }
+      }
+  return { positions: Float32Array.from(i), indices: Uint32Array.from(v) };
+}
+export {
+  U as tetraMesh
+};

package/dist/mesh/threeMf.js

@@ -0,0 +1,58 @@
+import { readZip as u, writeZip as g } from "./zipFile.js";
+const x = (o) => `#${o.map((l) => Math.round(l).toString(16).padStart(2, "0")).join("").toUpperCase()}`, d = (o) => o.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), p = (o) => String(+o.toFixed(3));
+function b(o, l, c = {}) {
+  const n = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">',
+    `<metadata name="Title">${d(l)}</metadata>`,
+    "<resources>",
+    '<basematerials id="1">',
+    ...o.map((a) => `<base name="${d(a.name)}" displaycolor="${x(a.color)}"/>`),
+    "</basematerials>"
+  ];
+  o.forEach((a, e) => {
+    n.push(`<object id="${e + 2}" type="model" name="${d(a.name)}" pid="1" pindex="${e}"><mesh><vertices>`);
+    const s = a.mesh.positions;
+    for (let t = 0; t < s.length; t += 3) n.push(`<vertex x="${p(s[t])}" y="${p(s[t + 1])}" z="${p(s[t + 2])}"/>`);
+    n.push("</vertices><triangles>");
+    const r = a.mesh.indices;
+    for (let t = 0; t < r.length; t += 3) n.push(`<triangle v1="${r[t]}" v2="${r[t + 1]}" v3="${r[t + 2]}"/>`);
+    n.push("</triangles></mesh></object>");
+  }), n.push("</resources><build>", ...o.map((a, e) => `<item objectid="${e + 2}"/>`), "</build></model>");
+  const i = new TextEncoder();
+  return g(
+    [
+      {
+        name: "[Content_Types].xml",
+        data: i.encode(
+          '<?xml version="1.0" encoding="UTF-8"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/></Types>'
+        )
+      },
+      {
+        name: "_rels/.rels",
+        data: i.encode(
+          '<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Target="/3D/3dmodel.model" Id="rel0" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/></Relationships>'
+        )
+      },
+      { name: "3D/3dmodel.model", data: i.encode(n.join(`
+`)) }
+    ],
+    c
+  );
+}
+function v(o, l = {}) {
+  const c = u(o, l).find((e) => e.name === "3D/3dmodel.model");
+  if (!c) throw new Error("No 3D/3dmodel.model in the file");
+  const n = new TextDecoder().decode(c.data), i = [...n.matchAll(/<base name="([^"]*)" displaycolor="#([0-9A-F]{6})"/g)].map(
+    (e) => [e[1], [0, 2, 4].map((s) => parseInt(e[2].slice(s, s + 2), 16))]
+  ), a = [];
+  for (const e of n.matchAll(/<object [^>]*pindex="(\d+)"[^>]*>([\s\S]*?)<\/object>/g)) {
+    const [s, r] = i[Number(e[1])], t = [...e[2].matchAll(/<vertex x="([^"]+)" y="([^"]+)" z="([^"]+)"/g)].flatMap((m) => [Number(m[1]), Number(m[2]), Number(m[3])]), h = [...e[2].matchAll(/<triangle v1="(\d+)" v2="(\d+)" v3="(\d+)"/g)].flatMap((m) => [Number(m[1]), Number(m[2]), Number(m[3])]);
+    a.push({ name: s, color: r, mesh: { positions: Float32Array.from(t), indices: Uint32Array.from(h) } });
+  }
+  return a;
+}
+export {
+  v as read3mf,
+  b as write3mf
+};

package/dist/mesh/zipFile.js

@@ -0,0 +1,52 @@
+const A = new Uint32Array(256).map((s, c) => {
+  let t = c;
+  for (let o = 0; o < 8; o++) t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
+  return t >>> 0;
+});
+function m(s) {
+  let c = 4294967295;
+  for (const t of s) c = A[(c ^ t) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function D(s, c = {}) {
+  const t = new TextEncoder(), o = [], U = [];
+  let n = 0;
+  for (const e of s) {
+    const i = t.encode(e.name), g = c.deflate?.(e.data), h = !!g && g.length < e.data.length, f = h ? g : e.data, d = m(e.data), u = new DataView(new ArrayBuffer(30));
+    u.setUint32(0, 67324752, !0), u.setUint16(4, 20, !0), u.setUint16(6, 2048, !0), u.setUint16(8, h ? 8 : 0, !0), u.setUint32(14, d, !0), u.setUint32(18, f.length, !0), u.setUint32(22, e.data.length, !0), u.setUint16(26, i.length, !0), o.push(new Uint8Array(u.buffer), i, f);
+    const r = new DataView(new ArrayBuffer(46));
+    r.setUint32(0, 33639248, !0), r.setUint16(4, 20, !0), r.setUint16(6, 20, !0), r.setUint16(8, 2048, !0), r.setUint16(10, h ? 8 : 0, !0), r.setUint32(16, d, !0), r.setUint32(20, f.length, !0), r.setUint32(24, e.data.length, !0), r.setUint16(28, i.length, !0), r.setUint32(42, n, !0), U.push(new Uint8Array(r.buffer), i), n += 30 + i.length + f.length;
+  }
+  const p = U.reduce((e, i) => e + i.length, 0), a = new DataView(new ArrayBuffer(22));
+  a.setUint32(0, 101010256, !0), a.setUint16(8, s.length, !0), a.setUint16(10, s.length, !0), a.setUint32(12, p, !0), a.setUint32(16, n, !0);
+  const w = [...o, ...U, new Uint8Array(a.buffer)], l = new Uint8Array(w.reduce((e, i) => e + i.length, 0));
+  let y = 0;
+  for (const e of w)
+    l.set(e, y), y += e.length;
+  return l;
+}
+function E(s, c = {}) {
+  const t = new DataView(s.buffer, s.byteOffset, s.byteLength);
+  let o = s.length - 22;
+  for (; o >= 0 && t.getUint32(o, !0) !== 101010256; ) o--;
+  if (o < 0) throw new Error("Not a ZIP file");
+  const U = t.getUint16(o + 10, !0);
+  let n = t.getUint32(o + 16, !0);
+  const p = new TextDecoder(), a = [];
+  for (let w = 0; w < U; w++) {
+    const l = t.getUint16(n + 10, !0), y = t.getUint32(n + 16, !0), e = t.getUint32(n + 20, !0), i = t.getUint16(n + 28, !0), g = t.getUint16(n + 30, !0), h = t.getUint16(n + 32, !0), f = t.getUint32(n + 42, !0), d = p.decode(s.subarray(n + 46, n + 46 + i)), u = f + 30 + t.getUint16(f + 26, !0) + t.getUint16(f + 28, !0), r = s.subarray(u, u + e);
+    let b = r;
+    if (l === 8) {
+      if (!c.inflate) throw new Error("A deflated entry needs an inflate function");
+      b = c.inflate(r);
+    } else if (l !== 0) throw new Error(`ZIP method ${l} is not supported`);
+    if (m(b) !== y) throw new Error(`ZIP entry ${d} fails its checksum`);
+    a.push({ name: d, data: b }), n += 46 + i + g + h;
+  }
+  return a;
+}
+export {
+  m as crc32,
+  E as readZip,
+  D as writeZip
+};

package/dist/microFont.js

@@ -0,0 +1,101 @@
+const o = Object.freeze({
+  0: "111101101101111",
+  1: "010110010010111",
+  2: "110001010100111",
+  3: "110001010001110",
+  4: "101101111001001",
+  5: "111100110001110",
+  6: "011100111101111",
+  7: "111001010010010",
+  8: "111101111101111",
+  9: "111101111001110",
+  A: "010101111101101",
+  B: "110101110101110",
+  C: "011100100100011",
+  D: "110101101101110",
+  E: "111100110100111",
+  F: "111100110100100",
+  G: "011100101101011",
+  H: "101101111101101",
+  I: "111010010010111",
+  J: "001001001101010",
+  K: "101101110101101",
+  L: "100100100100111",
+  M: "101111111101101",
+  N: "110101101101101",
+  O: "010101101101010",
+  P: "110101110100100",
+  Q: "010101101110011",
+  R: "110101110101101",
+  S: "011100010001110",
+  T: "111010010010010",
+  U: "101101101101111",
+  V: "101101101101010",
+  W: "101101111111101",
+  X: "101101010101101",
+  Y: "101101010010010",
+  Z: "111001010100111",
+  $: "011110010011110",
+  "&": "010101010101011",
+  "-": "000000111000000",
+  "!": "010010010000010",
+  ".": "000000000000010",
+  "'": "010010000000000",
+  " ": "000000000000000",
+  ":": "000010000010000",
+  "/": "001001010100100",
+  ",": "000000000010100",
+  "?": "110001010000010",
+  "+": "000010111010000",
+  ">": "100010001010100",
+  "<": "001010100010001",
+  "(": "010100100100010",
+  ")": "010001001001010",
+  "#": "101111101111101",
+  µ: "000101101111100",
+  "=": "000111000111000",
+  _: "000000000000111",
+  "\\": "100100010001001",
+  '"': "101101000000000",
+  "¢": "010111100111010",
+  "*": "101010101000000",
+  "%": "101001010100101",
+  "@": "010101111100011",
+  "~": "000011110000000"
+}), c = Object.freeze({
+  ...o,
+  2: "111001111100111",
+  3: "111001111001111",
+  5: "111100111001111",
+  6: "111100111101111",
+  7: "111001001010010",
+  9: "111101111001111",
+  C: "111100100100111",
+  G: "111100101101111",
+  J: "001001001101111",
+  O: "111101101101111",
+  P: "111101111100100",
+  Q: "111101101111001",
+  S: "111100111001111",
+  "?": "111001011000010",
+  "*": "000101010101000",
+  "%": "101001010100101",
+  "@": "010101111100011",
+  "~": "000011110000000"
+});
+function f(t, n = !1) {
+  const r = n ? c : o;
+  return Object.freeze(
+    Object.fromEntries(
+      [...t].map((e) => {
+        if (!(e in r)) throw new RangeError(`No micro glyph for ${e}`);
+        return [e, r[e]];
+      })
+    )
+  );
+}
+export {
+  o as MICRO_GLYPHS,
+  c as MICRO_SQUARE_GLYPHS,
+  f as microGlyphs
+};

package/dist/music/compose.js

@@ -0,0 +1,72 @@
+import { encodeCmf as C } from "@lewismoten/gamemaker-sandbox-engine/formats/cmf";
+function c(e) {
+  return Uint8Array.from([
+    e.modChar,
+    e.carChar,
+    e.modLevel,
+    e.carLevel,
+    e.modAD,
+    e.carAD,
+    e.modSR,
+    e.carSR,
+    e.modWave ?? 0,
+    e.carWave ?? 0,
+    e.feedback,
+    0,
+    0,
+    0,
+    0,
+    0
+  ]);
+}
+const S = {
+  piano: c({ modChar: 1, carChar: 1, modLevel: 90, carLevel: 0, modAD: 242, carAD: 243, modSR: 99, carSR: 101, feedback: 8 }),
+  bass: c({ modChar: 1, carChar: 1, modLevel: 26, carLevel: 0, modAD: 246, carAD: 245, modSR: 84, carSR: 69, feedback: 8 }),
+  strings: c({ modChar: 97, carChar: 33, modLevel: 29, carLevel: 0, modAD: 116, carAD: 99, modSR: 19, carSR: 21, feedback: 14 }),
+  brass: c({ modChar: 33, carChar: 33, modLevel: 26, carLevel: 0, modAD: 99, carAD: 116, modSR: 40, carSR: 23, feedback: 12 }),
+  lead: c({ modChar: 34, carChar: 33, modLevel: 27, carLevel: 0, modAD: 244, carAD: 244, modSR: 68, carSR: 36, modWave: 2, feedback: 12 }),
+  bell: c({ modChar: 7, carChar: 1, modLevel: 35, carLevel: 0, modAD: 245, carAD: 243, modSR: 34, carSR: 19, feedback: 4 }),
+  organ: c({ modChar: 50, carChar: 49, modLevel: 68, carLevel: 0, modAD: 240, carAD: 240, modSR: 15, carSR: 15, feedback: 1 }),
+  pad: c({ modChar: 161, carChar: 33, modLevel: 41, carLevel: 0, modAD: 67, carAD: 82, modSR: 5, carSR: 4, modWave: 1, feedback: 10 }),
+  pluck: c({ modChar: 3, carChar: 1, modLevel: 30, carLevel: 0, modAD: 248, carAD: 246, modSR: 53, carSR: 85, feedback: 12 })
+}, D = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 }, L = { w: 4, h: 2, q: 1, e: 0.5, s: 0.25, t: 1 / 3 };
+function R(e) {
+  if (/^r$/i.test(e)) return null;
+  const a = /^([A-G])([#b]?)(-?\d)$/.exec(e);
+  if (!a) throw new Error(`Bad note ${e}`);
+  return 12 * (Number(a[3]) + 1) + D[a[1]] + (a[2] === "#" ? 1 : a[2] === "b" ? -1 : 0);
+}
+function p(e, a) {
+  const n = Math.round(8760 / e), d = [], m = [], l = /* @__PURE__ */ new Map();
+  for (const r of a) {
+    d[r.channel] = r.instrument;
+    let t = 0;
+    for (const h of r.notes.split(",").map((o) => o.trim()).filter(Boolean)) {
+      const o = /^(.+?)\s+([whqest])(\.?)$/.exec(h);
+      if (!o) throw new Error(`Bad note "${h}"`);
+      const i = L[o[2]] * (o[3] ? 1.5 : 1) * n;
+      o[1].replace(/[[\]]/g, " ").trim().split(/\s+/).forEach((u, f) => {
+        const v = R(u);
+        if (v === null) return;
+        const s = Math.min(15, r.channel + f);
+        f > 0 && l.set(s, r.instrument);
+        const A = v + (r.transpose ?? 0);
+        m.push({ tick: t, data: [144 | s, A, r.velocity ?? 100] }), m.push({ tick: t + i * 0.92, data: [128 | s, A, 0] });
+      }), t += i;
+    }
+  }
+  for (const [r, t] of l) d[r] ??= t;
+  for (let r = 0; r < 16; r++) d[r] ??= S.piano;
+  return C({ instruments: d, events: m, ticksPerBeat: n });
+}
+function w(e = 120) {
+  const a = Math.round(8760 / e), n = Array.from({ length: 16 }, () => S.piano);
+  return C({ instruments: n, events: [{ tick: 4 * a, data: [176, 7, 100] }], ticksPerBeat: a });
+}
+export {
+  S as INSTRUMENTS,
+  w as blankSong,
+  R as midi,
+  c as sbi,
+  p as song
+};

package/dist/pack/meshPack.js

@@ -0,0 +1,198 @@
+class k {
+  buf = new Uint8Array(65536);
+  length = 0;
+  room(t) {
+    if (this.length + t <= this.buf.length) return;
+    let s = this.buf.length * 2;
+    for (; s < this.length + t; ) s *= 2;
+    const n = new Uint8Array(s);
+    n.set(this.buf.subarray(0, this.length)), this.buf = n;
+  }
+  bytes(t) {
+    this.room(t.length), this.buf.set(t, this.length), this.length += t.length;
+  }
+  u32(t) {
+    this.room(4), new DataView(this.buf.buffer).setUint32(this.length, t, !0), this.length += 4;
+  }
+  varint(t) {
+    for (this.room(8); t >= 128; )
+      this.buf[this.length++] = t % 128 | 128, t = Math.floor(t / 128);
+    this.buf[this.length++] = t;
+  }
+  done() {
+    return this.buf.slice(0, this.length);
+  }
+}
+class U {
+  constructor(t) {
+    this.data = t, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  }
+  data;
+  at = 0;
+  view;
+  bytes(t) {
+    if (this.at + t > this.data.length) throw new Error("Packed mesh is cut short");
+    const s = this.data.subarray(this.at, this.at + t);
+    return this.at += t, s;
+  }
+  u32() {
+    const t = this.view.getUint32(this.at, !0);
+    return this.at += 4, t;
+  }
+  varint() {
+    let t = 0, s = 1;
+    for (; ; ) {
+      if (this.at >= this.data.length) throw new Error("Packed mesh is cut short");
+      const n = this.data[this.at++];
+      if (t += (n & 127) * s, n < 128) return t;
+      s *= 128;
+    }
+  }
+}
+const F = (e) => e >= 0 ? e * 2 : -e * 2 - 1, L = (e) => e % 2 ? -(e + 1) / 2 : e / 2;
+function m(e, t) {
+  const s = e.length / t, n = new Uint8Array(e.length);
+  for (let o = 0; o < s; o++) for (let r = 0; r < t; r++) n[r * s + o] = e[o * t + r];
+  return n;
+}
+function p(e, t) {
+  const s = e.length / t, n = new Uint8Array(e.length);
+  for (let o = 0; o < s; o++) for (let r = 0; r < t; r++) n[o * t + r] = e[r * s + o];
+  return n;
+}
+function S(e, t = /* @__PURE__ */ new Set()) {
+  const s = new k();
+  let n = 0;
+  for (let o = 0; o < e.length; o++) {
+    t.has(o) && (n = 0);
+    const r = e[o];
+    s.varint(F(n - r)), r >= n && (n = r + 1);
+  }
+  return s.done();
+}
+function v(e, t, s = /* @__PURE__ */ new Set()) {
+  const n = new Uint32Array(t);
+  let o = 0;
+  for (let r = 0; r < t; r++) {
+    s.has(r) && (o = 0);
+    const c = o - L(e.varint());
+    n[r] = c, c >= o && (o = c + 1);
+  }
+  return n;
+}
+function N(e, t, s = /* @__PURE__ */ new Set()) {
+  return v(new U(e), t, s);
+}
+const E = 827542855;
+function I(e, t, s) {
+  const n = (h, l) => e.getFloat32(t + 12 + h * 12 + l * 4, !0), o = n(1, 0) - n(0, 0), r = n(1, 1) - n(0, 1), c = n(1, 2) - n(0, 2), w = n(2, 0) - n(0, 0), f = n(2, 1) - n(0, 1), a = n(2, 2) - n(0, 2), u = r * a - c * f, b = c * w - o * a, g = o * f - r * w, i = Math.sqrt(u * u + b * b + g * g) || 1;
+  s.setFloat32(0, u / i, !0), s.setFloat32(4, b / i, !0), s.setFloat32(8, g / i, !0);
+}
+function V(e) {
+  const t = new DataView(e.buffer, e.byteOffset, e.byteLength), s = e.length >= 84 ? t.getUint32(80, !0) : -1;
+  if (e.length !== 84 + s * 50) throw new Error("Not a binary STL: its size does not match its triangle count");
+  const n = /* @__PURE__ */ new Map(), o = new k(), r = new Uint32Array(s * 3), c = new Uint8Array(s * 2), w = [], f = new DataView(new ArrayBuffer(12)), a = new Uint8Array(f.buffer);
+  for (let i = 0; i < s; i++) {
+    const h = 84 + i * 50;
+    for (let l = 0; l < 3; l++) {
+      const y = h + 12 + l * 12, d = `${t.getUint32(y, !0)},${t.getUint32(y + 4, !0)},${t.getUint32(y + 8, !0)}`;
+      let A = n.get(d);
+      A === void 0 && (A = n.size, n.set(d, A), o.bytes(e.subarray(y, y + 12))), r[i * 3 + l] = A;
+    }
+    c[i * 2] = e[h + 48], c[i * 2 + 1] = e[h + 49], I(t, h, f);
+    for (let l = 0; l < 12; l++)
+      if (a[l] !== e[h + l]) {
+        w.push(i);
+        break;
+      }
+  }
+  const u = new k();
+  u.u32(E), u.u32(s), u.u32(n.size), u.bytes(e.subarray(0, 80)), u.bytes(m(o.done(), 4)), u.bytes(m(c, 2)), u.u32(w.length);
+  for (const i of w)
+    u.u32(i), u.bytes(e.subarray(84 + i * 50, 84 + i * 50 + 12));
+  u.bytes(S(r));
+  const b = u.done(), g = x(b);
+  if (g.length !== e.length || g.some((i, h) => i !== e[h])) throw new Error("The packed STL does not read back the same");
+  return b;
+}
+function x(e) {
+  const t = new U(e);
+  if (t.u32() !== E) throw new Error("Not a packed STL");
+  const s = t.u32(), n = t.u32(), o = t.bytes(80), r = p(t.bytes(n * 12), 4), c = p(t.bytes(s * 2), 2), w = /* @__PURE__ */ new Map();
+  for (let i = t.u32(); i > 0; i--) w.set(t.u32(), t.bytes(12));
+  const f = v(t, s * 3), a = new Uint8Array(84 + s * 50), u = new DataView(a.buffer);
+  a.set(o, 0), u.setUint32(80, s, !0);
+  const b = new DataView(new ArrayBuffer(12)), g = new Uint8Array(b.buffer);
+  for (let i = 0; i < s; i++) {
+    const h = 84 + i * 50;
+    for (let y = 0; y < 3; y++) {
+      const d = f[i * 3 + y];
+      if (d >= n) throw new Error("Packed STL names a corner it does not have");
+      a.set(r.subarray(d * 12, d * 12 + 12), h + 12 + y * 12);
+    }
+    a[h + 48] = c[i * 2], a[h + 49] = c[i * 2 + 1];
+    const l = w.get(i);
+    l ? a.set(l, h) : (I(u, h, b), a.set(g, h));
+  }
+  return a;
+}
+const T = 826690887;
+function P(e) {
+  const t = new k(), s = new TextEncoder();
+  t.u32(T), t.u32(e.length);
+  for (const n of e) {
+    let o = n.data, r = 0;
+    if (/\.stl$/i.test(n.name))
+      try {
+        o = V(n.data), r = 1;
+      } catch {
+      }
+    const c = s.encode(n.name);
+    t.u32(c.length), t.bytes(c), t.bytes(Uint8Array.of(r)), t.u32(o.length), t.bytes(o);
+  }
+  return t.done();
+}
+function O(e) {
+  const t = new U(e);
+  if (t.u32() !== T) throw new Error("Not packed files");
+  const s = new TextDecoder();
+  return Array.from({ length: t.u32() }, () => {
+    const n = s.decode(t.bytes(t.u32())), o = t.bytes(1)[0], r = t.bytes(t.u32());
+    return { name: n, data: o === 1 ? x(r) : r.slice() };
+  });
+}
+const D = 826363207;
+function $(e, t, s) {
+  const n = (e.length - t * 4) / 4;
+  if (!Number.isInteger(n) || n < 0) throw new Error("The file is not float32s then uint32s");
+  const o = new DataView(e.buffer, e.byteOffset, e.byteLength), r = new Uint32Array(n);
+  for (let a = 0; a < n; a++) r[a] = o.getUint32(t * 4 + a * 4, !0);
+  const c = new k();
+  c.u32(D), c.u32(t), c.u32(n), c.u32(s.length);
+  for (const a of s) c.u32(a);
+  c.bytes(m(e.subarray(0, t * 4), 4)), c.bytes(S(r, new Set(s)));
+  const w = c.done(), f = M(w);
+  if (f.length !== e.length || f.some((a, u) => a !== e[u])) throw new Error("The packed arrays do not read back the same");
+  return w;
+}
+function M(e) {
+  const t = new U(e);
+  if (t.u32() !== D) throw new Error("Not packed arrays");
+  const s = t.u32(), n = t.u32(), o = new Set(Array.from({ length: t.u32() }, () => t.u32())), r = new Uint8Array(s * 4 + n * 4);
+  r.set(p(t.bytes(s * 4), 4), 0);
+  const c = v(t, n, o), w = new DataView(r.buffer);
+  for (let f = 0; f < n; f++) w.setUint32(s * 4 + f * 4, c[f], !0);
+  return r;
+}
+export {
+  p as fromPlanes,
+  P as packFiles,
+  $ as packFloatsAndIndices,
+  S as packIndices,
+  V as packStl,
+  m as toPlanes,
+  O as unpackFiles,
+  M as unpackFloatsAndIndices,
+  N as unpackIndices,
+  x as unpackStl
+};