@lewismoten/gamemaker-sandbox-engine 3.1.0 → 3.3.0

package/dist/formats/character.js

@@ -0,0 +1,83 @@
+import { Reader as d, Writer as A } from "./binary.js";
+const r = 20, u = 10, a = 10, c = r + 10, S = 32767, s = 3784, b = 0, q = 1, v = 2, C = 3, I = 4, Q = ["Idle", "Die", "Hurt", "Pick up", "Drop"];
+function k(t) {
+  return { x: t.i16(), y: t.i16(), orient: t.u16(), pic1: t.u16(), pic2: t.u16(), pause: t.u16(), extra: t.bytesOf(5) };
+}
+function w(t, e) {
+  t.i16(e.x).i16(e.y).u16(e.orient).u16(e.pic1).u16(e.pic2).u16(e.pause).bytes(e.extra, 5);
+}
+function M(t) {
+  const e = [];
+  for (let n = 0; n < u; n++) e.push(k(t));
+  return {
+    frames: e,
+    key: t.u16(),
+    sound: t.i8(),
+    on: t.i8(),
+    bloc: t.u8(),
+    ground: t.i8(),
+    jstkBut: t.i8(),
+    jstkMov: t.i8(),
+    norepeat: t.i8(),
+    momentum: t.i8(),
+    xtra: t.bytesOf(5)
+  };
+}
+function R(t, e) {
+  for (const n of e.frames) w(t, n);
+  t.u16(e.key).i8(e.sound).i8(e.on).u8(e.bloc).i8(e.ground).i8(e.jstkBut).i8(e.jstkMov).i8(e.norepeat).i8(e.momentum).bytes(e.xtra, 5);
+}
+function U(t) {
+  const e = new d(t), n = [];
+  for (let o = 0; o < r; o++) n.push(M(e));
+  const i = [e.i16(), e.i16(), e.i16()], p = [e.i16(), e.i16(), e.i16()], y = e.i8(), E = e.i8(), l = e.bytesOf(a), f = [];
+  for (let o = 0; o < c; o++) f.push(e.i16());
+  const x = e.bytesOf(s);
+  return { sequences: n, x: i, y: p, cframe: y, cseq: E, inv: l, meter: f, rest: x };
+}
+function j(t) {
+  const e = new A(s * 2);
+  for (const n of t.sequences) R(e, n);
+  for (const n of t.x) e.i16(n);
+  for (const n of t.y) e.i16(n);
+  e.i8(t.cframe).i8(t.cseq).bytes(t.inv, a);
+  for (const n of t.meter) e.i16(n);
+  return e.bytes(t.rest, s), e.toBytes();
+}
+function m(t = !1) {
+  return { x: 0, y: 0, orient: 0, pic1: 50, pic2: t ? 51 : 50, pause: 1, extra: new Uint8Array(5) };
+}
+function D() {
+  const t = [];
+  for (let n = 0; n < r; n++) {
+    const i = Array.from({ length: u }, () => m(!0));
+    n === b && (i[0] = { ...m(), pic1: 0, pic2: 1, pause: 2 }), t.push({ frames: i, key: 0, sound: 30, on: 0, bloc: 150, ground: 0, jstkBut: 0, jstkMov: 0, norepeat: 0, momentum: 0, xtra: new Uint8Array(5) });
+  }
+  const e = new Array(c).fill(S);
+  e[0] = 100, e[1] = 3;
+  for (let n = r; n < c; n++) e[n] = 1;
+  return { sequences: t, x: [0, 0, 0], y: [0, 0, 0], cframe: 0, cseq: 0, inv: new Uint8Array(a).fill(150), meter: e, rest: new Uint8Array(s) };
+}
+function O(t) {
+  const e = t.frames.findIndex((n) => n.pic2 === 51);
+  return e < 0 ? u : e;
+}
+export {
+  s as CHR_RECORD_SIZE,
+  q as DIESEQ,
+  I as DROPSEQ,
+  v as HURTSEQ,
+  b as IDLESEQ,
+  S as INF_REPEAT,
+  u as MAXFRAME,
+  a as MAXINV,
+  r as MAXSEQ,
+  c as METERS,
+  C as PICKUPSEQ,
+  Q as SEQUENCE_NAMES,
+  m as emptyFrame,
+  O as frameCount,
+  D as newCharacter,
+  U as parseCharacter,
+  j as serializeCharacter
+};

package/dist/formats/cmf.js

@@ -0,0 +1,37 @@
+import { Reader as k } from "./binary.js";
+const h = 146;
+function U(t) {
+  return t[0] === 67 && t[1] === 84 && t[2] === 77 && t[3] === 70;
+}
+function w(t) {
+  if (!U(t)) throw new Error("Not a CMF file");
+  const n = new k(t, 4), i = n.u16(), l = n.u16(), o = n.u16(), u = n.u16(), a = n.u16();
+  n.skip(6);
+  const f = n.bytesOf(16), r = n.u16(), e = n.u16(), c = [];
+  for (let s = 0; s < r; s++) c.push(new k(t, l + s * 16).bytesOf(16));
+  return { version: i, ticksPerBeat: u, clockTicks: a, channelUsed: f, instruments: c, basicTempo: e, music: t.subarray(o) };
+}
+function p(t) {
+  const n = [t & 127];
+  for (t >>>= 7; t > 0; t >>>= 7) n.unshift(t & 127 | 128);
+  return n;
+}
+function E(t) {
+  const i = t.instruments.slice(0, 128), l = new Uint8Array(16), o = [];
+  let u = 0;
+  for (const c of [...t.events].sort((s, m) => s.tick - m.tick)) {
+    const s = Math.max(u, Math.round(c.tick));
+    o.push(...p(s - u), ...c.data), u = s;
+    const m = c.data[0];
+    m >= 128 && m < 240 && (l[m & 15] = 1);
+  }
+  o.push(0, 255, 47, 0);
+  const a = 40, f = a + i.length * 16, r = new Uint8Array(f + o.length), e = new DataView(r.buffer);
+  return r.set([67, 84, 77, 70]), e.setUint16(4, 257, !0), e.setUint16(6, a, !0), e.setUint16(8, f, !0), e.setUint16(10, t.ticksPerBeat ?? 48, !0), e.setUint16(12, h, !0), r.set(l, 20), e.setUint16(36, i.length, !0), e.setUint16(38, t.basicTempo ?? 488, !0), i.forEach((c, s) => r.set(c.subarray(0, 16), a + s * 16)), r.set(o, f), r;
+}
+export {
+  h as CMF_GAMEMAKER_CLOCK,
+  E as encodeCmf,
+  U as isCmf,
+  w as parseCmf
+};

package/dist/formats/cmfEdit.js

@@ -0,0 +1,154 @@
+import { RHYTHM_CHANNELS as h, streamEvents as p } from "./cmfSong.js";
+const v = { off: -1e9, mode: -6e8, program: -5e8, on: 1e9 };
+function r(e, t) {
+  return v[t] + ++e.counter;
+}
+function d(e, t) {
+  return e.notes.filter((o) => o.on.ch === t).sort((o, n) => o.on.tick - n.on.tick || o.on.seq - n.on.seq);
+}
+function b(e, t, o, n, f, i = l) {
+  const c = { type: "on", tick: Math.max(0, Math.round(n)), seq: r(e, "on"), ch: t, a: o, b: a(i) }, m = { type: "off", tick: c.tick + Math.max(1, Math.round(f)), seq: r(e, "off"), ch: t, a: o, b: 0 }, u = { on: c, off: m };
+  return e.notes.push(u), s(e), u;
+}
+const l = 100;
+function a(e) {
+  return Math.max(1, Math.min(127, Math.round(Number.isFinite(e) ? e : l)));
+}
+function x(e, t) {
+  const o = a(t);
+  for (const n of e) n.on.b = o;
+}
+function y(e, t, o = 0) {
+  let n = 0;
+  for (const f of e) {
+    const i = a(f.on.b * t + o);
+    i !== f.on.b && n++, f.on.b = i;
+  }
+  return n;
+}
+function E(e, t) {
+  return 63 - Math.floor((Math.min(127, e) + 128) * (63 - (t & 63)) / 256);
+}
+function C(e, t, o, n, f) {
+  o = Math.max(0, Math.round(o)), n = Math.max(1, Math.round(n));
+  const i = o !== t.on.tick;
+  i && (t.on.tick = o, t.on.seq = r(e, "on"), t.on.status = void 0), f !== t.on.a && (t.on.a = f, t.on.status = void 0);
+  const c = o + n;
+  t.off ? (t.off.tick !== c || i || t.off.a !== f) && (t.off.tick = c, t.off.seq = r(e, "off"), t.off.status = void 0, t.off.fn = void 0, t.off.b = 0) : t.off = { type: "off", tick: c, seq: r(e, "off"), ch: t.on.ch, a: f, b: 0 }, t.off.a = f, s(e);
+}
+function N(e, t) {
+  const o = new Set(t);
+  e.notes = e.notes.filter((n) => !o.has(n));
+}
+function s(e) {
+  let t = 0;
+  for (const o of e.notes) t = Math.max(t, o.off ? o.off.tick : o.on.tick);
+  for (const o of e.events) t = Math.max(t, o.tick);
+  e.end.tick = Math.max(e.end.tick, t);
+}
+function M(e) {
+  let t = 0;
+  for (const o of e.notes) t = Math.max(t, o.off ? o.off.tick : o.on.tick);
+  for (const o of e.events) t = Math.max(t, o.tick);
+  return t;
+}
+function S(e, t) {
+  e.end.tick = Math.max(M(e), Math.round(t), 1);
+}
+function w(e) {
+  let t;
+  const o = (n) => !t || n.tick < t.tick || n.tick === t.tick && n.seq < t.seq;
+  for (const n of e.events) n.type === "mode" && o(n) && (t = n);
+  for (const n of e.notes) o(n.on) && (t = n.on);
+  return !!t && t.type === "mode" && t.a !== 0;
+}
+function P(e) {
+  return e.events.filter((t) => t.type === "mode").sort((t, o) => t.tick - o.tick || t.seq - o.seq);
+}
+function T(e, t) {
+  const o = p(e), n = o.find((i) => i.type === "on"), f = o.filter((i) => i.type === "mode" && (!n || i.tick < n.tick || i.tick === n.tick && i.seq < n.seq));
+  f.length ? f[f.length - 1].a = t ? 1 : 0 : e.events.push({ type: "mode", tick: 0, seq: r(e, "mode"), ch: 0, a: t ? 1 : 0, b: 0 });
+}
+function k(e, t) {
+  return e.events.filter((o) => o.type === "program" && o.ch === t).sort((o, n) => o.tick - n.tick || o.seq - n.seq);
+}
+function I(e, t) {
+  const n = d(e, t)[0]?.on;
+  let f = t;
+  for (const i of k(e, t)) {
+    if (n && (i.tick > n.tick || i.tick === n.tick && i.seq > n.seq)) break;
+    f = i.a;
+  }
+  return f;
+}
+function L(e, t, o) {
+  const n = d(e, t)[0]?.on, f = k(e, t).filter((i) => !n || i.tick < n.tick || i.tick === n.tick && i.seq < n.seq);
+  f.length ? f[f.length - 1].a = o : e.events.push({ type: "program", tick: 0, seq: r(e, "program"), ch: t, a: o, b: 0 });
+}
+function V(e, t, o, n) {
+  o = Math.max(0, Math.round(o));
+  const f = e.events.find((c) => c.type === "program" && c.ch === t && c.tick === o);
+  if (f)
+    return f.a = n, f;
+  const i = { type: "program", tick: o, seq: r(e, "program"), ch: t, a: n, b: 0 };
+  return e.events.push(i), s(e), i;
+}
+function A(e, t) {
+  e.events = e.events.filter((o) => o !== t);
+}
+function H(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const o of e.notes) t.add(o.on.ch);
+  for (const o of e.events) (o.type === "program" || o.type === "raw") && t.add(o.ch);
+  return [...t].sort((o, n) => o - n);
+}
+function O(e, t) {
+  e.notes = e.notes.filter((o) => o.on.ch !== t), e.events = e.events.filter((o) => o.type === "mode" || o.ch !== t);
+}
+function R(e, t) {
+  const o = (n) => Math.round(n * t);
+  for (const n of e.notes) {
+    const f = o(n.on.tick);
+    n.on.tick = f, n.off && (n.off.tick = Math.max(f + 1, o(n.off.tick)));
+  }
+  for (const n of e.events) n.tick = o(n.tick);
+  e.end.tick = o(e.end.tick), e.leadIn = o(e.leadIn), e.ticksPerBeat = Math.max(1, o(e.ticksPerBeat)), s(e);
+}
+function B(e) {
+  const t = e.events.length;
+  return e.events = e.events.filter((o) => o.type === "program" || o.type === "mode" || o.prefix !== void 0 || o.type === "off" && o.status === !1), t - e.events.length;
+}
+function D(e) {
+  return e.events.filter((t) => t.type === "raw" && t.prefix === void 0 || t.type === "off" && t.status !== !1).length;
+}
+function F(e, t) {
+  return t ? e < 6 || h.includes(e) : e < 9;
+}
+export {
+  l as DEFAULT_VELOCITY,
+  b as addNote,
+  d as channelNotes,
+  F as channelSounds,
+  a as clampVelocity,
+  N as deleteNotes,
+  s as extendEnd,
+  D as ignoredCount,
+  M as lastEventTick,
+  P as modeChanges,
+  k as programChanges,
+  O as removeChannel,
+  A as removeEvent,
+  R as scaleTime,
+  y as scaleVelocities,
+  S as setEnd,
+  C as setNote,
+  V as setProgramAt,
+  T as setStartMode,
+  L as setStartProgram,
+  x as setVelocity,
+  w as startMode,
+  I as startProgram,
+  B as stripIgnored,
+  H as usedChannels,
+  E as velocityLevel
+};

package/dist/formats/cmfPreview.js

@@ -0,0 +1,89 @@
+import { DEFAULT_VELOCITY as q, clampVelocity as E } from "./cmfEdit.js";
+import { RHYTHM_CHANNELS as g, writeSong as w, streamEvents as T, noteEnd as I } from "./cmfSong.js";
+function x(c, s = {}) {
+  const u = s.muted ?? /* @__PURE__ */ new Set(), i = Math.max(1, c.end.tick), r = [];
+  if (s.loop) {
+    const [t, n] = s.loop, o = Math.max(t, Math.min(s.from ?? t, n - 1));
+    o > t && r.push({ from: o, to: n, gap: 0, prelude: !0 }), r.push({ from: t, to: n, gap: 0, prelude: !0 });
+  } else {
+    const t = Math.max(0, Math.min(s.from ?? 0, i - 1));
+    if (t > 0) {
+      r.push({ from: t, to: i, gap: 0, prelude: !0 });
+      let n = i - t;
+      for (let o = 0; o < 12 && n < 146 * 300; o++)
+        r.push({ from: 0, to: i, gap: c.leadIn, prelude: !1 }), n += i + c.leadIn;
+    } else r.push({ from: 0, to: i, gap: 0, prelude: !1 });
+  }
+  const m = T(c), a = {
+    ...c,
+    notes: [],
+    events: [],
+    end: { tick: 0, bytes: [] },
+    leadIn: 0,
+    leadInBytes: void 0,
+    hadEvents: new Array(16).fill(!0)
+  };
+  let p = 0;
+  const l = (t) => a.events.push({ ...t, seq: p++, status: void 0, delta: void 0 });
+  let f = 0;
+  const d = [];
+  for (const t of r) {
+    f += t.gap, d.push(f);
+    const n = f - t.from;
+    if (t.prelude) {
+      let o;
+      const b = /* @__PURE__ */ new Map();
+      for (const e of m) {
+        if (e.tick > t.from || e.tick === t.from && e.type === "on") break;
+        e.type === "mode" && (o = e), e.type === "program" && b.set(e.ch, e.a);
+      }
+      l({ type: "mode", tick: f, ch: o?.ch ?? 0, a: o ? o.a : 0, b: 0 });
+      for (let e = 0; e < 16; e++) l({ type: "program", tick: f, ch: e, a: b.get(e) ?? e, b: 0 });
+      const k = /* @__PURE__ */ new Map();
+      for (const e of c.notes) {
+        if (u.has(e.on.ch) || e.on.tick >= t.from || I(c, e) <= t.from) continue;
+        const v = k.get(e.on.ch);
+        (!v || e.on.tick > v.on.tick) && k.set(e.on.ch, e);
+      }
+      for (const e of k.values())
+        l({ type: "on", tick: f, ch: e.on.ch, a: e.on.a, b: e.on.b }), e.off && e.off.tick < t.to && l({ type: "off", tick: e.off.tick + n, ch: e.on.ch, a: e.on.a, b: 0 });
+    }
+    for (const o of m)
+      o.tick < t.from || o.tick >= t.to || o.type !== "raw" && (o.type === "on" && u.has(o.ch) || l({ type: o.type, tick: o.tick + n, ch: o.ch, a: o.a, b: o.b, fn: o.fn, bytes: o.bytes }));
+    for (const o of c.notes)
+      o.on.tick < t.to && I(c, o) > t.to && !u.has(o.on.ch) && l({ type: "off", tick: t.to + n, ch: o.on.ch, a: o.on.a, b: 0 });
+    f += t.to - t.from;
+  }
+  a.events.sort((t, n) => t.tick - n.tick || t.seq - n.seq), a.end = { tick: f, bytes: [] }, a.clockTicks = c.clockTicks;
+  const h = f, y = r.length === 1 && !s.loop && r[0].from === 0;
+  y && (a.leadIn = c.leadIn);
+  const M = (t) => {
+    if (y && t >= h) {
+      const n = (t - h) % (h + c.leadIn);
+      return n < c.leadIn ? -1 : n - c.leadIn;
+    }
+    t = (t % h + h) % h;
+    for (let n = r.length - 1; n >= 0; n--) {
+      if (t >= d[n]) return Math.min(r[n].to, r[n].from + (t - d[n]));
+      if (t >= d[n] - r[n].gap) return -1;
+    }
+    return r[0].from;
+  };
+  return { bytes: w(a), length: h, songTick: M };
+}
+function H(c, s, u, i, r = 70, m = q) {
+  const a = g.includes(s), p = {
+    ...c,
+    notes: [],
+    events: [],
+    end: { tick: r + 600, bytes: [] },
+    leadIn: 0,
+    leadInBytes: void 0,
+    hadEvents: new Array(16).fill(!0)
+  };
+  return p.events.push({ type: "mode", tick: 0, seq: 0, ch: 0, a: a ? 1 : 0, b: 0 }), p.events.push({ type: "program", tick: 0, seq: 1, ch: s, a: u, b: 0 }), p.events.push({ type: "on", tick: 0, seq: 2, ch: s, a: i, b: E(m) }), p.events.push({ type: "off", tick: r, seq: 3, ch: s, a: i, b: 0 }), w(p);
+}
+export {
+  H as auditionSong,
+  x as buildPreview
+};

package/dist/formats/cmfSong.js

@@ -0,0 +1,190 @@
+import { isCmf as S } from "./cmf.js";
+const O = [11, 12, 13, 14, 15], P = { 11: "Bass drum", 12: "Snare drum", 13: "Tom-tom", 14: "Cymbal", 15: "Hi-hat" };
+function T(t) {
+  const s = [t & 127];
+  for (t = Math.floor(t / 128); t > 0; t = Math.floor(t / 128)) s.unshift(t & 127 | 128);
+  return s;
+}
+function v(t, s) {
+  let f = t[s] ?? 0;
+  if (f & 128) {
+    f &= 127;
+    let l;
+    do
+      s++, l = t[s] ?? 0, f = f * 128 + (l & 127);
+    while (l & 128 && s < t.length);
+  }
+  return { value: f, next: s + 1 };
+}
+const N = (t) => t ? v(Uint8Array.from(t), 0).value : void 0;
+function R(t, s) {
+  return s.off ? s.off.tick : t.end.tick;
+}
+function _(t) {
+  if (!S(t)) throw new Error("Not a CMF file");
+  const s = new DataView(t.buffer, t.byteOffset, t.byteLength), f = (a) => a + 1 < t.length ? s.getUint16(a, !0) : 0, l = f(6), r = f(8), w = f(36), o = Math.max(40, Math.min(l, t.length)), E = new Uint8Array(o);
+  E.set(t.subarray(0, o));
+  const u = [];
+  for (let a = 0; a < Math.min(w, 128); a++) {
+    const p = new Uint8Array(16);
+    p.set(t.subarray(l + a * 16, l + a * 16 + 16)), u.push(p);
+  }
+  const g = l + w * 16, h = r > g ? t.slice(g, r) : new Uint8Array(0), i = t.subarray(r), c = {
+    header: E,
+    ticksPerBeat: f(10),
+    clockTicks: f(12),
+    channelUsed: t.slice(20, 36),
+    hadEvents: new Array(16).fill(!1),
+    instruments: u,
+    gap: h,
+    leadIn: 0,
+    notes: [],
+    events: [],
+    end: { tick: 0, bytes: [] },
+    counter: 0
+  };
+  if (i.length === 0) return c;
+  const y = [];
+  let n = 0;
+  const b = v(i, 0);
+  c.leadIn = b.value, c.leadInBytes = [...i.subarray(0, b.next)], n = b.next;
+  let d = 0, e = 8, x = 0, M, m = 0;
+  for (; ; ) {
+    const a = n;
+    if (n >= i.length) {
+      c.end = { tick: d, delta: M, bytes: [] };
+      break;
+    }
+    let p = !1, A;
+    const B = i[n];
+    ((B & 240) === 144 || (B & 240) === 128) && (x = B & 15, e = B >> 4, n++, p = !0, A = B);
+    const U = i[n];
+    let k;
+    if (n >= i.length) k = void 0;
+    else if (U < 128)
+      if (n + 1 >= i.length) k = void 0;
+      else {
+        const $ = i[n + 1];
+        k = e === 8 || $ === 0 ? { type: "off", tick: d, seq: m, ch: x, a: U, b: $, fn: e, status: p } : { type: "on", tick: d, seq: m, ch: x, a: U, b: $, status: p }, n += 2;
+      }
+    else {
+      const $ = U & 240, L = (I) => {
+        const D = [...i.subarray(n, n + I)];
+        return n += I, D;
+      };
+      if ($ === 176 && i[n + 1] === 103 && n + 2 < i.length)
+        k = { type: "mode", tick: d, seq: m, ch: U & 15, a: i[n + 2], b: 0 }, n += 3;
+      else if ($ === 192 && n + 1 < i.length)
+        k = { type: "program", tick: d, seq: m, ch: U & 15, a: i[n + 1], b: 0 }, n += 2;
+      else if (($ === 160 || $ === 176 || $ === 224) && n + 2 < i.length) k = { type: "raw", tick: d, seq: m, ch: U & 15, a: 0, b: 0, bytes: L(3) };
+      else if ($ === 208 && n + 1 < i.length) k = { type: "raw", tick: d, seq: m, ch: U & 15, a: 0, b: 0, bytes: L(2) };
+      else if ((U === 240 || U === 247) && n + 1 < i.length) {
+        const I = v(i, n + 1), D = I.next + I.value + 1;
+        D <= i.length && (k = { type: "raw", tick: d, seq: m, ch: 0, a: 0, b: 0, bytes: L(D - n) });
+      }
+      k && p && (k.prefix = A);
+    }
+    if (!k) {
+      c.end = { tick: d, delta: M, bytes: [...i.subarray(a)] };
+      break;
+    }
+    if (k.delta = M, y.push(k), m++, n >= i.length) {
+      c.end = { tick: d, bytes: [] };
+      break;
+    }
+    const H = v(i, n);
+    M = [...i.subarray(n, H.next)], d += H.value, n = H.next;
+  }
+  const q = /* @__PURE__ */ new Map();
+  for (const a of y)
+    if (c.hadEvents[a.ch] = !0, a.type === "on") {
+      const p = { on: a };
+      c.notes.push(p);
+      const A = a.ch * 128 + a.a, B = q.get(A);
+      B ? B.push(p) : q.set(A, [p]);
+    } else if (a.type === "off") {
+      const p = q.get(a.ch * 128 + a.a)?.shift();
+      p ? p.off = a : c.events.push(a);
+    } else c.events.push(a);
+  return c.counter = m, c;
+}
+function V(t) {
+  const s = [...t.events];
+  for (const f of t.notes)
+    s.push(f.on), f.off && (f.off.tick < f.on.tick && (f.off.tick = f.on.tick), f.off.tick === f.on.tick && f.off.seq < f.on.seq && (f.off.seq = f.on.seq + 0.5), s.push(f.off));
+  return s.sort((f, l) => f.tick - l.tick || f.seq - l.seq);
+}
+function F(t) {
+  const s = V(t);
+  s.length && s[0].tick > 0 && s.unshift({ type: "off", tick: 0, seq: -1 / 0, ch: 0, a: 0, b: 0, fn: 8 });
+  const f = s.length ? s[s.length - 1].tick : 0;
+  let l = Math.max(t.end.tick, f), r = t.leadIn;
+  l + r === 0 && (s.length || t.end.bytes.length) && (s.length ? l = 1 : r = 1);
+  const w = (e, x) => x && N(x) === e ? x : T(e), o = [], E = s.length || t.end.bytes.length || t.leadInBytes;
+  E && o.push(...w(r, t.leadInBytes));
+  let u = -1, g = -1, h = 0;
+  if (s.forEach((e, x) => {
+    if (x > 0 && o.push(...w(e.tick - h, e.delta)), h = e.tick, e.type === "on" || e.type === "off") {
+      let M, m = e.b;
+      e.type === "on" ? M = 9 : (M = e.fn ?? (u === 8 && g === e.ch ? 8 : 9), M === 9 && (m = 0));
+      const q = u >= 0, a = !q || u !== M || g !== e.ch;
+      (e.status === !0 || a && (q || e.status !== !1)) && o.push(M << 4 | e.ch), u = M, g = e.ch, o.push(e.a & 127, m & 255);
+      return;
+    }
+    e.prefix !== void 0 && (o.push(e.prefix), u = e.prefix >> 4, g = e.prefix & 15), e.type === "program" ? o.push(192 | e.ch, e.a & 255) : e.type === "mode" ? o.push(176 | e.ch, 103, e.a & 255) : o.push(...e.bytes ?? []);
+  }), E) {
+    const e = l - f;
+    s.length ? t.end.bytes.length === 0 && e === (N(t.end.delta) ?? 0) ? t.end.delta && o.push(...t.end.delta) : (o.push(...w(e, t.end.delta)), o.push(...t.end.bytes.length ? t.end.bytes : [255, 47, 0])) : o.push(...t.end.bytes.length ? t.end.bytes : [255, 47, 0]);
+  }
+  const i = t.header.length, c = t.instruments.slice(0, 128), y = i + c.length * 16 + t.gap.length, n = new Uint8Array(y + o.length);
+  n.set(t.header);
+  const b = new DataView(n.buffer);
+  b.setUint16(6, i, !0), b.setUint16(8, y, !0), b.setUint16(10, Math.max(1, Math.min(65535, Math.round(t.ticksPerBeat))), !0), b.setUint16(12, t.clockTicks, !0);
+  const d = new Array(16).fill(!1);
+  for (const e of s) d[e.ch] = !0;
+  for (let e = 0; e < 16; e++) n[20 + e] = d[e] === t.hadEvents[e] ? t.channelUsed[e] : d[e] ? 1 : 0;
+  return b.setUint16(36, c.length, !0), c.forEach((e, x) => n.set(e.subarray(0, 16), i + x * 16)), n.set(t.gap, i + c.length * 16), n.set(o, y), n;
+}
+function Y(t, s, f = !1) {
+  const l = [];
+  let r = 0, w = 0, o = 0, E = 8;
+  const u = (h) => t[h] ?? 255, g = () => {
+    const h = v(t, r);
+    return r = h.next, h.value;
+  };
+  if (!t.length) return l;
+  for (let h = 0; h < s; h++) {
+    r === 0 && (w = 1, g()), w--;
+    let i = 0;
+    for (; w <= 0; ) {
+      if (i++ > 1e5)
+        return l.push(`${h}:hang`), l;
+      const c = u(r);
+      ((c & 240) === 144 || (c & 240) === 128) && (o = c & 15, E = c >> 4, r++);
+      const y = u(r);
+      if (y < 128) {
+        const n = u(r + 1), b = E === 8 || n === 0;
+        l.push(`${h}:${b ? "off" : "on"} ${o} ${y}${f && !b ? `@${n}` : ""}`), r += 2;
+      } else {
+        const n = y & 240;
+        n === 160 || n === 224 ? r += 3 : n === 176 ? (u(r + 1) === 103 && l.push(`${h}:mode ${u(r + 2)}`), r += 3) : n === 192 ? (l.push(`${h}:program ${y & 15} ${u(r + 1)}`), r += 2) : n === 208 ? r += 2 : y === 240 || y === 247 ? (r++, r += g(), r++) : (l.push(`${h}:restart`), r = 0);
+      }
+      w = g();
+    }
+  }
+  return l;
+}
+function j(t) {
+  const s = new DataView(t.buffer, t.byteOffset, t.byteLength);
+  return t.subarray(s.getUint16(8, !0));
+}
+export {
+  P as DRUM_NAMES,
+  O as RHYTHM_CHANNELS,
+  j as musicOf,
+  R as noteEnd,
+  _ as readSong,
+  V as streamEvents,
+  Y as traceMusic,
+  F as writeSong
+};