@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/sceneSim.js

@@ -0,0 +1,112 @@
+import { moveChars as f } from "@lewismoten/gamemaker-sandbox-engine/engine/character";
+import { simKeyPress as u } from "@lewismoten/gamemaker-sandbox-engine/engine/keys";
+import { blockBirthMonsters as k, moveAllMonsters as p } from "@lewismoten/gamemaker-sandbox-engine/engine/monsters";
+import { updateCharDrawState as y } from "@lewismoten/gamemaker-sandbox-engine/engine/render";
+import { startSceneInits as g, changeBlocks as w } from "@lewismoten/gamemaker-sandbox-engine/engine/scene";
+import { initScroll as b, drawScroll as S, changeScroll as A } from "@lewismoten/gamemaker-sandbox-engine/engine/scroll";
+import { getTouchBlocks as x } from "@lewismoten/gamemaker-sandbox-engine/engine/touch";
+import { createWorld as M, padBlocks as a, BACKBL as B, CHARBL as _, newCharInfo as j, LASTMM as C } from "@lewismoten/gamemaker-sandbox-engine/engine/world";
+import { MONBL as O } from "@lewismoten/gamemaker-sandbox-engine/formats/blocks";
+function c(n) {
+  if (n === null || typeof n != "object") return n;
+  if (ArrayBuffer.isView(n)) return n.slice();
+  if (Array.isArray(n)) return n.map(c);
+  const t = {};
+  for (const s in n) t[s] = c(n[s]);
+  return t;
+}
+class P {
+  constructor(t, s, r = j(), e = 1, h = !0) {
+    this.scene = t, this.randA = e >>> 0;
+    const i = M(t.map, { play: (l) => (this.sounds.push(l), !0) }, () => this.rand());
+    i.bg = a(t.bbl, B), i.mblk = a(t.mbl, O), i.cblk = a(t.cbl, _), i.mon = t.mon ?? [], i.noMons = !t.mon, i.chr = structuredClone(t.chr), i.ci = r, i.clock = 1, this.w = i, g(i, s);
+    const o = h ? 255 : 0;
+    b(i, { up: o, down: o, left: o, right: o }), i.gclk = i.clock, i.joyOldTime = i.clock;
+  }
+  scene;
+  w;
+  held = /* @__PURE__ */ new Set();
+  doScroll = !1;
+  sounds = [];
+  /** Ticks played so far. */
+  ticks = 0;
+  /** Called with every key event (scan, bit 7 = released), e.g. to record a demo. */
+  onKey;
+  /** Link index reached (-1 = none yet). */
+  link = -1;
+  dead = !1;
+  /** kit/pixels.ts rng() (mulberry32), with its state out where a snapshot can keep it. */
+  randA;
+  rand() {
+    this.randA = this.randA + 1831565813 >>> 0;
+    let t = this.randA;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  /** Everything that changes as the scene plays, to try a move and take it back with restore(). */
+  snapshot() {
+    const { sound: t, rand: s, joystick: r, bg: e, mblk: h, cblk: i, mon: o, palette: l, chr: d, ...m } = this.w;
+    return {
+      w: c(m),
+      chr: { ...d, x: [...d.x], y: [...d.y] },
+      randA: this.randA,
+      held: [...this.held],
+      pending: [...this.pending],
+      doScroll: this.doScroll,
+      sounds: this.sounds.length,
+      ticks: this.ticks,
+      link: this.link,
+      dead: this.dead
+    };
+  }
+  restore(t) {
+    const { ci: s, ...r } = c(t.w);
+    Object.assign(this.w, r, { chr: { ...t.chr, x: [...t.chr.x], y: [...t.chr.y] } }), Object.assign(this.w.ci, s), this.randA = t.randA, this.held = new Set(t.held), this.pending = [...t.pending], this.doScroll = t.doScroll, this.sounds.length = t.sounds, this.ticks = t.ticks, this.link = t.link, this.dead = t.dead;
+  }
+  press(t) {
+    this.held.has(t) || (this.held.add(t), this.event(t));
+  }
+  release(t) {
+    this.held.has(t) && (this.held.delete(t), this.event(t | 128));
+  }
+  pending = [];
+  event(t) {
+    this.pending.push(t), this.onKey?.(t);
+  }
+  /** One 18.2 Hz game tick (8 scroll steps + tick()). */
+  async tick() {
+    const t = this.w;
+    this.ticks++;
+    for (let e = 0; e < 8; e++) this.doScroll && S(t);
+    t.clock++, t.noMons || (k(t), p(t));
+    const s = t.chr;
+    if (this.pending.length && (!s.sequences[s.cseq].ground || s.cframe === 0))
+      for (const e of this.pending.splice(0)) u(t, e);
+    let r = 0;
+    do
+      await f(t, async () => -1) && (this.dead = !0);
+    while (t.chr.cframe === -1 && !this.dead && r++ < 50);
+    if (w(t), y(t), this.doScroll = A(t) !== 0, t.monsolid = 0, t.mmSolid = C, this.scene.links) {
+      const e = x(t);
+      this.scene.links.forEach((h, i) => {
+        this.link < 0 && e.blks.some(([o, l]) => o === h.from.x && l === h.from.y) && (this.link = i);
+      });
+    }
+  }
+  async run(t, s) {
+    for (let r = 0; r < t && (await this.tick(), !(s?.(r) === !0 || this.dead || this.link >= 0)); r++)
+      ;
+  }
+  /** Live monsters called `name`, with their block positions. */
+  monsters(t) {
+    const s = this.scene.names?.indexOf(t) ?? -1;
+    return this.w.mm.flatMap((r, e) => r.monnum === s ? [{ x: this.w.mi[e].curx[0], y: this.w.mi[e].cury[0] }] : []);
+  }
+  /** Character position in pixels (x of its column, y of its bottom block). */
+  get pos() {
+    const t = this.w.chr;
+    return { x: t.x[0] * 20 + t.x[1], y: t.y[0] * 20 + t.y[1], bx: t.x[0], by: t.y[0] };
+  }
+}
+export {
+  P as Sim
+};

package/dist/kit/screenText.js

@@ -0,0 +1,15 @@
+const e = (r, o = 1) => {
+  for (const t of r) if (t.length > 30) throw new Error(`Text line over 30 columns: "${t}"`);
+  if (r.length > 16 * o) throw new Error(`Text over ${o} page(s): "${r[0]}"`);
+  for (; r.length % 16; ) r.push("");
+  return r.join(`
+`);
+}, n = (r, o) => {
+  const t = r.get(o);
+  if (!t) throw new Error(`No sprite ${o}`);
+  return t;
+};
+export {
+  e as page,
+  n as sprite
+};

package/dist/kit/sdftext.js

@@ -0,0 +1,237 @@
+function u(m, t, n, a, r, s, i = 14) {
+  const h = [];
+  for (let o = 0; o <= i; o++) {
+    const c = (r + (s - r) * o / i) * Math.PI / 180;
+    h.push([m + Math.cos(c) * n, t + Math.sin(c) * a]);
+  }
+  return h;
+}
+const G = (m, t) => [[m, 0.88], [m + t - 0.19, 0.88], ...u(m + t - 0.19, 0.69, 0.19, 0.19, 90, -90, 10), [m, 0.5]], S = (m, t) => [[m, 0.5], [m + t - 0.19, 0.5], ...u(m + t - 0.19, 0.31, 0.19, 0.19, 90, -90, 10), [m, 0.12]], X = {
+  S: [[...u(0.33, 0.69, 0.22, 0.19, 15, 270), ...u(0.33, 0.31, 0.22, 0.19, 90, -165)]],
+  A: [
+    [
+      [0.1, 0.12],
+      [0.36, 0.88],
+      [0.62, 0.12]
+    ],
+    [
+      [0.2, 0.38],
+      [0.52, 0.38]
+    ]
+  ],
+  N: [
+    [
+      [0.12, 0.12],
+      [0.12, 0.88],
+      [0.56, 0.12],
+      [0.56, 0.88]
+    ]
+  ],
+  D: [[[0.12, 0.12], [0.12, 0.88], [0.28, 0.88], ...u(0.28, 0.5, 0.3, 0.38, 90, -90), [0.12, 0.12]]],
+  B: [
+    [
+      [0.12, 0.12],
+      [0.12, 0.88]
+    ],
+    G(0.12, 0.44),
+    S(0.12, 0.48)
+  ],
+  O: [u(0.38, 0.5, 0.26, 0.38, 0, 360, 28)],
+  X: [
+    [
+      [0.12, 0.12],
+      [0.58, 0.88]
+    ],
+    [
+      [0.12, 0.88],
+      [0.58, 0.12]
+    ]
+  ],
+  F: [
+    [
+      [0.12, 0.12],
+      [0.12, 0.88],
+      [0.54, 0.88]
+    ],
+    [
+      [0.12, 0.52],
+      [0.44, 0.52]
+    ]
+  ],
+  T: [
+    [
+      [0.08, 0.88],
+      [0.58, 0.88]
+    ],
+    [
+      [0.33, 0.88],
+      [0.33, 0.12]
+    ]
+  ],
+  W: [
+    [
+      [0.08, 0.88],
+      [0.24, 0.12],
+      [0.41, 0.62],
+      [0.58, 0.12],
+      [0.74, 0.88]
+    ]
+  ],
+  R: [
+    [
+      [0.12, 0.12],
+      [0.12, 0.88]
+    ],
+    G(0.12, 0.46),
+    [
+      [0.3, 0.5],
+      [0.56, 0.12]
+    ]
+  ],
+  "-": [
+    [
+      [0.12, 0.5],
+      [0.5, 0.5]
+    ]
+  ],
+  "=": [
+    [
+      [0.12, 0.33],
+      [0.56, 0.33]
+    ],
+    [
+      [0.12, 0.67],
+      [0.56, 0.67]
+    ]
+  ],
+  G: [[...u(0.38, 0.5, 0.26, 0.38, 40, 360, 26), [0.4, 0.5]]],
+  M: [
+    [
+      [0.12, 0.12],
+      [0.12, 0.88],
+      [0.4, 0.4],
+      [0.68, 0.88],
+      [0.68, 0.12]
+    ]
+  ],
+  K: [
+    [
+      [0.12, 0.12],
+      [0.12, 0.88]
+    ],
+    [
+      [0.56, 0.88],
+      [0.14, 0.44]
+    ],
+    [
+      [0.3, 0.56],
+      [0.58, 0.12]
+    ]
+  ],
+  E: [
+    [
+      [0.54, 0.88],
+      [0.12, 0.88],
+      [0.12, 0.12],
+      [0.54, 0.12]
+    ],
+    [
+      [0.12, 0.5],
+      [0.44, 0.5]
+    ]
+  ]
+};
+function A(m, t, n, a = 0.1) {
+  const r = 0.12 * t, s = [];
+  let i = 0;
+  for (const o of m) {
+    const c = X[o];
+    if (!c) {
+      i += 0.5 * t;
+      continue;
+    }
+    const e = c.flat().map((f) => f[0]), x = Math.min(...e), M = Math.max(...e);
+    for (const f of c)
+      for (let l = 1; l < f.length; l++) {
+        const [B, T] = [f[l - 1], f[l]];
+        s.push([i + (B[0] - x + 0.12) * t, n + B[1] * t, i + (T[0] - x + 0.12) * t, n + T[1] * t, r]);
+      }
+    i += (M - x + 2 * 0.12 + a) * t;
+  }
+  const h = (i - a * t) / 2;
+  return s.map(([o, c, e, x, M]) => [o - h, c, e - h, x, M]);
+}
+class D {
+  constructor(t, n = 8e-3, a = 0.25) {
+    this.cell = n, this.cap = a;
+    const r = a + 0.05;
+    this.x0 = Math.min(...t.map((s) => Math.min(s[0], s[2]) - s[4])) - r, this.x1 = Math.max(...t.map((s) => Math.max(s[0], s[2]) + s[4])) + r, this.y0 = Math.min(...t.map((s) => Math.min(s[1], s[3]) - s[4])) - r, this.y1 = Math.max(...t.map((s) => Math.max(s[1], s[3]) + s[4])) + r, this.nx = Math.ceil((this.x1 - this.x0) / n) + 1, this.ny = Math.ceil((this.y1 - this.y0) / n) + 1, this.d = new Float32Array(this.nx * this.ny).fill(a);
+    for (const [s, i, h, o, c] of t) {
+      const e = c + a, x = Math.max(0, Math.floor((Math.min(s, h) - e - this.x0) / n)), M = Math.min(this.nx - 1, Math.ceil((Math.max(s, h) + e - this.x0) / n)), f = Math.max(0, Math.floor((Math.min(i, o) - e - this.y0) / n)), l = Math.min(this.ny - 1, Math.ceil((Math.max(i, o) + e - this.y0) / n)), B = h - s, T = o - i, d = B * B + T * T || 1e-9;
+      for (let y = f; y <= l; y++)
+        for (let p = x; p <= M; p++) {
+          const b = this.x0 + p * n - s, v = this.y0 + y * n - i, j = Math.max(0, Math.min(1, (b * B + v * T) / d)), w = Math.hypot(b - B * j, v - T * j) - c, k = y * this.nx + p;
+          w < this.d[k] && (this.d[k] = w);
+        }
+    }
+  }
+  cell;
+  cap;
+  x0;
+  y0;
+  x1;
+  y1;
+  nx;
+  ny;
+  d;
+  /** The distance at (x, y), bilinear between cells; outside the grid, a safe lower bound. */
+  at(t, n) {
+    const a = (t - this.x0) / this.cell, r = (n - this.y0) / this.cell;
+    if (a < 0 || r < 0 || a >= this.nx - 1 || r >= this.ny - 1) {
+      const x = Math.max(this.x0 - t, 0, t - this.x1), M = Math.max(this.y0 - n, 0, n - this.y1);
+      return Math.hypot(x, M) + this.cap * 0.5;
+    }
+    const s = a | 0, i = r | 0, h = a - s, o = r - i, c = i * this.nx + s, e = this.d;
+    return (e[c] * (1 - h) + e[c + 1] * h) * (1 - o) + (e[c + this.nx] * (1 - h) + e[c + this.nx + 1] * h) * o;
+  }
+}
+class E {
+  constructor(t, n, a) {
+    this.grid = t, this.bevel = a, this.half = n / 2;
+  }
+  grid;
+  bevel;
+  half;
+  sdf(t, n, a) {
+    const r = this.bevel, s = this.grid.at(t, n) + r, i = Math.abs(a) - this.half + r, h = Math.max(s, 0), o = Math.max(i, 0);
+    return Math.min(Math.max(s, i), 0) + Math.sqrt(h * h + o * o) - r;
+  }
+  /** Where a ray (object space, unit direction) first meets the letters, or -1. */
+  trace(t, n, a, r, s, i) {
+    const h = this.grid;
+    let o = 0, c = 1e9;
+    const e = (f, l, B, T) => {
+      if (Math.abs(l) < 1e-12) return f >= B && f <= T;
+      let d = (B - f) / l, y = (T - f) / l;
+      return d > y && ([d, y] = [y, d]), o = Math.max(o, d), c = Math.min(c, y), o <= c;
+    }, x = h.cap * 0.5;
+    if (!e(t, r, h.x0 + x, h.x1 - x) || !e(n, s, h.y0 + x, h.y1 - x) || !e(a, i, -this.half - 0.01, this.half + 0.01)) return -1;
+    let M = o;
+    for (let f = 0; f < 96 && M <= c; f++) {
+      const l = this.sdf(t + r * M, n + s * M, a + i * M);
+      if (l < 15e-4) return M;
+      M += l;
+    }
+    return -1;
+  }
+  /** The surface normal at a point (object space), from the field's gradient. */
+  normal(t, n, a) {
+    const s = this.sdf(t + 4e-3, n - 4e-3, a - 4e-3), i = this.sdf(t - 4e-3, n - 4e-3, a + 4e-3), h = this.sdf(t - 4e-3, n + 4e-3, a - 4e-3), o = this.sdf(t + 4e-3, n + 4e-3, a + 4e-3), c = s - i - h + o, e = -s - i + h + o, x = -s + i - h + o, M = Math.hypot(c, e, x) || 1;
+    return [c / M, e / M, x / M];
+  }
+}
+export {
+  D as DistanceGrid,
+  E as ExtrudedText,
+  A as textStrokes
+};

package/dist/kit/shading.js

@@ -0,0 +1,69 @@
+import { dither as d, rng as v } from "./pixels.js";
+function g(o, n, r, h, a, t) {
+  const e = n + Math.max(0, Math.min(1, h)) * (r - n), f = Math.floor(e), M = d(a, t, e - f) ? f + 1 : f;
+  return o[Math.max(0, Math.min(o.length - 1, M))];
+}
+const k = [0, 4, 6, 2, 7, 3, 5, 1];
+function z(o, n, r, h, a, t, e, f, M = !1) {
+  for (let l = r; l < r + a; l++) {
+    const i = (l - r) / Math.max(1, a - 1);
+    if (M) {
+      const c = e + Math.max(0, Math.min(1, i)) * (f - e), u = Math.floor(c), m = (c - u) * 8 > k[l & 7] ? u + 1 : u;
+      o.rect(n, l, h, 1, t[Math.max(0, Math.min(t.length - 1, m))]);
+    } else for (let c = n; c < n + h; c++) o.set(c, l, g(t, e, f, i, c, l));
+  }
+  return o;
+}
+function S(o, n, r, h, a, t, e = 0, f = t.length - 1, M = 1) {
+  for (let l = Math.floor(r - a); l <= r + a; l++)
+    for (let i = Math.floor(n - h); i <= n + h; i++) {
+      const c = (i + 0.5 - n) / h, u = (l + 0.5 - r) / a, m = c * c + u * u;
+      if (m > 1) continue;
+      const b = (0.62 * Math.sqrt(1 - m) - 0.42 * c - 0.52 * u) * M;
+      o.set(i, l, g(t, e, f, (b + 0.35) / 1.2, i, l));
+    }
+  return o;
+}
+function q(o, n, r, h, a, t, e, f = 1, M = [1, 1, -2, -2]) {
+  o.rect(n, r, h, a, t[e]);
+  const l = (s) => t[s >= 0 ? Math.min(t.length - 1, e + s) : Math.max(0, e + s)], [i, c, u, m] = M.map(l);
+  for (let s = 0; s < f; s++)
+    o.rect(n + s, r + s, h - 2 * s, 1, i).rect(n + s, r + s, 1, a - 2 * s, c), o.rect(n + s, r + a - 1 - s, h - 2 * s, 1, u).rect(n + h - 1 - s, r + s, 1, a - 2 * s, m);
+  return o;
+}
+function A(o, n, r, h, a, t, e, f, M, l = 0.25) {
+  const i = v(M);
+  for (let c = r; c < r + a; c++)
+    for (let u = n; u < n + h; u++) {
+      let m = e;
+      i() < l && (m += i() < 0.5 ? -f : f), o.set(u, c, t[Math.max(0, Math.min(t.length - 1, m))]);
+    }
+  return o;
+}
+function E(o, n, r, h) {
+  const a = /* @__PURE__ */ new Map();
+  for (const t of n) t.forEach((e, f) => a.set(e, t[Math.max(0, Math.min(t.length - 1, f + r))]));
+  for (let t = 0; t < o.h; t++)
+    for (let e = 0; e < o.w; e++) {
+      const f = a.get(o.get(e, t));
+      f !== void 0 && d(e, t, h(e, t)) && o.set(e, t, f);
+    }
+  return o;
+}
+function O(o, n, r, h, a, t, e, f) {
+  for (let M = Math.floor(r - a); M <= r + a; M++)
+    for (let l = Math.floor(n - h); l <= n + h; l++) {
+      const i = Math.hypot((l - n) / h, (M - r) / a);
+      i > 1 || o.set(l, M, g(t, e, f, 1 - i, l, M));
+    }
+  return o;
+}
+export {
+  q as bevel,
+  S as blob,
+  z as gradient,
+  O as pool,
+  E as rampShift,
+  g as shadeAt,
+  A as speckle
+};

package/dist/kit/song.js

@@ -0,0 +1,251 @@
+import { encodeCmf as p } from "@lewismoten/gamemaker-sandbox-engine/formats/cmf";
+import { sbi as i, INSTRUMENTS as M, midi as R } from "../music/compose.js";
+const H = i({ modChar: 98, carChar: 97, modLevel: 29, carLevel: 0, modAD: 100, carAD: 117, modSR: 22, carSR: 23, feedback: 12 }), W = i({
+  modChar: 49,
+  carChar: 34,
+  modLevel: 30,
+  carLevel: 0,
+  modAD: 114,
+  carAD: 115,
+  modSR: 6,
+  carSR: 7,
+  modWave: 1,
+  feedback: 10
+}), q = i({ modChar: 34, carChar: 33, modLevel: 74, carLevel: 5, modAD: 240, carAD: 240, modSR: 15, carSR: 15, feedback: 1 }), _ = i({ modChar: 97, carChar: 97, modLevel: 36, carLevel: 0, modAD: 84, carAD: 117, modSR: 6, carSR: 6, feedback: 14 }), K = i({
+  modChar: 3,
+  carChar: 1,
+  modLevel: 22,
+  carLevel: 0,
+  modAD: 246,
+  carAD: 244,
+  modSR: 68,
+  carSR: 69,
+  modWave: 2,
+  feedback: 12
+}), j = i({
+  modChar: 5,
+  carChar: 1,
+  modLevel: 28,
+  carLevel: 0,
+  modAD: 246,
+  carAD: 244,
+  modSR: 52,
+  carSR: 37,
+  feedback: 6
+}), y = i({ modChar: 1, carChar: 1, modLevel: 85, carLevel: 5, modAD: 242, carAD: 211, modSR: 99, carSR: 116, feedback: 8 }), w = i({ modChar: 1, carChar: 1, modLevel: 22, carLevel: 0, modAD: 244, carAD: 244, modSR: 38, carSR: 54, feedback: 10 }), g = i({ modChar: 1, carChar: 1, modLevel: 14, carLevel: 0, modAD: 248, carAD: 247, modSR: 119, carSR: 87, feedback: 8 }), O = i({ modChar: 2, carChar: 0, modLevel: 2, carLevel: 0, modAD: 247, carAD: 0, modSR: 7, carSR: 0, feedback: 0 }), $ = i({ modChar: 2, carChar: 0, modLevel: 4, carLevel: 0, modAD: 247, carAD: 0, modSR: 55, carSR: 0, feedback: 0 }), T = i({ modChar: 1, carChar: 0, modLevel: 8, carLevel: 0, modAD: 244, carAD: 0, modSR: 4, carSR: 0, feedback: 0 }), V = i({ modChar: 1, carChar: 0, modLevel: 6, carLevel: 0, modAD: 249, carAD: 0, modSR: 9, carSR: 0, feedback: 0 }), Y = (c, t, e = c.tune.length) => ({ chords: c.chords.slice(t, e), tune: c.tune.slice(t, e) }), z = (c, t) => ({ chords: c.chords, tune: [...c.tune.slice(0, -1), t] }), J = (c, t = "r w") => ({ chords: c, tune: c.map(() => t) }), L = { w: 4, h: 2, q: 1, e: 0.5, s: 0.25 }, E = (c) => c.split(",").map((t) => t.trim()).filter(Boolean);
+function S(c) {
+  return E(c).map((t) => {
+    const e = /^(\S+)\s+([whqes])(\.?)$/.exec(t);
+    if (!e) throw new Error(`Bad note "${t}"`);
+    return [R(e[1]), L[e[2]] * (e[3] ? 1.5 : 1)];
+  });
+}
+const B = {
+  C: 0,
+  "C#": 1,
+  Db: 1,
+  D: 2,
+  "D#": 3,
+  Eb: 3,
+  E: 4,
+  F: 5,
+  "F#": 6,
+  Gb: 6,
+  G: 7,
+  "G#": 8,
+  Ab: 8,
+  A: 9,
+  "A#": 10,
+  Bb: 10,
+  B: 11
+};
+function D(c) {
+  const t = /^([A-G][#b]?)(m?)(7?)$/.exec(c);
+  if (!t) throw new Error(`Unknown chord ${c}`);
+  const e = t[2] ? 3 : 4;
+  return { pc: B[t[1]], iv: t[3] ? [0, e, 10] : [0, e, 7] };
+}
+const N = {
+  voicing: (c) => {
+    const { pc: t, iv: e } = D(c);
+    return e.map((o) => 55 + (t + o - 55 + 120) % 12).sort((o, r) => o - r);
+  },
+  root: (c) => 40 + (D(c).pc - 40 + 120) % 12
+};
+function Q(c, t) {
+  return {
+    voicing: (e) => {
+      if (!c[e]) throw new Error(`No voicing for ${e}`);
+      return c[e].map((o) => R(o));
+    },
+    root: (e) => t[e]
+  };
+}
+const P = { k: 11, s: 12, t: 13, c: 14, h: 15 }, G = { k: 36, s: 55, t: 48, c: 72, h: 55 }, I = {
+  rock: { k: "x...x.x.", s: "..X...X.", h: "xxxxxxxx" },
+  rock4: { k: "x...x.x.", s: "..X...X.", h: "x.x.x.x." },
+  rockFill: { k: "x...x...", s: "..X..xXX", t: "......xx", h: "xxxxx..." },
+  crash: { k: "x...x.x.", s: "..X...X.", c: "X.......", h: ".xxxxxxx" },
+  half: { k: "x.......", s: "....X...", h: "x.x.x.x." },
+  soft: { k: "x.......", h: "..x...x." },
+  shuffle: { k: "x..x..x.", s: "..X...X.", h: "x.xxx.xx" },
+  camel: { k: "x.....x.", t: "..x.x..x", s: "....X...", h: "x.x.x.x." },
+  ride: { k: "x...x...", s: "....x...", c: "x.x.x.x." },
+  gospel: { k: "x..x..x.", s: "..X...X.", h: "xxxxxxxx", t: "........" },
+  // a clap-along gospel two-step (snare on 2 and 4 with a ghost before 4), sixteenth hats
+  clap: { k: "x.......x.x.....", s: "....X.......X...", h: "x.x.x.x.x.x.x.x." },
+  clapFill: { k: "x.......x.......", s: "....X.....x.XxXX", t: "..............xx", h: "x.x.x.x.x.x....." },
+  // a hop: the kick bounces ahead of the beat
+  hop: { k: "x..x...xx..x....", s: "....X.......X...", h: "x.xxx.x.x.xxx.x." },
+  march: { k: "x...x...", s: "..x...x.", t: "x.....xx", h: "x.x.x.x." },
+  none: {}
+};
+class Z {
+  constructor(t, e = N) {
+    this.chords = e, this.tpb = Math.round(8760 / t), this.events.push({ tick: 0, data: [176, 103, 1] }), this.instruments[11] = g, this.instruments[12] = O, this.instruments[13] = $, this.instruments[14] = T, this.instruments[15] = V;
+  }
+  chords;
+  tpb;
+  events = [];
+  instruments = [];
+  bar = 0;
+  current = [];
+  tick(t) {
+    return Math.round(t * this.tpb);
+  }
+  /** A note from beat `at` lasting `len` beats; it lets go a little early so the next one retriggers. */
+  note(t, e, o, r, s, a = 0.9) {
+    const h = this.tick(e), n = Math.max(h + 1, Math.min(this.tick(e + o) - 1, h + Math.round(o * this.tpb * a)));
+    this.events.push({ tick: h, data: [144 | t, r, s] }), this.events.push({ tick: n, data: [128 | t, r, 0] });
+  }
+  /** Plays a note string from beat `at`; returns its length in beats. */
+  line(t, e, o, r, s = 0, a = 0.9) {
+    let h = e;
+    for (const [n, d] of S(o))
+      n !== null && this.note(t, h, d, n + s, r, a), h += d;
+    return h - e;
+  }
+  drums(t, e, o) {
+    for (const r of Object.keys(e)) {
+      const s = e[r], a = 4 / s.length;
+      [...s].forEach((h, n) => {
+        if (h === ".") return;
+        const d = Math.min(127, Math.round(o * (h === "X" ? 1.15 : r === "h" && n % 2 ? 0.8 : 1)));
+        this.note(P[r], t + n * a, Math.min(a, 0.5), G[r], d, 0.6);
+      });
+    }
+  }
+  /** The bass for `beats` beats from `at` under one chord. */
+  bassLine(t, e, o, r) {
+    const s = this.chords.root(e) + (t.shift ?? 0), a = s + 7, h = {
+      whole: [[s, 4]],
+      half: [
+        [s, 2],
+        [a, 2]
+      ],
+      pump: [
+        [s, 1],
+        [a, 1],
+        [s, 1],
+        [a, 1]
+      ],
+      walk: [
+        [s, 1],
+        [s + (e.endsWith("m") ? 3 : 4), 1],
+        [a, 1],
+        [s + 12, 1]
+      ],
+      eighths: [
+        [s, 0.5],
+        [s, 0.5],
+        [s + 12, 0.5],
+        [s, 0.5],
+        [a, 0.5],
+        [s, 0.5],
+        [s + 12, 0.5],
+        [a, 0.5]
+      ]
+    };
+    let n = o;
+    for (const [d, u] of h[t.bass]) {
+      if (n >= o + r - 1e-6) break;
+      this.note(2, n, Math.min(u, o + r - n), d, t.bassVel ?? 105, 0.85), n += u;
+    }
+  }
+  /** Writes a section's bars: tune, second voice, bass, three comping voices and drums. */
+  part(t) {
+    const e = t.section;
+    return this.patches(t), e.tune.forEach((o, r) => {
+      const s = (this.bar + r) * 4, a = S(o).reduce((x, [, m]) => x + m, 0);
+      if (Math.abs(a - 4) > 1e-6) throw new Error(`Bar ${r + 1} of a section has ${a} beats: ${o}`);
+      const h = t.shift ?? 0;
+      if (!t.noTune) {
+        const x = t.up ?? 0;
+        this.line(0, s, o, t.leadVel ?? 112, h + x), t.second === "double" && this.line(1, s, o, t.secondVel ?? 70, h + x - 12), t.second === "octave" && this.line(1, s, o, t.secondVel ?? 60, h + x + 12);
+      }
+      const n = e.chords[r].split(" "), d = 4 / n.length, u = (x) => n[Math.min(n.length - 1, Math.floor((x - s) / d + 1e-6))];
+      n.forEach((x, m) => this.bassLine(t, x, s + m * d, d));
+      let l = s;
+      for (const x of E(t.comp)) {
+        const m = /^([xr])\s+([whqes])(\.?)$/.exec(x);
+        if (!m) throw new Error(`Bad comp "${x}"`);
+        const k = L[m[2]] * (m[3] ? 1.5 : 1);
+        if (m[1] === "x" && n.length === 1) this.chords.voicing(n[0]).forEach((v, f) => this.note(3 + f, l, k, v + h, t.compVel ?? 70, 0.85));
+        else if (m[1] === "x") {
+          const v = u(l), f = Math.min(l + k, s + (n.indexOf(v) + 1) * d);
+          if (this.chords.voicing(v).forEach((A, b) => this.note(3 + b, l, f - l, A + h, t.compVel ?? 70, 0.85)), f < l + k) {
+            const A = u(f);
+            this.chords.voicing(A).forEach((b, X) => this.note(3 + X, f, l + k - f, b + h, t.compVel ?? 70, 0.85));
+          }
+        }
+        l += k;
+      }
+      const C = I[t.drums[Math.min(r, t.drums.length - 1)]];
+      if (!C) throw new Error(`No groove ${t.drums[Math.min(r, t.drums.length - 1)]}`);
+      this.drums(s, C, t.drumVel ?? 100);
+    }), this.bar += e.tune.length, this;
+  }
+  /** Puts each melodic channel's patch in place for a part: the first part's are the file's instruments 0-5; later changes add an instrument and a program change. */
+  patches(t) {
+    const e = [
+      [0, t.lead],
+      [1, t.secondPatch ?? t.lead],
+      [2, t.bassPatch ?? w],
+      [3, t.compPatch],
+      [4, t.compPatch],
+      [5, t.compPatch]
+    ];
+    for (const [o, r] of e)
+      if (this.current[o] !== r) {
+        if (this.current[o] === void 0) this.instruments[o] = r;
+        else {
+          let s = this.instruments.indexOf(r, 16);
+          s < 0 && (s = Math.max(16, this.instruments.length), this.instruments[s] = r), this.events.push({ tick: this.tick(this.bar * 4), data: [192 | o, s] });
+        }
+        this.current[o] = r;
+      }
+  }
+  /** The .CMF: ends exactly on the bar line, so PLAYGAME's restart keeps time. */
+  cmf() {
+    const t = this.tick(this.bar * 4);
+    for (let e = 0; e < 6; e++) this.current[e] !== this.instruments[e] && this.events.push({ tick: t, data: [192 | e, e] });
+    this.events.push({ tick: t, data: [176, 103, 1] });
+    for (let e = 0; e < 16; e++) this.instruments[e] ??= M.piano;
+    return p({ instruments: this.instruments, events: this.events, ticksPerBeat: this.tpb });
+  }
+}
+export {
+  w as BASS,
+  j as CELESTA,
+  y as EPIANO,
+  _ as FLUTE,
+  q as ORGAN,
+  K as OUD,
+  W as REED,
+  H as VOICE,
+  Z as Writer,
+  Q as chordTable,
+  z as ending,
+  Y as slice,
+  J as vamp
+};