@lewismoten/gamemaker-sandbox-engine 0.0.0-stage → 3.1.0

package/README.md

@@ -1,3 +1,66 @@
-# Temporary Holding Version
+# Game-Maker: Sandbox Edition browser engine
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@lewismoten/gamemaker-sandbox-engine` runs RSD Game-Maker games from their original DOS files in a browser. It is the same TypeScript engine used by the Game-Maker: Sandbox Edition web player. The package includes its audio worklet and TypeScript declarations; it does not include games or the site's editor and catalog.
+
+Build a tarball from this repository with `cd web/packages/engine && npm pack`. The package has not been published to the npm registry. Install the tarball with `npm install ./lewismoten-gamemaker-sandbox-engine-3.1.0.tgz`.
+
+Pass the files from one game's DOS directory to `GameFiles`. Names are case insensitive and use DOS 8.3 names. `GameFiles.mainGame()` finds a `.GAM` file. Keep the original file names and bytes; the game refers to its other files by name.
+
+```ts
+import { GameFiles, Machine, runGame } from '@lewismoten/gamemaker-sandbox-engine';
+
+const input = document.querySelector<HTMLInputElement>('#files')!;
+const canvas = document.querySelector<HTMLCanvasElement>('#screen')!;
+const play = document.querySelector<HTMLButtonElement>('#play')!;
+let files: GameFiles | undefined;
+
+input.addEventListener('change', async () => {
+  const entries = await Promise.all(
+    Array.from(input.files ?? [], async (file): Promise<[string, Uint8Array]> => [
+      file.name,
+      new Uint8Array(await file.arrayBuffer()),
+    ]),
+  );
+  files = new GameFiles(entries);
+  play.disabled = !files.mainGame();
+});
+
+play.addEventListener('click', async () => {
+  if (!files) return;
+  const gam = files.mainGame();
+  if (!gam) throw new Error('Choose a game directory containing a .GAM file');
+
+  const machine = new Machine(canvas, files);
+  try {
+    await machine.audio.resume(); // the click is a user gesture
+    await runGame(machine, gam);
+  } finally {
+    machine.destroy();
+  }
+});
+```
+
+```html
+<input id="files" type="file" webkitdirectory multiple aria-label="Game directory" />
+<button id="play" disabled>Play</button>
+<canvas id="screen" tabindex="0" aria-label="Game screen"></canvas>
+<style>
+  #screen { width: min(100%, 960px); aspect-ratio: 8 / 5; image-rendering: pixelated; }
+</style>
+```
+
+`Machine` owns the screen, keyboard and audio. Call `machine.destroy()` when play finishes or the containing page closes. `runGame` accepts `RunOptions` for callbacks, joystick input, playback and the optional DOS player appearance. The game may write saves or high scores into `GameFiles`; use `files.onChange` to persist those bytes. The package targets modern browsers and ES modules.
+
+The source is MIT licensed; see `LICENSE` and `NOTICE.md` for credits.
+
+## Publishing
+
+The [release workflow](../../../.github/workflows/publish-engine.yml) publishes this package to
+GitHub Packages when an `engine-v<version>` tag is pushed. The tagged commit must be on
+`master`, and `<version>` must exactly match this package's `package.json` (for example,
+`engine-v3.1.0`). Merge the package changes to `master` before pushing the tag.
+
+The workflow uses GitHub's `GITHUB_TOKEN` with package write permission. It checks the source,
+builds the package, and publishes it to GitHub Packages. No package is published by ordinary
+branch pushes. Publishing to npm is a separate, manual decision; this workflow does not use
+an npm token.

package/dist/assets/music.worklet-NqOeNo6T.js

@@ -0,0 +1,464 @@
+const g = [0.5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 12, 12, 15, 15], M = [0, 9, 12, 13.875, 15, 16.125, 16.875, 17.625, 18, 18.75, 19.125, 19.5, 19.875, 20.25, 20.625, 21], v = [0, 0.5, 0.25, 1], O = 49716, l = 96, D = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, 21];
+class b {
+  am = !1;
+  vib = !1;
+  sustainHold = !1;
+  ksr = !1;
+  mult = 1;
+  ksl = 0;
+  tl = 0;
+  ar = 0;
+  dr = 0;
+  sl = 0;
+  rr = 0;
+  wave = 0;
+  // Runtime state. envDb is the envelope attenuation (0 = full, SILENT_DB = off);
+  // out/prevOut keep the last two modulator outputs for feedback.
+  phase = 0;
+  // cycles
+  stage = 0;
+  envDb = l;
+  out = 0;
+  prevOut = 0;
+  keyOn() {
+    this.stage = 1, this.phase = 0;
+  }
+  keyOff() {
+    this.stage !== 0 && (this.stage = 4);
+  }
+  /** Rate in "rate units" (0..63) including key scale rate offset. */
+  rate(t, s) {
+    return t === 0 ? 0 : Math.min(63, t * 4 + (this.ksr ? s : s >> 2));
+  }
+  stepEnvelope(t, s) {
+    switch (this.stage) {
+      case 1: {
+        const e = this.rate(this.ar, s);
+        if (e === 0) return;
+        if (e >= 60)
+          this.envDb = 0;
+        else {
+          const h = 2.826 / Math.pow(2, (e - 4) / 4);
+          this.envDb -= (this.envDb + 8) * (t / h) * 3.2;
+        }
+        this.envDb <= 0 && (this.envDb = 0, this.stage = 2);
+        return;
+      }
+      case 2: {
+        const e = this.sl === 15 ? 93 : this.sl * 3;
+        this.envDb += this.decayDbPerSecond(this.dr, s) * t, this.envDb >= e && (this.envDb = e, this.stage = 3);
+        return;
+      }
+      // EG-TYP set (sustainHold) holds the level until key off; otherwise the
+      // percussive envelope keeps falling at the release rate.
+      case 3:
+        this.sustainHold || (this.envDb += this.decayDbPerSecond(this.rr, s) * t);
+        break;
+      case 4:
+        this.envDb += this.decayDbPerSecond(this.rr, s) * t;
+        break;
+      default:
+        return;
+    }
+    this.envDb >= l && (this.envDb = l, this.stage = 0);
+  }
+  decayDbPerSecond(t, s) {
+    const e = this.rate(t, s);
+    return e === 0 ? 0 : l / (39.28 / Math.pow(2, (e - 4) / 4));
+  }
+  /** Waveform value at phase (cycles): 0 sine, 1 half sine, 2 absolute sine, 3 pulse (quarter) sine. */
+  wave01(t) {
+    const s = t - Math.floor(t), e = Math.sin(s * 2 * Math.PI);
+    switch (this.wave) {
+      case 1:
+        return s < 0.5 ? e : 0;
+      case 2:
+        return Math.abs(e);
+      case 3:
+        return s < 0.25 || s >= 0.5 && s < 0.75 ? Math.abs(e) : 0;
+      default:
+        return e;
+    }
+  }
+}
+class S {
+  fnum = 0;
+  block = 0;
+  key = !1;
+  feedback = 0;
+  additive = !1;
+  ops = [new b(), new b()];
+  /** Hz = F-number * clock / 2^(20 - block); block is the octave. */
+  get freq() {
+    return this.fnum * O / Math.pow(2, 20 - this.block);
+  }
+  /** Key scale rate offset: block * 2 + bit 9 (or 8) of the F-number. */
+  rof(t) {
+    return this.block * 2 + (this.fnum >> (t ? 8 : 9) & 1);
+  }
+  /** KSL attenuation: table value minus 6 dB per octave below block 7, scaled by the KSL setting. */
+  kslDb(t) {
+    return t.ksl ? Math.max(0, M[this.fnum >> 6] - 6 * (7 - this.block)) * v[t.ksl] : 0;
+  }
+}
+class P {
+  sampleRate;
+  channels = Array.from({ length: 9 }, () => new S());
+  regs = new Uint8Array(256);
+  waveSelect = !1;
+  noteSel = !1;
+  amDepth = !1;
+  vibDepth = !1;
+  rhythm = !1;
+  time = 0;
+  noise = 1;
+  constructor(t) {
+    this.sampleRate = t;
+  }
+  reset() {
+    for (let t = 0; t < 256; t++) this.write(t, 0);
+    for (const t of this.channels)
+      for (const s of t.ops)
+        s.stage = 0, s.envDb = l;
+  }
+  read(t) {
+    return this.regs[t & 255];
+  }
+  write(t, s) {
+    if (t &= 255, s &= 255, this.regs[t] = s, t === 1) {
+      this.waveSelect = (s & 32) !== 0;
+      return;
+    }
+    if (t === 8) {
+      this.noteSel = (s & 64) !== 0;
+      return;
+    }
+    if (t === 189) {
+      this.writeRhythm(s);
+      return;
+    }
+    const e = t & 224;
+    if (e >= 32 && e <= 128 || e === 224) {
+      const o = D.indexOf(t & 31);
+      if (o < 0) return;
+      const r = this.channels[Math.floor(o / 6) * 3 + o % 3].ops[Math.floor(o % 6 / 3)];
+      switch (e) {
+        case 32:
+          r.am = (s & 128) !== 0, r.vib = (s & 64) !== 0, r.sustainHold = (s & 32) !== 0, r.ksr = (s & 16) !== 0, r.mult = g[s & 15];
+          break;
+        case 64:
+          r.ksl = s >> 6, r.tl = s & 63;
+          break;
+        case 96:
+          r.ar = s >> 4, r.dr = s & 15;
+          break;
+        case 128:
+          r.sl = s >> 4, r.rr = s & 15;
+          break;
+        case 224:
+          r.wave = this.waveSelect ? s & 3 : 0;
+          break;
+      }
+      return;
+    }
+    const h = t & 15;
+    if (h > 8) return;
+    const i = this.channels[h];
+    if (e === 160 && t < 176)
+      i.fnum = i.fnum & 768 | s;
+    else if (t >= 176 && t <= 184) {
+      i.fnum = i.fnum & 255 | (s & 3) << 8, i.block = s >> 2 & 7;
+      const o = (s & 32) !== 0;
+      if (o && !i.key) for (const a of i.ops) a.keyOn();
+      if (!o && i.key) for (const a of i.ops) a.keyOff();
+      i.key = o;
+    } else t >= 192 && t <= 200 && (i.feedback = s >> 1 & 7, i.additive = (s & 1) !== 0);
+  }
+  rhythmKeys = 0;
+  /**
+   * Register 0xBD: bit 7 tremolo depth, bit 6 vibrato depth, bit 5 rhythm mode, bits 0-4 the
+   * drum keys. In rhythm mode channels 6-8 become the bass drum (both operators of channel 6),
+   * hi-hat and snare (channel 7) and tom-tom and cymbal (channel 8).
+   */
+  writeRhythm(t) {
+    this.amDepth = (t & 128) !== 0, this.vibDepth = (t & 64) !== 0, this.rhythm = (t & 32) !== 0;
+    const s = this.rhythm ? t & 31 : 0, e = s ^ this.rhythmKeys, [h, i, o] = [this.channels[6], this.channels[7], this.channels[8]], a = (r, n) => {
+      if (e & r)
+        for (const f of n) s & r ? f.keyOn() : f.keyOff();
+    };
+    a(16, h.ops), a(8, [i.ops[1]]), a(4, [o.ops[0]]), a(2, [o.ops[1]]), a(1, [i.ops[0]]), this.rhythmKeys = s;
+  }
+  /** Renders mono samples into out (added to existing content). */
+  render(t, s = 0.12) {
+    const e = 1 / this.sampleRate;
+    for (let h = 0; h < t.length; h++) {
+      this.time += e;
+      const i = (1 - Math.cos(this.time * 3.7 * 2 * Math.PI)) / 2 * (this.amDepth ? 4.8 : 1), o = Math.sin(this.time * 6.1 * 2 * Math.PI) * (this.vibDepth ? 14 : 7), a = Math.pow(2, o / 1200);
+      this.noise = this.noise >> 1 | ((this.noise >> 0 ^ this.noise >> 14) & 1) << 22;
+      const r = this.noise & 1 ? 1 : -1;
+      let n = 0;
+      const f = this.rhythm ? 6 : 9;
+      for (let c = 0; c < f; c++) n += this.channelSample(this.channels[c], e, i, a);
+      this.rhythm && (n += this.rhythmSample(e, i, a, r)), t[h] += n * s;
+    }
+  }
+  /** Linear amplitude from the summed attenuation: envelope + TL (0.75 dB steps) + KSL + tremolo. */
+  opLevel(t, s, e) {
+    const h = s.envDb + s.tl * 0.75 + t.kslDb(s) + (s.am ? e : 0);
+    return h >= l ? 0 : Math.pow(10, -h / 20);
+  }
+  advance(t, s, e, h) {
+    s.phase += t.freq * s.mult * (s.vib ? h : 1) * e, s.phase > 1e6 && (s.phase -= Math.floor(s.phase)), s.stepEnvelope(e, t.rof(this.noteSel));
+  }
+  channelSample(t, s, e, h) {
+    const [i, o] = t.ops;
+    if (i.stage === 0 && o.stage === 0) return 0;
+    this.advance(t, i, s, h), this.advance(t, o, s, h);
+    const a = t.feedback ? (i.out + i.prevOut) * Math.pow(2, t.feedback - 7) : 0, r = i.wave01(i.phase + a) * this.opLevel(t, i, e);
+    i.prevOut = i.out, i.out = r;
+    const n = this.opLevel(t, o, e);
+    return t.additive ? r + o.wave01(o.phase) * n : o.wave01(o.phase + r * 4) * n;
+  }
+  /**
+   * Approximates the five drums. The bass drum is a normal FM channel (at double level); the
+   * hi-hat, snare and cymbal mix operator tone with LFSR noise, and the tom-tom is a plain tone.
+   * The mixing weights are this port's approximation, not the chip's exact phase logic.
+   */
+  rhythmSample(t, s, e, h) {
+    const [i, o, a] = [this.channels[6], this.channels[7], this.channels[8]];
+    let r = this.channelSample(i, t, s, e) * 2;
+    const [n, f] = o.ops, [c, p] = a.ops;
+    for (const [w, k] of [
+      [o, n],
+      [o, f],
+      [a, c],
+      [a, p]
+    ])
+      this.advance(w, k, t, e);
+    return n.stage !== 0 && (r += h * 0.5 * this.opLevel(o, n, s) * (n.wave01(n.phase) > 0 ? 1 : 0.6) * 2), f.stage !== 0 && (r += (f.wave01(f.phase) * 0.6 + h * 0.4) * this.opLevel(o, f, s) * 2), c.stage !== 0 && (r += c.wave01(c.phase) * this.opLevel(a, c, s) * 2), p.stage !== 0 && (r += (p.wave01(p.phase) > 0 ? 0.5 : -0.5) * (h > 0 ? 1 : 0.7) * this.opLevel(a, p, s) * 2), r;
+  }
+}
+const y = [0, 1, 2, 8, 9, 10, 16, 17, 18], T = 1193180 / Math.floor(65535 / 8), u = { 11: 16, 12: 8, 13: 4, 14: 2, 15: 1 }, d = {
+  11: { ch: 6, ops: ["mod", "car"] },
+  12: { ch: 7, ops: ["car"] },
+  13: { ch: 8, ops: ["mod"] },
+  14: { ch: 8, ops: ["car"] },
+  15: { ch: 7, ops: ["mod"] }
+};
+class K {
+  opl;
+  music = new Uint8Array(0);
+  instruments = [];
+  // PlayIt's statics: read position in the music block, ticks left before the next
+  // event, and the running status (channel and 8 = note off / 9 = note on).
+  offset = 0;
+  wait = 0;
+  channel = 0;
+  funct = 8;
+  rhythm = !1;
+  rhythmKeys = 0;
+  // Note sounding on each MIDI channel (-1 none), so a note off only releases its own note.
+  notes = new Int16Array(16).fill(-1);
+  programs = new Uint8Array(16);
+  playing = !1;
+  constructor(t) {
+    this.opl = t, this.init();
+  }
+  /** sbfd_init: enable waveform select, melody mode (0xBD = deep tremolo and vibrato, rhythm off). */
+  init() {
+    this.opl.reset(), this.opl.write(1, 32), this.opl.write(8, 0), this.opl.write(189, 192);
+  }
+  load(t, s) {
+    this.stop(), this.init(), this.music = t, this.instruments = s, this.rhythm = !1, this.rhythmKeys = 0;
+    for (let e = 0; e < 16; e++) this.programChange(e, e);
+    this.offset = 0, this.playing = t.length > 0;
+  }
+  /** sbfd_music_off + rewind. */
+  stop() {
+    this.allNotesOff(), this.offset = 0, this.playing = !1;
+  }
+  allNotesOff() {
+    for (let t = 0; t < 9; t++) this.opl.write(176 + t, this.opl.read(176 + t) & -33);
+    this.rhythmKeys = 0, this.opl.write(189, 192 | (this.rhythm ? 32 : 0)), this.notes.fill(-1);
+  }
+  /**
+   * *(APOS) in SBMUSIC.C. PlayIt read sbmusic+offset with no bounds check, so past the end of
+   * the farmalloc'd music block it read whatever heap memory followed. Every CMF ends with the
+   * FF 2F 00 end marker, which restarts the song before the read gets there; only a truncated
+   * file runs off the end, and for that the port reads 0xFF, which takes the same path as the
+   * end marker (sbfd_music_off, offset = 0).
+   */
+  byte(t) {
+    return this.music[t] ?? 255;
+  }
+  /**
+   * getpaws() in SBMUSIC.C: reads a MIDI variable length number (7 bits per byte, high bit
+   * set on every byte but the last), with no limit on the number of bytes:
+   *   do { offset++; value = (value << 7) | ((c=*(APOS)) & 0x07F); } while (c & 0x80);
+   * value is an unsigned long, so bits shifted past 32 are lost (>>> 0). The one difference:
+   * the loop stops at the end of the data, where DOS read on into unknown memory.
+   */
+  getPaws() {
+    let t = this.byte(this.offset);
+    if (t & 128) {
+      t &= 127;
+      let s;
+      do
+        this.offset++, s = this.byte(this.offset), t = (t << 7 | s & 127) >>> 0;
+      while (s & 128 && this.offset < this.music.length);
+    }
+    return this.offset++, t;
+  }
+  /** One timer tick of PlayIt(). */
+  tick() {
+    if (!this.playing) return;
+    this.offset === 0 && (this.wait = 1, this.getPaws()), this.wait--;
+    let t = 0;
+    for (; this.wait <= 0 && t++ < 1e5; ) {
+      const s = this.byte(this.offset);
+      switch (s & 240) {
+        case 144:
+          this.channel = s & 15, this.offset++, this.funct = 9;
+          break;
+        case 128:
+          this.channel = s & 15, this.offset++, this.funct = 8;
+          break;
+      }
+      const e = this.byte(this.offset);
+      if (e < 128) {
+        const h = this.byte(this.offset + 1);
+        this.funct === 8 || h === 0 ? this.noteOff(this.channel, e) : this.noteOn(this.channel, e, h), this.offset += 2;
+      } else
+        switch (e & 240) {
+          case 160:
+            this.offset += 3;
+            break;
+          case 176:
+            this.byte(this.offset + 1) === 103 && this.setMode(this.byte(this.offset + 2)), this.offset += 3;
+            break;
+          case 192:
+            this.programChange(e & 15, this.byte(this.offset + 1)), this.offset += 2;
+            break;
+          case 208:
+            this.offset += 2;
+            break;
+          case 224:
+            this.offset += 3;
+            break;
+          case 240:
+            e === 247 || e === 240 ? (this.offset++, this.offset += this.getPaws(), this.offset++) : (this.allNotesOff(), this.offset = 0);
+            break;
+          default:
+            this.allNotesOff(), this.offset = 0;
+        }
+      this.wait = this.getPaws();
+    }
+  }
+  /** sbfd_setmode: switch melody/rhythm mode and reload the drum channels' instruments. */
+  setMode(t) {
+    if (this.allNotesOff(), this.rhythm = t !== 0, this.opl.write(189, 192 | (this.rhythm ? 32 : 0)), this.rhythm) for (const s of [11, 12, 13, 14, 15]) this.programChange(s, this.programs[s]);
+  }
+  programChange(t, s) {
+    this.programs[t] = s;
+    const e = this.instruments[s];
+    if (e) {
+      if (this.rhythm && d[t]) {
+        const h = d[t];
+        h.ops.length === 2 ? this.loadVoice(h.ch, e) : this.loadOperator(y[h.ch] + (h.ops[0] === "car" ? 3 : 0), e, 0);
+        return;
+      }
+      t < this.melodyVoices() && this.loadVoice(t, e);
+    }
+  }
+  melodyVoices() {
+    return this.rhythm ? 6 : 9;
+  }
+  /**
+   * Writes one operator from a 16 byte SBI instrument record, whose bytes alternate
+   * modulator/carrier: 0/1 AM-VIB-EG-KSR-MULT, 2/3 KSL-TL, 4/5 AR-DR, 6/7 SL-RR, 8/9 waveform.
+   */
+  loadOperator(t, s, e) {
+    this.opl.write(32 + t, s[0 + e]), this.opl.write(64 + t, s[2 + e]), this.opl.write(96 + t, s[4 + e]), this.opl.write(128 + t, s[6 + e]), this.opl.write(224 + t, s[8 + e]);
+  }
+  loadVoice(t, s) {
+    const e = y[t];
+    this.loadOperator(e, s, 0), this.loadOperator(e + 3, s, 1), this.opl.write(192 + t, s[10]);
+  }
+  /**
+   * MIDI note -> OPL frequency: picks the lowest block (octave) whose F-number fits in 10 bits,
+   * which keeps the most pitch resolution (Hz = fnum * 49716 / 2^(20 - block)).
+   */
+  setPitch(t, s, e) {
+    const h = 440 * Math.pow(2, (s - 69) / 12);
+    let i, o = 0;
+    for (i = 0; i < 8 && (o = Math.round(h * Math.pow(2, 20 - i) / 49716), !(o < 1024)); i++)
+      ;
+    i = Math.min(i, 7), o = Math.min(o, 1023), this.opl.write(160 + t, o & 255), this.opl.write(176 + t, (e ? 32 : 0) | i << 2 | o >> 8);
+  }
+  /**
+   * SBFMDRV's loudness by velocity: it scales the instrument's carrier level (TL is an
+   * attenuation, 0 loudest .. 63 silent) and keeps the key-scaling bits:
+   * TL = 63 - floor((velocity + 128) * (63 - instrumentTL) / 256). So velocity 127 plays
+   * the instrument almost as loud as written and velocity 1 about half as loud in TL steps.
+   */
+  applyVelocity(t, s) {
+    const e = this.instruments[this.programs[t]];
+    if (!e) return;
+    let h, i;
+    const o = this.rhythm ? d[t] : void 0;
+    if (o && o.ops.length === 1)
+      h = y[o.ch] + (o.ops[0] === "car" ? 3 : 0), i = e[2];
+    else {
+      const r = o ? o.ch : t;
+      if (!o && r >= this.melodyVoices()) return;
+      h = y[r] + 3, i = e[3];
+    }
+    const a = 63 - Math.floor((Math.min(127, s) + 128) * (63 - (i & 63)) / 256);
+    this.opl.write(64 + h, i & 192 | a);
+  }
+  noteOn(t, s, e = 127) {
+    if (this.applyVelocity(t, e), this.rhythm && u[t]) {
+      const h = u[t];
+      this.setPitch(d[t].ch, s, !1), this.rhythmKeys &= ~h, this.opl.write(189, 224 | this.rhythmKeys), this.rhythmKeys |= h, this.opl.write(189, 224 | this.rhythmKeys), this.notes[t] = s;
+      return;
+    }
+    t >= this.melodyVoices() || (this.notes[t] >= 0 && this.opl.write(176 + t, this.opl.read(176 + t) & -33), this.setPitch(t, s, !0), this.notes[t] = s);
+  }
+  noteOff(t, s) {
+    if (this.notes[t] === s) {
+      if (this.notes[t] = -1, this.rhythm && u[t]) {
+        this.rhythmKeys &= ~u[t], this.opl.write(189, 224 | this.rhythmKeys);
+        return;
+      }
+      t < this.melodyVoices() && this.opl.write(176 + t, this.opl.read(176 + t) & -33);
+    }
+  }
+}
+class L extends AudioWorkletProcessor {
+  opl = new P(sampleRate);
+  player = new K(this.opl);
+  untilTick = 0;
+  paused = !1;
+  ended = !1;
+  samplesPerTick = sampleRate / T;
+  constructor() {
+    super(), this.port.onmessage = (t) => {
+      const s = t.data;
+      s.type === "load" ? (this.player.load(s.music, s.instruments), this.untilTick = 0) : s.type === "stop" ? this.player.stop() : s.type === "pause" ? this.paused = s.paused : s.type === "end" && (this.ended = !0);
+    };
+  }
+  process(t, s) {
+    if (this.ended) return !1;
+    const e = s[0][0];
+    if (!e || this.paused) return !0;
+    let h = 0;
+    for (; h < e.length; ) {
+      this.untilTick <= 0 && (this.player.tick(), this.untilTick += this.samplesPerTick);
+      const i = Math.min(e.length - h, Math.ceil(this.untilTick));
+      this.opl.render(e.subarray(h, h + i)), this.untilTick -= i, h += i;
+    }
+    for (let i = 1; i < s[0].length; i++) s[0][i].set(e);
+    return !0;
+  }
+}
+registerProcessor("gm-music", L);