@songram/songram-daw-engine 3.1.0

package/dist/index.js

@@ -0,0 +1,4157 @@
+import Ht from "eventemitter3";
+import { Volume as W, Panner as st, Gain as ot, getDestination as J, getTransport as I, getContext as F, PolySynth as G, Synth as jt, MembraneSynth as $, NoiseSynth as Wt, MetalSynth as lt, Part as Bt, start as Jt, now as tt, Context as Kt, setContext as Xt } from "tone";
+import { SoundFont2 as ht, GeneratorType as T } from "soundfont2";
+const Je = 1e3;
+function et(a) {
+  const {
+    audioBuffer: t,
+    startSample: e,
+    offsetSamples: n = 0,
+    gain: i = 1,
+    name: r,
+    color: s,
+    fadeIn: c,
+    fadeOut: u,
+    waveformData: l,
+    midiNotes: o,
+    midiChannel: h,
+    midiProgram: f
+  } = a, d = t?.sampleRate ?? a.sampleRate ?? l?.sample_rate, g = t?.length ?? a.sourceDurationSamples ?? (l && d ? Math.ceil(l.duration * d) : void 0);
+  if (d === void 0)
+    throw new Error(
+      "createClip: sampleRate is required when audioBuffer is not provided (can use waveformData.sample_rate)"
+    );
+  if (g === void 0)
+    throw new Error(
+      "createClip: sourceDurationSamples is required when audioBuffer is not provided (can use waveformData.duration)"
+    );
+  t && l && t.sampleRate !== l.sample_rate && console.warn(
+    `Sample rate mismatch: audioBuffer (${t.sampleRate}) vs waveformData (${l.sample_rate}). Using audioBuffer sample rate. Waveform visualization may be slightly off.`
+  );
+  const b = a.durationSamples ?? g;
+  return {
+    id: Vt(),
+    audioBuffer: t,
+    startSample: e,
+    durationSamples: b,
+    offsetSamples: n,
+    sampleRate: d,
+    sourceDurationSamples: g,
+    gain: i,
+    name: r,
+    color: s,
+    fadeIn: c,
+    fadeOut: u,
+    waveformData: l,
+    midiNotes: o,
+    midiChannel: h,
+    midiProgram: f
+  };
+}
+function Ke(a) {
+  const {
+    audioBuffer: t,
+    startTime: e,
+    offset: n = 0,
+    gain: i = 1,
+    name: r,
+    color: s,
+    fadeIn: c,
+    fadeOut: u,
+    waveformData: l,
+    midiNotes: o,
+    midiChannel: h,
+    midiProgram: f
+  } = a, d = t?.sampleRate ?? a.sampleRate ?? l?.sample_rate;
+  if (d === void 0)
+    throw new Error(
+      "createClipFromSeconds: sampleRate is required when audioBuffer is not provided (can use waveformData.sample_rate)"
+    );
+  const g = t?.duration ?? a.sourceDuration ?? l?.duration;
+  if (g === void 0)
+    throw new Error(
+      "createClipFromSeconds: sourceDuration is required when audioBuffer is not provided (can use waveformData.duration)"
+    );
+  t && l && t.sampleRate !== l.sample_rate && console.warn(
+    `Sample rate mismatch: audioBuffer (${t.sampleRate}) vs waveformData (${l.sample_rate}). Using audioBuffer sample rate. Waveform visualization may be slightly off.`
+  );
+  const b = a.duration ?? g;
+  return et({
+    audioBuffer: t,
+    startSample: Math.round(e * d),
+    durationSamples: Math.round(b * d),
+    offsetSamples: Math.round(n * d),
+    sampleRate: d,
+    sourceDurationSamples: Math.ceil(g * d),
+    gain: i,
+    name: r,
+    color: s,
+    fadeIn: c,
+    fadeOut: u,
+    waveformData: l,
+    midiNotes: o,
+    midiChannel: h,
+    midiProgram: f
+  });
+}
+function Xe(a) {
+  const {
+    name: t,
+    clips: e = [],
+    muted: n = !1,
+    soloed: i = !1,
+    volume: r = 1,
+    pan: s = 0,
+    color: c,
+    height: u,
+    spectrogramConfig: l,
+    spectrogramColorMap: o
+  } = a;
+  return {
+    id: Vt(),
+    name: t,
+    clips: e,
+    muted: n,
+    soloed: i,
+    volume: r,
+    pan: s,
+    color: c,
+    height: u,
+    spectrogramConfig: l,
+    spectrogramColorMap: o
+  };
+}
+function Ze(a, t = 44100, e) {
+  const i = a.reduce((r, s) => {
+    const c = s.clips.reduce((u, l) => Math.max(u, l.startSample + l.durationSamples), 0);
+    return Math.max(r, c);
+  }, 0) / t;
+  return {
+    tracks: a,
+    duration: i,
+    sampleRate: t,
+    name: e?.name,
+    tempo: e?.tempo,
+    timeSignature: e?.timeSignature
+  };
+}
+function Vt() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function Qe(a, t, e) {
+  return a.clips.filter((n) => {
+    const i = n.startSample + n.durationSamples;
+    return n.startSample < e && i > t;
+  });
+}
+function Ye(a, t) {
+  return a.clips.filter((e) => {
+    const n = e.startSample + e.durationSamples;
+    return t >= e.startSample && t < n;
+  });
+}
+function tr(a, t) {
+  const e = a.startSample + a.durationSamples, n = t.startSample + t.durationSamples;
+  return a.startSample < n && e > t.startSample;
+}
+function rt(a) {
+  return [...a].sort((t, e) => t.startSample - e.startSample);
+}
+function er(a) {
+  if (a.clips.length === 0) return [];
+  const t = rt(a.clips), e = [];
+  for (let n = 0; n < t.length - 1; n++) {
+    const i = t[n].startSample + t[n].durationSamples, r = t[n + 1].startSample;
+    r > i && e.push({
+      startSample: i,
+      endSample: r,
+      durationSamples: r - i
+    });
+  }
+  return e;
+}
+var Zt = /* @__PURE__ */ ((a) => (a.Cursor = "cursor", a.Select = "select", a.Shift = "shift", a.FadeIn = "fadein", a.FadeOut = "fadeout", a))(Zt || {});
+function rr(a, t) {
+  return a / t;
+}
+function nr(a, t) {
+  return Math.ceil(a * t);
+}
+function ar(a, t) {
+  return Math.floor(a / t);
+}
+function ir(a, t) {
+  return Math.floor(a * t);
+}
+function sr(a, t, e) {
+  return a * t / e;
+}
+function or(a, t, e) {
+  return Math.ceil(a * e / t);
+}
+const R = 192;
+function Lt(a, t = R) {
+  const [, e] = a;
+  return t * (4 / e);
+}
+function Qt(a, t = R) {
+  const [e] = a;
+  return e * Lt(a, t);
+}
+function cr(a, t, e, n = R) {
+  return Math.round(a * 60 * e / (t * n));
+}
+function ur(a, t, e, n = R) {
+  return Math.round(a * n * t / (60 * e));
+}
+function lr(a, t) {
+  return Math.round(a / t) * t;
+}
+function hr(a, t, e = R) {
+  const n = Qt(t, e), i = Lt(t, e), r = Math.floor(a / n) + 1, s = Math.floor(a % n / i) + 1;
+  return s === 1 ? `${r}` : `${r}.${s}`;
+}
+const j = -100;
+function Yt(a, t = j) {
+  return Number.isNaN(a) ? (console.warn("[songram-daw] dBToNormalized received NaN"), 0) : t >= 0 ? (console.warn("[songram-daw] dBToNormalized floor must be negative, got:", t), 0) : !isFinite(a) || a <= t ? 0 : (a - t) / -t;
+}
+function dr(a, t = j) {
+  return isFinite(a) ? t >= 0 ? (console.warn("[songram-daw] normalizedToDb floor must be negative, got:", t), j) : Math.max(0, a) * -t + t : t;
+}
+function fr(a, t = j) {
+  if (a <= 0) return 0;
+  const e = 20 * Math.log10(a);
+  return Yt(e, t);
+}
+function q(a) {
+  return a.startSample / a.sampleRate;
+}
+function dt(a) {
+  return (a.startSample + a.durationSamples) / a.sampleRate;
+}
+function ft(a) {
+  return a.offsetSamples / a.sampleRate;
+}
+function mt(a) {
+  return a.durationSamples / a.sampleRate;
+}
+function mr(a, t, e) {
+  return Math.floor((a + t) / e) - Math.floor(a / e);
+}
+function te(a, t, e, n) {
+  let i = t;
+  const r = -a.startSample;
+  if (i = Math.max(i, r), n > 0) {
+    const s = e[n - 1], u = s.startSample + s.durationSamples - a.startSample;
+    i = Math.max(i, u);
+  }
+  if (n < e.length - 1) {
+    const c = e[n + 1].startSample - (a.startSample + a.durationSamples);
+    i = Math.min(i, c);
+  }
+  return i;
+}
+function ee(a, t, e, n, i, r) {
+  let s = t;
+  if (e === "left") {
+    if (s = Math.max(s, -a.startSample), s = Math.max(s, -a.offsetSamples), i > 0) {
+      const c = n[i - 1], u = c.startSample + c.durationSamples;
+      s = Math.max(s, u - a.startSample);
+    }
+    s = Math.min(s, a.durationSamples - r);
+  } else if (s = Math.max(s, r - a.durationSamples), s = Math.min(s, a.sourceDurationSamples - a.offsetSamples - a.durationSamples), i < n.length - 1) {
+    const c = n[i + 1];
+    s = Math.min(s, c.startSample - a.startSample - a.durationSamples);
+  }
+  return s;
+}
+function pr(a, t) {
+  return Math.floor(a / t) * t;
+}
+function re(a, t) {
+  const e = t - a.startSample, n = a.durationSamples - e, i = a.name ? `${a.name} (1)` : void 0, r = a.name ? `${a.name} (2)` : void 0, s = et({
+    startSample: a.startSample,
+    durationSamples: e,
+    offsetSamples: a.offsetSamples,
+    sampleRate: a.sampleRate,
+    sourceDurationSamples: a.sourceDurationSamples,
+    gain: a.gain,
+    name: i,
+    color: a.color,
+    fadeIn: a.fadeIn,
+    audioBuffer: a.audioBuffer,
+    waveformData: a.waveformData
+  }), c = et({
+    startSample: t,
+    durationSamples: n,
+    offsetSamples: a.offsetSamples + e,
+    sampleRate: a.sampleRate,
+    sourceDurationSamples: a.sourceDurationSamples,
+    gain: a.gain,
+    name: r,
+    color: a.color,
+    fadeOut: a.fadeOut,
+    audioBuffer: a.audioBuffer,
+    waveformData: a.waveformData
+  });
+  return { left: s, right: c };
+}
+function ne(a, t, e) {
+  const n = a.startSample + a.durationSamples;
+  if (t <= a.startSample || t >= n)
+    return !1;
+  const i = t - a.startSample, r = n - t;
+  return i >= e && r >= e;
+}
+function gr(a, t, e = 1.5) {
+  const n = t * e;
+  return {
+    visibleStart: Math.max(0, a - n),
+    visibleEnd: a + t + n
+  };
+}
+function yr(a, t, e, n) {
+  const i = Math.ceil(a / t), r = [];
+  for (let s = 0; s < i; s++) {
+    const c = s * t, u = Math.min(a - c, t);
+    c + u <= e || c >= n || r.push(s);
+  }
+  return r;
+}
+function vr(a, t, e = 100) {
+  return Math.abs(a - t) >= e;
+}
+function K(a) {
+  let t = 0;
+  for (const e of a)
+    for (const n of e.clips) {
+      const r = (n.startSample + n.durationSamples) / n.sampleRate;
+      t = Math.max(t, r);
+    }
+  return t;
+}
+function ae(a, t) {
+  if (t.length === 0) return 0;
+  let e = 0, n = Math.abs(t[0] - a);
+  for (let i = 1; i < t.length; i++) {
+    const r = Math.abs(t[i] - a);
+    r < n && (n = r, e = i);
+  }
+  return e;
+}
+function br(a, t, e, n, i, r = 0) {
+  const l = (e + n / 2 - r) * a / i * i / t + r - n / 2;
+  return Math.max(0, l);
+}
+function pt(a, t) {
+  return Math.max(0, Math.min(a, t));
+}
+const ie = 44100, se = 1024, oe = [256, 512, 1024, 2048, 4096, 8192], gt = 0.1;
+class ce {
+  constructor(t = {}) {
+    if (this._tracks = [], this._currentTime = 0, this._playStartPosition = 0, this._isPlaying = !1, this._selectedTrackId = null, this._selectionStart = 0, this._selectionEnd = 0, this._masterVolume = 1, this._loopStart = 0, this._loopEnd = 0, this._isLoopEnabled = !1, this._tracksVersion = 0, this._animFrameId = null, this._disposed = !1, this._listeners = /* @__PURE__ */ new Map(), this._sampleRate = t.sampleRate ?? ie, this._zoomLevels = [...t.zoomLevels ?? oe], this._adapter = t.adapter ?? null, this._zoomLevels.length === 0)
+      throw new Error("PlaylistEngine: zoomLevels must not be empty");
+    const e = t.samplesPerPixel ?? se, n = this._zoomLevels.indexOf(e);
+    if (n === -1)
+      throw new Error(
+        `PlaylistEngine: samplesPerPixel ${e} is not in zoomLevels [${this._zoomLevels.join(", ")}]. Either pass a samplesPerPixel value that exists in zoomLevels, or include ${e} in your zoomLevels array.`
+      );
+    this._zoomIndex = n;
+  }
+  // ---------------------------------------------------------------------------
+  // State snapshot
+  // ---------------------------------------------------------------------------
+  getState() {
+    return {
+      tracks: this._tracks.map((t) => ({ ...t, clips: [...t.clips] })),
+      tracksVersion: this._tracksVersion,
+      duration: K(this._tracks),
+      currentTime: this._currentTime,
+      isPlaying: this._isPlaying,
+      samplesPerPixel: this._zoomLevels[this._zoomIndex],
+      sampleRate: this._sampleRate,
+      selectedTrackId: this._selectedTrackId,
+      zoomIndex: this._zoomIndex,
+      canZoomIn: this._zoomIndex > 0,
+      canZoomOut: this._zoomIndex < this._zoomLevels.length - 1,
+      selectionStart: this._selectionStart,
+      selectionEnd: this._selectionEnd,
+      masterVolume: this._masterVolume,
+      loopStart: this._loopStart,
+      loopEnd: this._loopEnd,
+      isLoopEnabled: this._isLoopEnabled
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Track Management
+  // ---------------------------------------------------------------------------
+  setTracks(t) {
+    this._tracks = [...t], this._tracksVersion++, this._adapter?.setTracks(this._tracks), this._emitStateChange();
+  }
+  addTrack(t) {
+    this._tracks = [...this._tracks, t], this._tracksVersion++, this._adapter?.addTrack ? this._adapter.addTrack(t) : this._adapter?.setTracks(this._tracks), this._emitStateChange();
+  }
+  removeTrack(t) {
+    this._tracks.some((e) => e.id === t) && (this._tracks = this._tracks.filter((e) => e.id !== t), this._tracksVersion++, this._selectedTrackId === t && (this._selectedTrackId = null), this._adapter?.setTracks(this._tracks), this._emitStateChange());
+  }
+  selectTrack(t) {
+    t !== this._selectedTrackId && (this._selectedTrackId = t, this._emitStateChange());
+  }
+  // ---------------------------------------------------------------------------
+  // Clip Editing (delegates to operations/)
+  // ---------------------------------------------------------------------------
+  moveClip(t, e, n) {
+    const i = this._tracks.find((o) => o.id === t);
+    if (!i) {
+      console.warn(`[songram-daw/engine] moveClip: track "${t}" not found`);
+      return;
+    }
+    const r = i.clips.findIndex((o) => o.id === e);
+    if (r === -1) {
+      console.warn(
+        `[songram-daw/engine] moveClip: clip "${e}" not found in track "${t}"`
+      );
+      return;
+    }
+    const s = i.clips[r], c = rt(i.clips), u = c.findIndex((o) => o.id === e), l = te(s, n, c, u);
+    l !== 0 && (this._tracks = this._tracks.map((o) => {
+      if (o.id !== t) return o;
+      const h = o.clips.map(
+        (f, d) => d === r ? {
+          ...f,
+          startSample: Math.floor(f.startSample + l)
+        } : f
+      );
+      return { ...o, clips: h };
+    }), this._tracksVersion++, this._adapter?.setTracks(this._tracks), this._emitStateChange());
+  }
+  splitClip(t, e, n) {
+    const i = this._tracks.find((o) => o.id === t);
+    if (!i) {
+      console.warn(`[songram-daw/engine] splitClip: track "${t}" not found`);
+      return;
+    }
+    const r = i.clips.findIndex((o) => o.id === e);
+    if (r === -1) {
+      console.warn(
+        `[songram-daw/engine] splitClip: clip "${e}" not found in track "${t}"`
+      );
+      return;
+    }
+    const s = i.clips[r], c = Math.floor(gt * this._sampleRate);
+    if (!ne(s, n, c)) {
+      console.warn(
+        `[songram-daw/engine] splitClip: cannot split clip "${e}" at sample ${n} (clip range: ${s.startSample}–${s.startSample + s.durationSamples}, minDuration: ${c})`
+      );
+      return;
+    }
+    const { left: u, right: l } = re(s, n);
+    this._tracks = this._tracks.map((o) => {
+      if (o.id !== t) return o;
+      const h = [...o.clips];
+      return h.splice(r, 1, u, l), { ...o, clips: h };
+    }), this._tracksVersion++, this._adapter?.setTracks(this._tracks), this._emitStateChange();
+  }
+  trimClip(t, e, n, i) {
+    const r = this._tracks.find((f) => f.id === t);
+    if (!r) {
+      console.warn(`[songram-daw/engine] trimClip: track "${t}" not found`);
+      return;
+    }
+    const s = r.clips.findIndex((f) => f.id === e);
+    if (s === -1) {
+      console.warn(
+        `[songram-daw/engine] trimClip: clip "${e}" not found in track "${t}"`
+      );
+      return;
+    }
+    const c = r.clips[s], u = rt(r.clips), l = u.findIndex((f) => f.id === e), o = Math.floor(gt * this._sampleRate), h = ee(
+      c,
+      i,
+      n,
+      u,
+      l,
+      o
+    );
+    h !== 0 && (this._tracks = this._tracks.map((f) => {
+      if (f.id !== t) return f;
+      const d = f.clips.map((g, b) => b !== s ? g : n === "left" ? {
+        ...g,
+        startSample: g.startSample + h,
+        offsetSamples: g.offsetSamples + h,
+        durationSamples: g.durationSamples - h
+      } : { ...g, durationSamples: g.durationSamples + h });
+      return { ...f, clips: d };
+    }), this._tracksVersion++, this._adapter?.setTracks(this._tracks), this._emitStateChange());
+  }
+  // ---------------------------------------------------------------------------
+  // Playback (delegates to adapter, no-ops without adapter)
+  // ---------------------------------------------------------------------------
+  async init() {
+    this._adapter && await this._adapter.init();
+  }
+  play(t, e) {
+    const n = this._currentTime, i = this._playStartPosition;
+    if (t !== void 0) {
+      const r = K(this._tracks);
+      this._currentTime = pt(t, r);
+    }
+    if (this._playStartPosition = this._currentTime, this._adapter) {
+      if (e !== void 0)
+        this._adapter.setLoop(!1, this._loopStart, this._loopEnd);
+      else if (this._isLoopEnabled) {
+        const r = this._currentTime < this._loopEnd;
+        this._adapter.setLoop(r, this._loopStart, this._loopEnd);
+      }
+      try {
+        this._adapter.play(this._currentTime, e);
+      } catch (r) {
+        throw this._currentTime = n, this._playStartPosition = i, r;
+      }
+    }
+    this._isPlaying = !0, this._startTimeUpdateLoop(), this._emit("play"), this._emitStateChange();
+  }
+  pause() {
+    this._isPlaying = !1, this._stopTimeUpdateLoop(), this._adapter?.pause(), this._adapter && (this._currentTime = this._adapter.getCurrentTime()), this._emit("pause"), this._emitStateChange();
+  }
+  stop() {
+    this._isPlaying = !1, this._currentTime = this._playStartPosition, this._stopTimeUpdateLoop(), this._adapter?.setLoop(!1, this._loopStart, this._loopEnd), this._adapter?.stop(), this._emit("stop"), this._emitStateChange();
+  }
+  seek(t) {
+    const e = K(this._tracks);
+    this._currentTime = pt(t, e), this._adapter?.seek(this._currentTime), this._emitStateChange();
+  }
+  setMasterVolume(t) {
+    t !== this._masterVolume && (this._masterVolume = t, this._adapter?.setMasterVolume(t), this._emitStateChange());
+  }
+  getCurrentTime() {
+    return this._isPlaying && this._adapter ? this._adapter.getCurrentTime() : this._currentTime;
+  }
+  // ---------------------------------------------------------------------------
+  // Selection & Loop
+  // ---------------------------------------------------------------------------
+  setSelection(t, e) {
+    const n = Math.min(t, e), i = Math.max(t, e);
+    n === this._selectionStart && i === this._selectionEnd || (this._selectionStart = n, this._selectionEnd = i, this._emitStateChange());
+  }
+  setLoopRegion(t, e) {
+    const n = Math.min(t, e), i = Math.max(t, e);
+    n === this._loopStart && i === this._loopEnd || (this._loopStart = n, this._loopEnd = i, this._adapter?.setLoop(
+      this._isLoopEnabled && this._isBeforeLoopEnd(),
+      this._loopStart,
+      this._loopEnd
+    ), this._emitStateChange());
+  }
+  setLoopEnabled(t) {
+    t !== this._isLoopEnabled && (this._isLoopEnabled = t, this._adapter?.setLoop(t && this._isBeforeLoopEnd(), this._loopStart, this._loopEnd), this._emitStateChange());
+  }
+  // ---------------------------------------------------------------------------
+  // Per-Track Audio (delegates to adapter)
+  // ---------------------------------------------------------------------------
+  setTrackVolume(t, e) {
+    const n = this._tracks.find((i) => i.id === t);
+    n && (n.volume = e), this._adapter?.setTrackVolume(t, e);
+  }
+  setTrackMute(t, e) {
+    const n = this._tracks.find((i) => i.id === t);
+    n && (n.muted = e), this._adapter?.setTrackMute(t, e);
+  }
+  setTrackSolo(t, e) {
+    const n = this._tracks.find((i) => i.id === t);
+    n && (n.soloed = e), this._adapter?.setTrackSolo(t, e);
+  }
+  setTrackPan(t, e) {
+    const n = this._tracks.find((i) => i.id === t);
+    n && (n.pan = e), this._adapter?.setTrackPan(t, e);
+  }
+  // ---------------------------------------------------------------------------
+  // Zoom
+  // ---------------------------------------------------------------------------
+  zoomIn() {
+    this._zoomIndex > 0 && (this._zoomIndex--, this._emitStateChange());
+  }
+  zoomOut() {
+    this._zoomIndex < this._zoomLevels.length - 1 && (this._zoomIndex++, this._emitStateChange());
+  }
+  setZoomLevel(t) {
+    const e = ae(t, this._zoomLevels);
+    e !== this._zoomIndex && (this._zoomIndex = e, this._emitStateChange());
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  on(t, e) {
+    this._listeners.has(t) || this._listeners.set(t, /* @__PURE__ */ new Set()), this._listeners.get(t).add(e);
+  }
+  off(t, e) {
+    this._listeners.get(t)?.delete(e);
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  dispose() {
+    if (!this._disposed) {
+      this._disposed = !0, this._stopTimeUpdateLoop();
+      try {
+        this._adapter?.dispose();
+      } catch (t) {
+        console.warn("[songram-daw/engine] Error disposing adapter:", t);
+      }
+      this._listeners.clear();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  _emit(t, ...e) {
+    const n = this._listeners.get(t);
+    if (n)
+      for (const i of n)
+        try {
+          i(...e);
+        } catch (r) {
+          console.warn("[songram-daw/engine] Error in event listener:", r);
+        }
+  }
+  /**
+   * Returns whether the current playback position is before loopEnd.
+   * Used by setLoopEnabled/setLoopRegion during playback — if past loopEnd,
+   * Transport loop stays off so playback continues to the end.
+   * Note: play() uses an inline check instead — _isPlaying is still false
+   * when play() runs, and this method returns true unconditionally when
+   * not playing.
+   */
+  _isBeforeLoopEnd() {
+    return this._isPlaying ? (this._adapter?.getCurrentTime() ?? this._currentTime) < this._loopEnd : !0;
+  }
+  _emitStateChange() {
+    this._emit("statechange", this.getState());
+  }
+  _startTimeUpdateLoop() {
+    if (typeof requestAnimationFrame > "u") return;
+    this._stopTimeUpdateLoop();
+    const t = () => {
+      this._disposed || !this._isPlaying || (this._adapter && (this._currentTime = this._adapter.getCurrentTime(), this._emit("timeupdate", this._currentTime)), this._animFrameId = requestAnimationFrame(t));
+    };
+    this._animFrameId = requestAnimationFrame(t);
+  }
+  _stopTimeUpdateLoop() {
+    this._animFrameId !== null && typeof cancelAnimationFrame < "u" && (cancelAnimationFrame(this._animFrameId), this._animFrameId = null);
+  }
+}
+let yt = !1;
+function ct(a) {
+  const t = a._param;
+  return !t && !yt && (yt = !0, console.warn(
+    "[songram-daw] Unable to access Tone.js internal _param. This likely means the Tone.js version is incompatible. Mute scheduling may not work correctly."
+  )), t;
+}
+function vt(a, t) {
+  const e = new Float32Array(a), n = a - 1;
+  for (let i = 0; i < a; i++) {
+    const r = i / n;
+    e[i] = t ? r : 1 - r;
+  }
+  return e;
+}
+function ue(a, t) {
+  const e = new Float32Array(a), n = a - 1;
+  for (let i = 0; i < a; i++) {
+    const r = i / n, s = t ? i : a - 1 - i;
+    e[s] = Math.exp(2 * r - 1) / Math.E;
+  }
+  return e;
+}
+function le(a, t) {
+  const e = new Float32Array(a), n = t ? Math.PI / 2 : -Math.PI / 2;
+  for (let i = 0; i < a; i++)
+    e[i] = Math.sin(Math.PI * i / a - n) / 2 + 0.5;
+  return e;
+}
+function he(a, t, e = 10) {
+  const n = new Float32Array(a);
+  for (let i = 0; i < a; i++) {
+    const r = t ? i : a - 1 - i, s = i / a;
+    n[r] = Math.log(1 + e * s) / Math.log(1 + e);
+  }
+  return n;
+}
+function Rt(a, t, e) {
+  switch (a) {
+    case "linear":
+      return vt(t, e);
+    case "exponential":
+      return ue(t, e);
+    case "sCurve":
+      return le(t, e);
+    case "logarithmic":
+      return he(t, e);
+    default:
+      return vt(t, e);
+  }
+}
+function bt(a, t, e, n = "linear", i = 0, r = 1) {
+  if (!(e <= 0))
+    if (n === "linear")
+      a.setValueAtTime(i, t), a.linearRampToValueAtTime(r, t + e);
+    else if (n === "exponential")
+      a.setValueAtTime(Math.max(i, 1e-3), t), a.exponentialRampToValueAtTime(Math.max(r, 1e-3), t + e);
+    else {
+      const s = Rt(n, 1e4, !0), c = new Float32Array(s.length), u = r - i;
+      for (let l = 0; l < s.length; l++)
+        c[l] = i + s[l] * u;
+      a.setValueCurveAtTime(c, t, e);
+    }
+}
+function kt(a, t, e, n = "linear", i = 1, r = 0) {
+  if (!(e <= 0))
+    if (n === "linear")
+      a.setValueAtTime(i, t), a.linearRampToValueAtTime(r, t + e);
+    else if (n === "exponential")
+      a.setValueAtTime(Math.max(i, 1e-3), t), a.exponentialRampToValueAtTime(Math.max(r, 1e-3), t + e);
+    else {
+      const s = Rt(n, 1e4, !1), c = new Float32Array(s.length), u = i - r;
+      for (let l = 0; l < s.length; l++)
+        c[l] = r + s[l] * u;
+      a.setValueCurveAtTime(c, t, e);
+    }
+}
+class de {
+  constructor(t) {
+    this.activeSources = /* @__PURE__ */ new Set(), this._scheduleGuardOffset = 0, this.track = t.track, this.volumeNode = new W(this.gainToDb(t.track.gain)), this.panNode = new st({ pan: t.track.stereoPan, channelCount: 2 }), this.muteGain = new ot(t.track.muted ? 0 : 1), this.volumeNode.chain(this.panNode, this.muteGain);
+    const e = t.destination || J();
+    if (t.effects) {
+      const c = t.effects(this.muteGain, e, !1);
+      c && (this.effectsCleanup = c);
+    } else
+      this.muteGain.connect(e);
+    const n = t.clips || (t.buffer ? [
+      {
+        buffer: t.buffer,
+        startTime: 0,
+        duration: t.buffer.duration,
+        offset: 0,
+        fadeIn: t.track.fadeIn,
+        fadeOut: t.track.fadeOut,
+        gain: 1
+      }
+    ] : []), i = I(), r = F().rawContext, s = this.volumeNode.input.input;
+    this.scheduledClips = n.map((c) => {
+      const u = r.createGain();
+      u.gain.value = c.gain, u.connect(s);
+      const l = this.track.startTime + c.startTime, o = i.schedule((h) => {
+        l < this._scheduleGuardOffset || this.startClipSource(c, u, h);
+      }, l);
+      return { clipInfo: c, fadeGainNode: u, scheduleId: o };
+    });
+  }
+  /**
+   * Create and start an AudioBufferSourceNode for a clip.
+   * Sources are one-shot: each play or loop iteration creates a fresh one.
+   */
+  startClipSource(t, e, n, i, r) {
+    const c = F().rawContext.createBufferSource();
+    c.buffer = t.buffer, c.connect(e);
+    const u = i ?? t.offset, l = r ?? t.duration;
+    try {
+      c.start(n, u, l);
+    } catch (o) {
+      console.warn(
+        `[songram-daw] Failed to start source on track "${this.id}" (time=${n}, offset=${u}, duration=${l}):`,
+        o
+      ), c.disconnect();
+      return;
+    }
+    this.activeSources.add(c), c.onended = () => {
+      this.activeSources.delete(c);
+    };
+  }
+  /**
+   * Set the schedule guard offset. Schedule callbacks for clips before this
+   * offset are suppressed (already handled by startMidClipSources).
+   * Must be called before transport.start() and in the loop handler.
+   */
+  setScheduleGuardOffset(t) {
+    this._scheduleGuardOffset = t;
+  }
+  /**
+   * Start sources for clips that span the given Transport position.
+   * Used for mid-playback seeking and loop boundary handling where
+   * Transport.schedule() callbacks have already passed.
+   *
+   * Uses strict < for absClipStart to avoid double-creation with
+   * schedule callbacks at exact Transport position (e.g., loopStart).
+   */
+  startMidClipSources(t, e) {
+    for (const { clipInfo: n, fadeGainNode: i } of this.scheduledClips) {
+      const r = this.track.startTime + n.startTime, s = r + n.duration;
+      if (r < t && s > t) {
+        const c = t - r, u = n.offset + c, l = n.duration - c;
+        this.startClipSource(
+          n,
+          i,
+          e,
+          u,
+          l
+        );
+      }
+    }
+  }
+  /**
+   * Stop all active AudioBufferSourceNodes and clear the set.
+   * Native AudioBufferSourceNodes ignore Transport state changes —
+   * they must be explicitly stopped.
+   */
+  stopAllSources() {
+    this.activeSources.forEach((t) => {
+      try {
+        t.stop();
+      } catch (e) {
+        console.warn(`[songram-daw] Error stopping source on track "${this.id}":`, e);
+      }
+    }), this.activeSources.clear();
+  }
+  /**
+   * Schedule fade envelopes for a clip at the given AudioContext time.
+   * Uses native GainNode.gain (AudioParam) directly — no _param workaround needed.
+   */
+  scheduleFades(t, e, n = 0) {
+    const { clipInfo: i, fadeGainNode: r } = t, s = r.gain;
+    s.cancelScheduledValues(0);
+    const c = n - i.offset;
+    if (i.fadeIn && c < i.fadeIn.duration) {
+      const u = i.fadeIn.duration;
+      if (c <= 0)
+        bt(
+          s,
+          e,
+          u,
+          i.fadeIn.type || "linear",
+          0,
+          i.gain
+        );
+      else {
+        const l = u - c, o = c / u, h = i.gain * o;
+        bt(
+          s,
+          e,
+          l,
+          i.fadeIn.type || "linear",
+          h,
+          i.gain
+        );
+      }
+    } else
+      s.setValueAtTime(i.gain, e);
+    if (i.fadeOut) {
+      const l = i.duration - i.fadeOut.duration - c;
+      if (l > 0) {
+        const o = e + l;
+        kt(
+          s,
+          o,
+          i.fadeOut.duration,
+          i.fadeOut.type || "linear",
+          i.gain,
+          0
+        );
+      } else if (l > -i.fadeOut.duration) {
+        const o = -l, h = i.fadeOut.duration - o, f = o / i.fadeOut.duration, d = i.gain * (1 - f);
+        kt(
+          s,
+          e,
+          h,
+          i.fadeOut.type || "linear",
+          d,
+          0
+        );
+      }
+    }
+  }
+  /**
+   * Prepare fade envelopes for all clips based on Transport offset.
+   * Called before Transport.start() to schedule fades at correct AudioContext times.
+   */
+  prepareFades(t, e) {
+    this.scheduledClips.forEach((n) => {
+      const i = this.track.startTime + n.clipInfo.startTime, r = i + n.clipInfo.duration;
+      if (!(e >= r))
+        if (e >= i) {
+          const s = e - i + n.clipInfo.offset;
+          this.scheduleFades(n, t, s);
+        } else {
+          const s = i - e;
+          this.scheduleFades(n, t + s, n.clipInfo.offset);
+        }
+    });
+  }
+  /**
+   * Cancel all scheduled fade automation and reset to nominal gain.
+   * Called on pause/stop to prevent stale fade envelopes.
+   */
+  cancelFades() {
+    this.scheduledClips.forEach(({ fadeGainNode: t, clipInfo: e }) => {
+      const n = t.gain;
+      n.cancelScheduledValues(0), n.setValueAtTime(e.gain, 0);
+    });
+  }
+  gainToDb(t) {
+    return 20 * Math.log10(t);
+  }
+  setVolume(t) {
+    this.track.gain = t, this.volumeNode.volume.value = this.gainToDb(t);
+  }
+  setPan(t) {
+    this.track.stereoPan = t, this.panNode.pan.value = t;
+  }
+  setMute(t) {
+    this.track.muted = t;
+    const e = t ? 0 : 1;
+    ct(this.muteGain.gain)?.setValueAtTime(e, 0), this.muteGain.gain.value = e;
+  }
+  setSolo(t) {
+    this.track.soloed = t;
+  }
+  dispose() {
+    const t = I();
+    if (this.effectsCleanup)
+      try {
+        this.effectsCleanup();
+      } catch (e) {
+        console.warn(`[songram-daw] Error during track "${this.id}" effects cleanup:`, e);
+      }
+    this.stopAllSources(), this.scheduledClips.forEach((e, n) => {
+      try {
+        t.clear(e.scheduleId);
+      } catch (i) {
+        console.warn(
+          `[songram-daw] Error clearing schedule ${n} on track "${this.id}":`,
+          i
+        );
+      }
+      try {
+        e.fadeGainNode.disconnect();
+      } catch (i) {
+        console.warn(
+          `[songram-daw] Error disconnecting fadeGain ${n} on track "${this.id}":`,
+          i
+        );
+      }
+    });
+    try {
+      this.volumeNode.dispose();
+    } catch (e) {
+      console.warn(`[songram-daw] Error disposing volumeNode on track "${this.id}":`, e);
+    }
+    try {
+      this.panNode.dispose();
+    } catch (e) {
+      console.warn(`[songram-daw] Error disposing panNode on track "${this.id}":`, e);
+    }
+    try {
+      this.muteGain.dispose();
+    } catch (e) {
+      console.warn(`[songram-daw] Error disposing muteGain on track "${this.id}":`, e);
+    }
+  }
+  get id() {
+    return this.track.id;
+  }
+  get duration() {
+    if (this.scheduledClips.length === 0) return 0;
+    const t = this.scheduledClips[this.scheduledClips.length - 1];
+    return t.clipInfo.startTime + t.clipInfo.duration;
+  }
+  get buffer() {
+    return this.scheduledClips[0]?.clipInfo.buffer;
+  }
+  get muted() {
+    return this.track.muted;
+  }
+  get startTime() {
+    return this.track.startTime;
+  }
+}
+function fe(a) {
+  return a === 35 || a === 36 ? "kick" : a >= 37 && a <= 40 ? "snare" : a === 41 || a === 43 || a === 45 || a === 47 || a === 48 || a === 50 ? "tom" : "cymbal";
+}
+class me {
+  constructor(t) {
+    this.track = t.track, this.volumeNode = new W(this.gainToDb(t.track.gain)), this.panNode = new st(t.track.stereoPan), this.muteGain = new ot(t.track.muted ? 0 : 1), this.volumeNode.chain(this.panNode, this.muteGain), this.synth = new G(jt, t.synthOptions), this.synth.connect(this.volumeNode), this.kickSynth = new G($, {
+      voice: $,
+      options: {
+        pitchDecay: 0.05,
+        octaves: 6,
+        envelope: { attack: 1e-3, decay: 0.4, sustain: 0, release: 0.1 }
+      }
+    }), this.snareSynth = new Wt({
+      noise: { type: "white" },
+      envelope: { attack: 1e-3, decay: 0.15, sustain: 0, release: 0.05 }
+    }), this.cymbalSynth = new G(lt, {
+      voice: lt,
+      options: {
+        envelope: { attack: 1e-3, decay: 0.3, release: 0.1 },
+        harmonicity: 5.1,
+        modulationIndex: 32,
+        resonance: 4e3,
+        octaves: 1.5
+      }
+    }), this.tomSynth = new G($, {
+      voice: $,
+      options: {
+        pitchDecay: 0.08,
+        octaves: 4,
+        envelope: { attack: 1e-3, decay: 0.3, sustain: 0, release: 0.1 }
+      }
+    }), this.kickSynth.connect(this.volumeNode), this.snareSynth.connect(this.volumeNode), this.cymbalSynth.connect(this.volumeNode), this.tomSynth.connect(this.volumeNode);
+    const e = t.destination || J();
+    if (t.effects) {
+      const n = t.effects(this.muteGain, e, !1);
+      n && (this.effectsCleanup = n);
+    } else
+      this.muteGain.connect(e);
+    this.scheduledClips = t.clips.map((n) => {
+      const i = n.notes.filter((u) => {
+        const l = u.time + u.duration;
+        return u.time < n.offset + n.duration && l > n.offset;
+      }), r = this.track.startTime + n.startTime, s = i.map((u) => {
+        const l = u.time - n.offset, o = Math.max(0, l), h = Math.min(
+          u.duration - Math.max(0, n.offset - u.time),
+          n.duration - o
+        );
+        return {
+          time: r + o,
+          note: u.name,
+          midi: u.midi,
+          duration: Math.max(0, h),
+          velocity: u.velocity,
+          channel: u.channel
+        };
+      }), c = new Bt((u, l) => {
+        l.duration > 0 && this.triggerNote(
+          l.midi,
+          l.note,
+          l.duration,
+          u,
+          l.velocity,
+          l.channel
+        );
+      }, s);
+      return c.start(0), { clipInfo: n, part: c };
+    });
+  }
+  /**
+   * Trigger a note using the appropriate synth.
+   * Routes per-note: channel 9 → percussion synths, others → melodic PolySynth.
+   */
+  triggerNote(t, e, n, i, r, s) {
+    if (s === 9)
+      switch (fe(t)) {
+        case "kick":
+          this.kickSynth.triggerAttackRelease("C1", n, i, r);
+          break;
+        case "snare":
+          try {
+            this.snareSynth.triggerAttackRelease(n, i, r);
+          } catch (u) {
+            console.warn(
+              "[songram-daw] Snare overlap — previous hit still decaying, skipped:",
+              u
+            );
+          }
+          break;
+        case "tom": {
+          const u = {
+            41: "G1",
+            43: "A1",
+            45: "C2",
+            47: "D2",
+            48: "E2",
+            50: "G2"
+          };
+          this.tomSynth.triggerAttackRelease(
+            u[t] || "C2",
+            n,
+            i,
+            r
+          );
+          break;
+        }
+        case "cymbal":
+          this.cymbalSynth.triggerAttackRelease("C4", n, i, r);
+          break;
+      }
+    else
+      this.synth.triggerAttackRelease(e, n, i, r);
+  }
+  gainToDb(t) {
+    return 20 * Math.log10(t);
+  }
+  /**
+   * No-op for MIDI — schedule guard is for AudioBufferSourceNode ghost tick prevention.
+   * Tone.Part handles its own scheduling relative to Transport.
+   */
+  setScheduleGuardOffset(t) {
+  }
+  /**
+   * For MIDI, mid-clip sources are notes that should already be sounding.
+   * We trigger them with their remaining duration.
+   */
+  startMidClipSources(t, e) {
+    for (const { clipInfo: n } of this.scheduledClips) {
+      const i = this.track.startTime + n.startTime, r = i + n.duration;
+      if (i < t && r > t)
+        for (const s of n.notes) {
+          const c = s.time - n.offset, u = i + Math.max(0, c), l = u + s.duration;
+          if (u < t && l > t) {
+            const o = l - t;
+            try {
+              this.triggerNote(
+                s.midi,
+                s.name,
+                o,
+                e,
+                s.velocity,
+                s.channel
+              );
+            } catch (h) {
+              console.warn(
+                `[songram-daw] Failed to start mid-clip MIDI note "${s.name}" on track "${this.id}":`,
+                h
+              );
+            }
+          }
+        }
+    }
+  }
+  /**
+   * Stop all sounding notes and cancel scheduled Part events.
+   */
+  stopAllSources() {
+    const t = F().rawContext.currentTime;
+    try {
+      this.synth.releaseAll(t), this.kickSynth.releaseAll(t), this.cymbalSynth.releaseAll(t), this.tomSynth.releaseAll(t);
+    } catch (e) {
+      console.warn(`[songram-daw] Error releasing synth on track "${this.id}":`, e);
+    }
+  }
+  /**
+   * No-op for MIDI — MIDI uses note velocity, not gain fades.
+   */
+  prepareFades(t, e) {
+  }
+  /**
+   * No-op for MIDI — no fade automation to cancel.
+   */
+  cancelFades() {
+  }
+  setVolume(t) {
+    this.track.gain = t, this.volumeNode.volume.value = this.gainToDb(t);
+  }
+  setPan(t) {
+    this.track.stereoPan = t, this.panNode.pan.value = t;
+  }
+  setMute(t) {
+    this.track.muted = t;
+    const e = t ? 0 : 1;
+    ct(this.muteGain.gain)?.setValueAtTime(e, 0), this.muteGain.gain.value = e;
+  }
+  setSolo(t) {
+    this.track.soloed = t;
+  }
+  dispose() {
+    if (this.effectsCleanup)
+      try {
+        this.effectsCleanup();
+      } catch (e) {
+        console.warn(
+          `[songram-daw] Error during MIDI track "${this.id}" effects cleanup:`,
+          e
+        );
+      }
+    this.stopAllSources(), this.scheduledClips.forEach(({ part: e }, n) => {
+      try {
+        e.dispose();
+      } catch (i) {
+        console.warn(
+          `[songram-daw] Error disposing Part ${n} on MIDI track "${this.id}":`,
+          i
+        );
+      }
+    });
+    const t = [
+      this.synth,
+      this.kickSynth,
+      this.snareSynth,
+      this.cymbalSynth,
+      this.tomSynth
+    ];
+    for (const e of t)
+      try {
+        e?.dispose();
+      } catch (n) {
+        console.warn(`[songram-daw] Error disposing synth on MIDI track "${this.id}":`, n);
+      }
+    try {
+      this.volumeNode.dispose();
+    } catch (e) {
+      console.warn(
+        `[songram-daw] Error disposing volumeNode on MIDI track "${this.id}":`,
+        e
+      );
+    }
+    try {
+      this.panNode.dispose();
+    } catch (e) {
+      console.warn(`[songram-daw] Error disposing panNode on MIDI track "${this.id}":`, e);
+    }
+    try {
+      this.muteGain.dispose();
+    } catch (e) {
+      console.warn(`[songram-daw] Error disposing muteGain on MIDI track "${this.id}":`, e);
+    }
+  }
+  get id() {
+    return this.track.id;
+  }
+  get duration() {
+    if (this.scheduledClips.length === 0) return 0;
+    const t = this.scheduledClips[this.scheduledClips.length - 1];
+    return t.clipInfo.startTime + t.clipInfo.duration;
+  }
+  get muted() {
+    return this.track.muted;
+  }
+  get startTime() {
+    return this.track.startTime;
+  }
+}
+const L = class L {
+  constructor(t) {
+    this.activeSources = /* @__PURE__ */ new Set(), this.track = t.track, this.soundFontCache = t.soundFontCache, this.programNumber = t.programNumber ?? 0, this.bankNumber = t.isPercussion ? 128 : 0, this.volumeNode = new W(this.gainToDb(t.track.gain)), this.panNode = new st(t.track.stereoPan), this.muteGain = new ot(t.track.muted ? 0 : 1), this.volumeNode.chain(this.panNode, this.muteGain);
+    const e = t.destination || J();
+    if (t.effects) {
+      const n = t.effects(this.muteGain, e, !1);
+      n && (this.effectsCleanup = n);
+    } else
+      this.muteGain.connect(e);
+    this.scheduledClips = t.clips.map((n) => {
+      const i = n.notes.filter((u) => {
+        const l = u.time + u.duration;
+        return u.time < n.offset + n.duration && l > n.offset;
+      }), r = this.track.startTime + n.startTime, s = i.map((u) => {
+        const l = u.time - n.offset, o = Math.max(0, l), h = Math.min(
+          u.duration - Math.max(0, n.offset - u.time),
+          n.duration - o
+        );
+        return {
+          time: r + o,
+          note: u.name,
+          midi: u.midi,
+          duration: Math.max(0, h),
+          velocity: u.velocity,
+          channel: u.channel
+        };
+      }), c = new Bt((u, l) => {
+        l.duration > 0 && this.triggerNote(l.midi, l.duration, u, l.velocity, l.channel);
+      }, s);
+      return c.start(0), { clipInfo: n, part: c };
+    });
+  }
+  /**
+   * Trigger a note by creating a native AudioBufferSourceNode from the SoundFont cache.
+   *
+   * Per-note routing: channel 9 → bank 128 (drums), others → bank 0 with programNumber.
+   */
+  triggerNote(t, e, n, i, r) {
+    const s = r === 9 ? 128 : this.bankNumber, c = r === 9 ? 0 : this.programNumber, u = this.soundFontCache.getAudioBuffer(t, s, c);
+    if (!u) {
+      L._missingSampleWarned || (console.warn(
+        `[songram-daw] SoundFont sample not found for MIDI note ${t} (bank ${s}, preset ${c}). Subsequent missing samples will be silent.`
+      ), L._missingSampleWarned = !0);
+      return;
+    }
+    const l = F().rawContext, o = l.createBufferSource();
+    o.buffer = u.buffer, o.playbackRate.value = u.playbackRate, (u.loopMode === 1 || u.loopMode === 3) && (o.loop = !0, o.loopStart = u.loopStart, o.loopEnd = u.loopEnd);
+    const h = u.buffer.duration / u.playbackRate, f = u.loopMode === 0 ? Math.max(e, h) : e, d = i * i, g = l.createGain(), { attackVolEnv: b, holdVolEnv: y, decayVolEnv: m, sustainVolEnv: v, releaseVolEnv: k } = u, p = d * v;
+    g.gain.setValueAtTime(0, n), g.gain.linearRampToValueAtTime(d, n + b), y > 1e-3 && g.gain.setValueAtTime(d, n + b + y);
+    const S = n + b + y;
+    g.gain.linearRampToValueAtTime(p, S + m), g.gain.setValueAtTime(p, n + f), g.gain.linearRampToValueAtTime(0, n + f + k), o.connect(g), g.connect(this.volumeNode.input.input), this.activeSources.add(o), o.onended = () => {
+      this.activeSources.delete(o);
+      try {
+        g.disconnect();
+      } catch (w) {
+        console.warn("[songram-daw] GainNode already disconnected:", w);
+      }
+    }, o.start(n), o.stop(n + f + k);
+  }
+  gainToDb(t) {
+    return 20 * Math.log10(t);
+  }
+  /**
+   * No-op — Tone.Part handles scheduling internally, no ghost tick guard needed.
+   */
+  setScheduleGuardOffset(t) {
+  }
+  /**
+   * Start notes that should already be sounding at the current transport offset.
+   */
+  startMidClipSources(t, e) {
+    for (const { clipInfo: n } of this.scheduledClips) {
+      const i = this.track.startTime + n.startTime, r = i + n.duration;
+      if (i < t && r > t)
+        for (const s of n.notes) {
+          const c = s.time - n.offset, u = i + Math.max(0, c), l = u + s.duration;
+          if (u < t && l > t) {
+            const o = l - t;
+            try {
+              this.triggerNote(
+                s.midi,
+                o,
+                e,
+                s.velocity,
+                s.channel
+              );
+            } catch (h) {
+              console.warn(
+                `[songram-daw] Failed to start mid-clip SoundFont note on track "${this.id}":`,
+                h
+              );
+            }
+          }
+        }
+    }
+  }
+  /**
+   * Stop all active AudioBufferSourceNodes.
+   */
+  stopAllSources() {
+    for (const t of this.activeSources)
+      try {
+        t.stop();
+      } catch (e) {
+        console.warn("[songram-daw] Error stopping AudioBufferSourceNode:", e);
+      }
+    this.activeSources.clear();
+  }
+  /** No-op for MIDI — MIDI uses note velocity, not gain fades. */
+  prepareFades(t, e) {
+  }
+  /** No-op for MIDI — no fade automation to cancel. */
+  cancelFades() {
+  }
+  setVolume(t) {
+    this.track.gain = t, this.volumeNode.volume.value = this.gainToDb(t);
+  }
+  setPan(t) {
+    this.track.stereoPan = t, this.panNode.pan.value = t;
+  }
+  setMute(t) {
+    this.track.muted = t;
+    const e = t ? 0 : 1;
+    ct(this.muteGain.gain)?.setValueAtTime(e, 0), this.muteGain.gain.value = e;
+  }
+  setSolo(t) {
+    this.track.soloed = t;
+  }
+  dispose() {
+    if (this.effectsCleanup)
+      try {
+        this.effectsCleanup();
+      } catch (t) {
+        console.warn(
+          `[songram-daw] Error during SoundFont track "${this.id}" effects cleanup:`,
+          t
+        );
+      }
+    this.stopAllSources(), this.scheduledClips.forEach(({ part: t }, e) => {
+      try {
+        t.dispose();
+      } catch (n) {
+        console.warn(
+          `[songram-daw] Error disposing Part ${e} on SoundFont track "${this.id}":`,
+          n
+        );
+      }
+    });
+    try {
+      this.volumeNode.dispose();
+    } catch (t) {
+      console.warn(
+        `[songram-daw] Error disposing volumeNode on SoundFont track "${this.id}":`,
+        t
+      );
+    }
+    try {
+      this.panNode.dispose();
+    } catch (t) {
+      console.warn(
+        `[songram-daw] Error disposing panNode on SoundFont track "${this.id}":`,
+        t
+      );
+    }
+    try {
+      this.muteGain.dispose();
+    } catch (t) {
+      console.warn(
+        `[songram-daw] Error disposing muteGain on SoundFont track "${this.id}":`,
+        t
+      );
+    }
+  }
+  get id() {
+    return this.track.id;
+  }
+  get duration() {
+    if (this.scheduledClips.length === 0) return 0;
+    const t = this.scheduledClips[this.scheduledClips.length - 1];
+    return t.clipInfo.startTime + t.clipInfo.duration;
+  }
+  get muted() {
+    return this.track.muted;
+  }
+  get startTime() {
+    return this.track.startTime;
+  }
+};
+L._missingSampleWarned = !1;
+let nt = L;
+class pe {
+  constructor(t = {}) {
+    if (this.tracks = /* @__PURE__ */ new Map(), this.isInitialized = !1, this.soloedTracks = /* @__PURE__ */ new Set(), this.manualMuteState = /* @__PURE__ */ new Map(), this._completionEventId = null, this._loopHandler = null, this._loopEnabled = !1, this._loopStart = 0, this._loopEnd = 0, this.masterVolume = new W(this.gainToDb(t.masterGain ?? 1)), t.effects) {
+      const e = t.effects(this.masterVolume, J(), !1);
+      e && (this.effectsCleanup = e);
+    } else
+      this.masterVolume.toDestination();
+    t.tracks && t.tracks.forEach((e) => {
+      this.tracks.set(e.id, e), this.manualMuteState.set(e.id, e.muted);
+    });
+  }
+  gainToDb(t) {
+    return 20 * Math.log10(t);
+  }
+  clearCompletionEvent() {
+    if (this._completionEventId !== null) {
+      try {
+        I().clear(this._completionEventId);
+      } catch (t) {
+        console.warn("[songram-daw] Error clearing Transport completion event:", t);
+      }
+      this._completionEventId = null;
+    }
+  }
+  async init() {
+    this.isInitialized || (await Jt(), this.isInitialized = !0);
+  }
+  addTrack(t) {
+    const e = {
+      ...t,
+      destination: this.masterVolume
+    }, n = new de(e);
+    return this.tracks.set(n.id, n), this.manualMuteState.set(n.id, t.track.muted ?? !1), t.track.soloed && this.soloedTracks.add(n.id), n;
+  }
+  addMidiTrack(t) {
+    const e = {
+      ...t,
+      destination: this.masterVolume
+    }, n = new me(e);
+    return this.tracks.set(n.id, n), this.manualMuteState.set(n.id, t.track.muted ?? !1), t.track.soloed && this.soloedTracks.add(n.id), n;
+  }
+  addSoundFontTrack(t) {
+    const e = {
+      ...t,
+      destination: this.masterVolume
+    }, n = new nt(e);
+    return this.tracks.set(n.id, n), this.manualMuteState.set(n.id, t.track.muted ?? !1), t.track.soloed && this.soloedTracks.add(n.id), n;
+  }
+  /**
+   * Apply solo muting after all tracks have been added.
+   * Call this after adding all tracks to ensure solo logic is applied correctly.
+   */
+  applyInitialSoloState() {
+    this.updateSoloMuting();
+  }
+  removeTrack(t) {
+    const e = this.tracks.get(t);
+    e && (e.dispose(), this.tracks.delete(t), this.manualMuteState.delete(t), this.soloedTracks.delete(t));
+  }
+  getTrack(t) {
+    return this.tracks.get(t);
+  }
+  play(t, e, n) {
+    if (!this.isInitialized)
+      throw new Error("[songram-daw] TonePlayout not initialized. Call init() first.");
+    const i = t ?? tt(), r = I();
+    this.clearCompletionEvent();
+    const s = e ?? 0;
+    this.tracks.forEach((c) => {
+      c.cancelFades(), c.prepareFades(i, s);
+    }), n !== void 0 && (this._completionEventId = r.scheduleOnce(() => {
+      this._completionEventId = null;
+      try {
+        this.onPlaybackCompleteCallback?.();
+      } catch (c) {
+        console.warn("[songram-daw] Error in playback completion callback:", c);
+      }
+    }, s + n));
+    try {
+      r.state !== "stopped" && r.stop(), this.tracks.forEach((c) => c.stopAllSources()), r.loopStart = this._loopStart, r.loopEnd = this._loopEnd, r.loop = this._loopEnabled, this.tracks.forEach((c) => c.setScheduleGuardOffset(s)), e !== void 0 ? r.start(i, e) : r.start(i), r._clock._lastUpdate = i, this.tracks.forEach((c) => {
+        c.startMidClipSources(s, i);
+      });
+    } catch (c) {
+      throw this.clearCompletionEvent(), this.tracks.forEach((u) => u.cancelFades()), console.warn(
+        "[songram-daw] Transport.start() failed. Audio playback could not begin.",
+        c
+      ), c;
+    }
+  }
+  pause() {
+    const t = I();
+    try {
+      t.pause();
+    } catch (e) {
+      console.warn("[songram-daw] Transport.pause() failed:", e);
+    }
+    this.tracks.forEach((e) => e.stopAllSources()), this.tracks.forEach((e) => e.cancelFades()), this.clearCompletionEvent();
+  }
+  stop() {
+    const t = I();
+    try {
+      t.stop();
+    } catch (e) {
+      console.warn("[songram-daw] Transport.stop() failed:", e);
+    }
+    if (this._loopHandler) {
+      try {
+        t.off("loop", this._loopHandler);
+      } catch (e) {
+        console.warn("[songram-daw] Error removing loop handler:", e);
+      }
+      this._loopHandler = null;
+    }
+    this.tracks.forEach((e) => {
+      try {
+        e.stopAllSources();
+      } catch (n) {
+        console.warn(`[songram-daw] Error stopping sources for track "${e.id}":`, n);
+      }
+    }), this.tracks.forEach((e) => {
+      try {
+        e.cancelFades();
+      } catch (n) {
+        console.warn(`[songram-daw] Error canceling fades for track "${e.id}":`, n);
+      }
+    }), this.clearCompletionEvent();
+  }
+  setMasterGain(t) {
+    this.masterVolume.volume.value = this.gainToDb(t);
+  }
+  setSolo(t, e) {
+    const n = this.tracks.get(t);
+    n && (n.setSolo(e), e ? this.soloedTracks.add(t) : this.soloedTracks.delete(t), this.updateSoloMuting());
+  }
+  updateSoloMuting() {
+    const t = this.soloedTracks.size > 0;
+    this.tracks.forEach((e, n) => {
+      if (t)
+        if (!this.soloedTracks.has(n))
+          e.setMute(!0);
+        else {
+          const i = this.manualMuteState.get(n) ?? !1;
+          e.setMute(i);
+        }
+      else {
+        const i = this.manualMuteState.get(n) ?? !1;
+        e.setMute(i);
+      }
+    });
+  }
+  setMute(t, e) {
+    const n = this.tracks.get(t);
+    n && (this.manualMuteState.set(t, e), n.setMute(e));
+  }
+  setLoop(t, e, n) {
+    this._loopEnabled = t, this._loopStart = e, this._loopEnd = n;
+    const i = I();
+    try {
+      i.loopStart = e, i.loopEnd = n, i.loop = t;
+    } catch (r) {
+      console.warn("[songram-daw] Error configuring Transport loop:", r);
+      return;
+    }
+    t && !this._loopHandler ? (this._loopHandler = () => {
+      const r = tt();
+      this.tracks.forEach((s) => {
+        try {
+          s.stopAllSources(), s.cancelFades(), s.setScheduleGuardOffset(this._loopStart), s.startMidClipSources(this._loopStart, r), s.prepareFades(r, this._loopStart);
+        } catch (c) {
+          console.warn(
+            `[songram-daw] Error re-scheduling track "${s.id}" on loop:`,
+            c
+          );
+        }
+      });
+    }, i.on("loop", this._loopHandler)) : !t && this._loopHandler && (i.off("loop", this._loopHandler), this._loopHandler = null);
+  }
+  getCurrentTime() {
+    return I().seconds;
+  }
+  seekTo(t) {
+    I().seconds = t;
+  }
+  dispose() {
+    try {
+      this.stop();
+    } catch (t) {
+      console.warn("[songram-daw] Error stopping Transport during dispose:", t);
+    }
+    if (this.tracks.forEach((t) => {
+      try {
+        t.dispose();
+      } catch (e) {
+        console.warn(`[songram-daw] Error disposing track "${t.id}":`, e);
+      }
+    }), this.tracks.clear(), this.effectsCleanup)
+      try {
+        this.effectsCleanup();
+      } catch (t) {
+        console.warn("[songram-daw] Error during master effects cleanup:", t);
+      }
+    try {
+      this.masterVolume.dispose();
+    } catch (t) {
+      console.warn("[songram-daw] Error disposing master volume:", t);
+    }
+  }
+  get context() {
+    return F();
+  }
+  get sampleRate() {
+    return F().sampleRate;
+  }
+  setOnPlaybackComplete(t) {
+    this.onPlaybackCompleteCallback = t;
+  }
+}
+function z(a) {
+  return Math.pow(2, a / 1200);
+}
+const ge = 5;
+function _(a, t) {
+  return a[t]?.value;
+}
+function ye(a) {
+  const t = new Float32Array(a.length);
+  for (let e = 0; e < a.length; e++)
+    t[e] = a[e] / 32768;
+  return t;
+}
+function ve(a) {
+  const { midiNote: t, overrideRootKey: e, originalPitch: n, coarseTune: i, fineTune: r, pitchCorrection: s } = a, u = t - (e !== void 0 ? e : n !== 255 ? n : 60) + i + (r + s) / 100;
+  return Math.pow(2, u / 12);
+}
+function be(a) {
+  const { generators: t, header: e } = a, n = _(t, T.SampleModes) ?? 0, i = e.startLoop + (_(t, T.StartLoopAddrsOffset) ?? 0) + (_(t, T.StartLoopAddrsCoarseOffset) ?? 0) * 32768, r = e.endLoop + (_(t, T.EndLoopAddrsOffset) ?? 0) + (_(t, T.EndLoopAddrsCoarseOffset) ?? 0) * 32768, s = i / e.sampleRate, c = r / e.sampleRate, u = z(
+    _(t, T.AttackVolEnv) ?? -12e3
+  ), l = z(
+    _(t, T.HoldVolEnv) ?? -12e3
+  ), o = z(
+    _(t, T.DecayVolEnv) ?? -12e3
+  ), h = Math.min(
+    z(_(t, T.ReleaseVolEnv) ?? -12e3),
+    ge
+  ), f = _(t, T.SustainVolEnv) ?? 0, d = Math.pow(10, -f / 200);
+  return {
+    loopMode: n,
+    loopStart: s,
+    loopEnd: c,
+    attackVolEnv: u,
+    holdVolEnv: l,
+    decayVolEnv: o,
+    sustainVolEnv: d,
+    releaseVolEnv: h
+  };
+}
+class kr {
+  /**
+   * @param context Optional AudioContext for createBuffer(). If omitted, uses
+   *   an OfflineAudioContext which doesn't require user gesture — safe to
+   *   construct before user interaction (avoids Firefox autoplay warnings).
+   */
+  constructor(t) {
+    this.sf2 = null, this.audioBufferCache = /* @__PURE__ */ new Map(), this.context = t ?? new OfflineAudioContext(1, 1, 44100);
+  }
+  /**
+   * Load and parse an SF2 file from a URL.
+   */
+  async load(t, e) {
+    const n = await fetch(t, { signal: e });
+    if (!n.ok)
+      throw new Error(`Failed to fetch SoundFont ${t}: ${n.statusText}`);
+    const i = await n.arrayBuffer();
+    try {
+      this.sf2 = new ht(new Uint8Array(i));
+    } catch (r) {
+      throw new Error(
+        `Failed to parse SoundFont ${t}: ${r instanceof Error ? r.message : String(r)}`
+      );
+    }
+  }
+  /**
+   * Load from an already-fetched ArrayBuffer.
+   */
+  loadFromBuffer(t) {
+    try {
+      this.sf2 = new ht(new Uint8Array(t));
+    } catch (e) {
+      throw new Error(
+        `Failed to parse SoundFont from buffer: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  get isLoaded() {
+    return this.sf2 !== null;
+  }
+  /**
+   * Look up a MIDI note and return the AudioBuffer + playbackRate.
+   *
+   * @param midiNote - MIDI note number (0-127)
+   * @param bankNumber - Bank number (0 for melodic, 128 for percussion/drums)
+   * @param presetNumber - GM program number (0-127)
+   * @returns SoundFontSample or null if no sample found for this note
+   */
+  getAudioBuffer(t, e = 0, n = 0) {
+    if (!this.sf2) return null;
+    const i = this.sf2.getKeyData(t, e, n);
+    if (!i) return null;
+    const r = i.sample, s = this.sf2.samples.indexOf(r);
+    let c = this.audioBufferCache.get(s);
+    c || (c = this.int16ToAudioBuffer(r.data, r.header.sampleRate), this.audioBufferCache.set(s, c));
+    const u = ve({
+      midiNote: t,
+      overrideRootKey: _(i.generators, T.OverridingRootKey),
+      originalPitch: r.header.originalPitch,
+      coarseTune: _(i.generators, T.CoarseTune) ?? 0,
+      fineTune: _(i.generators, T.FineTune) ?? 0,
+      pitchCorrection: r.header.pitchCorrection ?? 0
+    }), l = be({
+      generators: i.generators,
+      header: i.sample.header
+    });
+    return { buffer: c, playbackRate: u, ...l };
+  }
+  /**
+   * Convert Int16Array sample data to an AudioBuffer.
+   * Uses the extracted int16ToFloat32 for the conversion, then copies into an AudioBuffer.
+   */
+  int16ToAudioBuffer(t, e) {
+    const n = ye(t), i = this.context.createBuffer(1, n.length, e);
+    return i.getChannelData(0).set(n), i;
+  }
+  /**
+   * Clear all cached AudioBuffers and release the parsed SF2.
+   */
+  dispose() {
+    this.audioBufferCache.clear(), this.sf2 = null;
+  }
+}
+let x = null;
+function ut() {
+  return x || (x = new Kt(), Xt(x)), x;
+}
+function Sr() {
+  return ut().rawContext;
+}
+function wr() {
+  return ut();
+}
+async function Tr() {
+  const a = ut();
+  a.state !== "running" && await a.resume();
+}
+function _r() {
+  return x?.rawContext.state || "suspended";
+}
+async function Cr() {
+  x && x.rawContext.state !== "closed" && (await x.close(), x = null);
+}
+const V = /* @__PURE__ */ new Map(), at = /* @__PURE__ */ new Map();
+function Ir(a) {
+  if (V.has(a))
+    return V.get(a);
+  const e = F().createMediaStreamSource(a);
+  V.set(a, e);
+  const n = () => {
+    e.disconnect(), V.delete(a), at.delete(a), a.removeEventListener("ended", n), a.removeEventListener("inactive", n);
+  };
+  return at.set(a, n), a.addEventListener("ended", n), a.addEventListener("inactive", n), e;
+}
+function xr(a) {
+  const t = at.get(a);
+  t && t();
+}
+function Mr(a) {
+  return V.has(a);
+}
+function ke(a) {
+  let t = null, e = !1, n = 0, i = !1, r = 0, s = 0, c = !1;
+  function u(o, h) {
+    const f = h.clips.filter((g) => g.audioBuffer && !g.midiNotes), d = h.clips.filter((g) => g.midiNotes && g.midiNotes.length > 0);
+    if (f.length > 0) {
+      const g = Math.min(...f.map(q)), b = Math.max(...f.map(dt)), y = {
+        id: h.id,
+        name: h.name,
+        gain: h.volume,
+        muted: h.muted,
+        soloed: h.soloed,
+        stereoPan: h.pan,
+        startTime: g,
+        endTime: b
+      }, m = f.map((v) => ({
+        buffer: v.audioBuffer,
+        startTime: q(v) - g,
+        duration: mt(v),
+        offset: ft(v),
+        fadeIn: v.fadeIn,
+        fadeOut: v.fadeOut,
+        gain: v.gain
+      }));
+      o.addTrack({
+        clips: m,
+        track: y,
+        effects: h.effects
+      });
+    }
+    if (d.length > 0) {
+      const g = Math.min(...d.map(q)), b = Math.max(...d.map(dt)), m = {
+        id: f.length > 0 ? `${h.id}:midi` : h.id,
+        name: h.name,
+        gain: h.volume,
+        muted: h.muted,
+        soloed: h.soloed,
+        stereoPan: h.pan,
+        startTime: g,
+        endTime: b
+      }, v = d.map((k) => ({
+        notes: k.midiNotes,
+        startTime: q(k) - g,
+        duration: mt(k),
+        offset: ft(k)
+      }));
+      if (a?.soundFontCache?.isLoaded) {
+        const k = d[0], S = k.midiChannel === 9, w = k.midiProgram ?? 0;
+        o.addSoundFontTrack({
+          clips: v,
+          track: m,
+          soundFontCache: a.soundFontCache,
+          programNumber: w,
+          isPercussion: S,
+          effects: h.effects
+        });
+      } else
+        a?.soundFontCache && console.warn(
+          `[songram-daw] SoundFont not loaded for track "${h.name}" — falling back to PolySynth.`
+        ), o.addMidiTrack({
+          clips: v,
+          track: m,
+          effects: h.effects
+        });
+    }
+  }
+  function l(o) {
+    if (t) {
+      try {
+        t.dispose();
+      } catch (f) {
+        console.warn("[songram-daw] Error disposing previous playout during rebuild:", f);
+      }
+      t = null;
+    }
+    n++;
+    const h = n;
+    t = new pe({
+      effects: a?.effects
+    }), c && t.init().catch((f) => {
+      console.warn(
+        "[songram-daw] Failed to re-initialize playout after rebuild. Audio playback will require another user gesture.",
+        f
+      ), c = !1;
+    });
+    for (const f of o)
+      u(t, f);
+    t.applyInitialSoloState(), t.setLoop(i, r, s), t.setOnPlaybackComplete(() => {
+      h === n && (e = !1);
+    });
+  }
+  return {
+    async init() {
+      t && (await t.init(), c = !0);
+    },
+    setTracks(o) {
+      l(o);
+    },
+    addTrack(o) {
+      if (!t)
+        throw new Error(
+          "[songram-daw] adapter.addTrack() called but no playout exists. Call setTracks() first to initialize the playout."
+        );
+      u(t, o), t.applyInitialSoloState();
+    },
+    play(o, h) {
+      if (!t) {
+        console.warn(
+          "[songram-daw] adapter.play() called but no playout is available. Tracks may not have been set, or the adapter was disposed."
+        );
+        return;
+      }
+      const f = h !== void 0 ? h - o : void 0;
+      t.play(tt(), o, f), e = !0;
+    },
+    pause() {
+      t?.pause(), e = !1;
+    },
+    stop() {
+      t?.stop(), e = !1;
+    },
+    seek(o) {
+      t?.seekTo(o);
+    },
+    getCurrentTime() {
+      return t?.getCurrentTime() ?? 0;
+    },
+    isPlaying() {
+      return e;
+    },
+    setMasterVolume(o) {
+      t?.setMasterGain(o);
+    },
+    setTrackVolume(o, h) {
+      t?.getTrack(o)?.setVolume(h);
+    },
+    setTrackMute(o, h) {
+      t?.setMute(o, h);
+    },
+    setTrackSolo(o, h) {
+      t?.setSolo(o, h);
+    },
+    setTrackPan(o, h) {
+      t?.getTrack(o)?.setPan(h);
+    },
+    setLoop(o, h, f) {
+      i = o, r = h, s = f, t?.setLoop(o, h, f);
+    },
+    dispose() {
+      try {
+        t?.dispose();
+      } catch (o) {
+        console.warn("[songram-daw] Error disposing playout:", o);
+      }
+      t = null, e = !1;
+    }
+  };
+}
+function Se(a) {
+  if (Object.prototype.hasOwnProperty.call(a, "__esModule")) return a;
+  var t = a.default;
+  if (typeof t == "function") {
+    var e = function n() {
+      var i = !1;
+      try {
+        i = this instanceof n;
+      } catch {
+      }
+      return i ? Reflect.construct(t, arguments, this.constructor) : t.apply(this, arguments);
+    };
+    e.prototype = t.prototype;
+  } else e = {};
+  return Object.defineProperty(e, "__esModule", { value: !0 }), Object.keys(a).forEach(function(n) {
+    var i = Object.getOwnPropertyDescriptor(a, n);
+    Object.defineProperty(e, n, i.get ? i : {
+      enumerable: !0,
+      get: function() {
+        return a[n];
+      }
+    });
+  }), e;
+}
+var M = {}, H = {}, X, St;
+function we() {
+  if (St) return X;
+  St = 1;
+  function a(i) {
+    var r = new n(i), s = r.readChunk();
+    if (s.id != "MThd")
+      throw "Bad MIDI file.  Expected 'MHdr', got: '" + s.id + "'";
+    for (var c = t(s.data), u = [], l = 0; !r.eof() && l < c.numTracks; l++) {
+      var o = r.readChunk();
+      if (o.id != "MTrk")
+        throw "Bad MIDI file.  Expected 'MTrk', got: '" + o.id + "'";
+      var h = e(o.data);
+      u.push(h);
+    }
+    return {
+      header: c,
+      tracks: u
+    };
+  }
+  function t(i) {
+    var r = new n(i), s = r.readUInt16(), c = r.readUInt16(), u = {
+      format: s,
+      numTracks: c
+    }, l = r.readUInt16();
+    return l & 32768 ? (u.framesPerSecond = 256 - (l >> 8), u.ticksPerFrame = l & 255) : u.ticksPerBeat = l, u;
+  }
+  function e(i) {
+    for (var r = new n(i), s = []; !r.eof(); ) {
+      var c = l();
+      s.push(c);
+    }
+    return s;
+    var u;
+    function l() {
+      var o = {};
+      o.deltaTime = r.readVarInt();
+      var h = r.readUInt8();
+      if ((h & 240) === 240)
+        if (h === 255) {
+          o.meta = !0;
+          var f = r.readUInt8(), d = r.readVarInt();
+          switch (f) {
+            case 0:
+              if (o.type = "sequenceNumber", d !== 2) throw "Expected length for sequenceNumber event is 2, got " + d;
+              return o.number = r.readUInt16(), o;
+            case 1:
+              return o.type = "text", o.text = r.readString(d), o;
+            case 2:
+              return o.type = "copyrightNotice", o.text = r.readString(d), o;
+            case 3:
+              return o.type = "trackName", o.text = r.readString(d), o;
+            case 4:
+              return o.type = "instrumentName", o.text = r.readString(d), o;
+            case 5:
+              return o.type = "lyrics", o.text = r.readString(d), o;
+            case 6:
+              return o.type = "marker", o.text = r.readString(d), o;
+            case 7:
+              return o.type = "cuePoint", o.text = r.readString(d), o;
+            case 32:
+              if (o.type = "channelPrefix", d != 1) throw "Expected length for channelPrefix event is 1, got " + d;
+              return o.channel = r.readUInt8(), o;
+            case 33:
+              if (o.type = "portPrefix", d != 1) throw "Expected length for portPrefix event is 1, got " + d;
+              return o.port = r.readUInt8(), o;
+            case 47:
+              if (o.type = "endOfTrack", d != 0) throw "Expected length for endOfTrack event is 0, got " + d;
+              return o;
+            case 81:
+              if (o.type = "setTempo", d != 3) throw "Expected length for setTempo event is 3, got " + d;
+              return o.microsecondsPerBeat = r.readUInt24(), o;
+            case 84:
+              if (o.type = "smpteOffset", d != 5) throw "Expected length for smpteOffset event is 5, got " + d;
+              var g = r.readUInt8(), b = { 0: 24, 32: 25, 64: 29, 96: 30 };
+              return o.frameRate = b[g & 96], o.hour = g & 31, o.min = r.readUInt8(), o.sec = r.readUInt8(), o.frame = r.readUInt8(), o.subFrame = r.readUInt8(), o;
+            case 88:
+              if (o.type = "timeSignature", d != 2 && d != 4) throw "Expected length for timeSignature event is 4 or 2, got " + d;
+              return o.numerator = r.readUInt8(), o.denominator = 1 << r.readUInt8(), d === 4 ? (o.metronome = r.readUInt8(), o.thirtyseconds = r.readUInt8()) : (o.metronome = 36, o.thirtyseconds = 8), o;
+            case 89:
+              if (o.type = "keySignature", d != 2) throw "Expected length for keySignature event is 2, got " + d;
+              return o.key = r.readInt8(), o.scale = r.readUInt8(), o;
+            case 127:
+              return o.type = "sequencerSpecific", o.data = r.readBytes(d), o;
+            default:
+              return o.type = "unknownMeta", o.data = r.readBytes(d), o.metatypeByte = f, o;
+          }
+        } else if (h == 240) {
+          o.type = "sysEx";
+          var d = r.readVarInt();
+          return o.data = r.readBytes(d), o;
+        } else if (h == 247) {
+          o.type = "endSysEx";
+          var d = r.readVarInt();
+          return o.data = r.readBytes(d), o;
+        } else
+          throw "Unrecognised MIDI event type byte: " + h;
+      else {
+        var y;
+        if ((h & 128) === 0) {
+          if (u === null)
+            throw "Running status byte encountered before status byte";
+          y = h, h = u, o.running = !0;
+        } else
+          y = r.readUInt8(), u = h;
+        var m = h >> 4;
+        switch (o.channel = h & 15, m) {
+          case 8:
+            return o.type = "noteOff", o.noteNumber = y, o.velocity = r.readUInt8(), o;
+          case 9:
+            var v = r.readUInt8();
+            return o.type = v === 0 ? "noteOff" : "noteOn", o.noteNumber = y, o.velocity = v, v === 0 && (o.byte9 = !0), o;
+          case 10:
+            return o.type = "noteAftertouch", o.noteNumber = y, o.amount = r.readUInt8(), o;
+          case 11:
+            return o.type = "controller", o.controllerType = y, o.value = r.readUInt8(), o;
+          case 12:
+            return o.type = "programChange", o.programNumber = y, o;
+          case 13:
+            return o.type = "channelAftertouch", o.amount = y, o;
+          case 14:
+            return o.type = "pitchBend", o.value = y + (r.readUInt8() << 7) - 8192, o;
+          default:
+            throw "Unrecognised MIDI event type: " + m;
+        }
+      }
+    }
+  }
+  function n(i) {
+    this.buffer = i, this.bufferLen = this.buffer.length, this.pos = 0;
+  }
+  return n.prototype.eof = function() {
+    return this.pos >= this.bufferLen;
+  }, n.prototype.readUInt8 = function() {
+    var i = this.buffer[this.pos];
+    return this.pos += 1, i;
+  }, n.prototype.readInt8 = function() {
+    var i = this.readUInt8();
+    return i & 128 ? i - 256 : i;
+  }, n.prototype.readUInt16 = function() {
+    var i = this.readUInt8(), r = this.readUInt8();
+    return (i << 8) + r;
+  }, n.prototype.readInt16 = function() {
+    var i = this.readUInt16();
+    return i & 32768 ? i - 65536 : i;
+  }, n.prototype.readUInt24 = function() {
+    var i = this.readUInt8(), r = this.readUInt8(), s = this.readUInt8();
+    return (i << 16) + (r << 8) + s;
+  }, n.prototype.readInt24 = function() {
+    var i = this.readUInt24();
+    return i & 8388608 ? i - 16777216 : i;
+  }, n.prototype.readUInt32 = function() {
+    var i = this.readUInt8(), r = this.readUInt8(), s = this.readUInt8(), c = this.readUInt8();
+    return (i << 24) + (r << 16) + (s << 8) + c;
+  }, n.prototype.readBytes = function(i) {
+    var r = this.buffer.slice(this.pos, this.pos + i);
+    return this.pos += i, r;
+  }, n.prototype.readString = function(i) {
+    var r = this.readBytes(i);
+    return String.fromCharCode.apply(null, r);
+  }, n.prototype.readVarInt = function() {
+    for (var i = 0; !this.eof(); ) {
+      var r = this.readUInt8();
+      if (r & 128)
+        i += r & 127, i <<= 7;
+      else
+        return i + r;
+    }
+    return i;
+  }, n.prototype.readChunk = function() {
+    var i = this.readString(4), r = this.readUInt32(), s = this.readBytes(r);
+    return {
+      id: i,
+      length: r,
+      data: s
+    };
+  }, X = a, X;
+}
+var Z, wt;
+function Te() {
+  if (wt) return Z;
+  wt = 1;
+  function a(r, s) {
+    if (typeof r != "object")
+      throw "Invalid MIDI data";
+    s = s || {};
+    var c = r.header || {}, u = r.tracks || [], l, o = u.length, h = new i();
+    for (t(h, c, o), l = 0; l < o; l++)
+      e(h, u[l], s);
+    return h.buffer;
+  }
+  function t(r, s, c) {
+    var u = s.format == null ? 1 : s.format, l = 128;
+    s.timeDivision ? l = s.timeDivision : s.ticksPerFrame && s.framesPerSecond ? l = -(s.framesPerSecond & 255) << 8 | s.ticksPerFrame & 255 : s.ticksPerBeat && (l = s.ticksPerBeat & 32767);
+    var o = new i();
+    o.writeUInt16(u), o.writeUInt16(c), o.writeUInt16(l), r.writeChunk("MThd", o.buffer);
+  }
+  function e(r, s, c) {
+    var u = new i(), l, o = s.length, h = null;
+    for (l = 0; l < o; l++)
+      (c.running === !1 || !c.running && !s[l].running) && (h = null), h = n(u, s[l], h, c.useByte9ForNoteOff);
+    r.writeChunk("MTrk", u.buffer);
+  }
+  function n(r, s, c, u) {
+    var l = s.type, o = s.deltaTime, h = s.text || "", f = s.data || [], d = null;
+    switch (r.writeVarInt(o), l) {
+      // meta events
+      case "sequenceNumber":
+        r.writeUInt8(255), r.writeUInt8(0), r.writeVarInt(2), r.writeUInt16(s.number);
+        break;
+      case "text":
+        r.writeUInt8(255), r.writeUInt8(1), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "copyrightNotice":
+        r.writeUInt8(255), r.writeUInt8(2), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "trackName":
+        r.writeUInt8(255), r.writeUInt8(3), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "instrumentName":
+        r.writeUInt8(255), r.writeUInt8(4), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "lyrics":
+        r.writeUInt8(255), r.writeUInt8(5), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "marker":
+        r.writeUInt8(255), r.writeUInt8(6), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "cuePoint":
+        r.writeUInt8(255), r.writeUInt8(7), r.writeVarInt(h.length), r.writeString(h);
+        break;
+      case "channelPrefix":
+        r.writeUInt8(255), r.writeUInt8(32), r.writeVarInt(1), r.writeUInt8(s.channel);
+        break;
+      case "portPrefix":
+        r.writeUInt8(255), r.writeUInt8(33), r.writeVarInt(1), r.writeUInt8(s.port);
+        break;
+      case "endOfTrack":
+        r.writeUInt8(255), r.writeUInt8(47), r.writeVarInt(0);
+        break;
+      case "setTempo":
+        r.writeUInt8(255), r.writeUInt8(81), r.writeVarInt(3), r.writeUInt24(s.microsecondsPerBeat);
+        break;
+      case "smpteOffset":
+        r.writeUInt8(255), r.writeUInt8(84), r.writeVarInt(5);
+        var g = { 24: 0, 25: 32, 29: 64, 30: 96 }, b = s.hour & 31 | g[s.frameRate];
+        r.writeUInt8(b), r.writeUInt8(s.min), r.writeUInt8(s.sec), r.writeUInt8(s.frame), r.writeUInt8(s.subFrame);
+        break;
+      case "timeSignature":
+        r.writeUInt8(255), r.writeUInt8(88), r.writeVarInt(4), r.writeUInt8(s.numerator);
+        var y = Math.floor(Math.log(s.denominator) / Math.LN2) & 255;
+        r.writeUInt8(y), r.writeUInt8(s.metronome), r.writeUInt8(s.thirtyseconds || 8);
+        break;
+      case "keySignature":
+        r.writeUInt8(255), r.writeUInt8(89), r.writeVarInt(2), r.writeInt8(s.key), r.writeUInt8(s.scale);
+        break;
+      case "sequencerSpecific":
+        r.writeUInt8(255), r.writeUInt8(127), r.writeVarInt(f.length), r.writeBytes(f);
+        break;
+      case "unknownMeta":
+        s.metatypeByte != null && (r.writeUInt8(255), r.writeUInt8(s.metatypeByte), r.writeVarInt(f.length), r.writeBytes(f));
+        break;
+      // system-exclusive
+      case "sysEx":
+        r.writeUInt8(240), r.writeVarInt(f.length), r.writeBytes(f);
+        break;
+      case "endSysEx":
+        r.writeUInt8(247), r.writeVarInt(f.length), r.writeBytes(f);
+        break;
+      // channel events
+      case "noteOff":
+        var m = u !== !1 && s.byte9 || u && s.velocity == 0 ? 144 : 128;
+        d = m | s.channel, d !== c && r.writeUInt8(d), r.writeUInt8(s.noteNumber), r.writeUInt8(s.velocity);
+        break;
+      case "noteOn":
+        d = 144 | s.channel, d !== c && r.writeUInt8(d), r.writeUInt8(s.noteNumber), r.writeUInt8(s.velocity);
+        break;
+      case "noteAftertouch":
+        d = 160 | s.channel, d !== c && r.writeUInt8(d), r.writeUInt8(s.noteNumber), r.writeUInt8(s.amount);
+        break;
+      case "controller":
+        d = 176 | s.channel, d !== c && r.writeUInt8(d), r.writeUInt8(s.controllerType), r.writeUInt8(s.value);
+        break;
+      case "programChange":
+        d = 192 | s.channel, d !== c && r.writeUInt8(d), r.writeUInt8(s.programNumber);
+        break;
+      case "channelAftertouch":
+        d = 208 | s.channel, d !== c && r.writeUInt8(d), r.writeUInt8(s.amount);
+        break;
+      case "pitchBend":
+        d = 224 | s.channel, d !== c && r.writeUInt8(d);
+        var v = 8192 + s.value, k = v & 127, p = v >> 7 & 127;
+        r.writeUInt8(k), r.writeUInt8(p);
+        break;
+      default:
+        throw "Unrecognized event type: " + l;
+    }
+    return d;
+  }
+  function i() {
+    this.buffer = [];
+  }
+  return i.prototype.writeUInt8 = function(r) {
+    this.buffer.push(r & 255);
+  }, i.prototype.writeInt8 = i.prototype.writeUInt8, i.prototype.writeUInt16 = function(r) {
+    var s = r >> 8 & 255, c = r & 255;
+    this.writeUInt8(s), this.writeUInt8(c);
+  }, i.prototype.writeInt16 = i.prototype.writeUInt16, i.prototype.writeUInt24 = function(r) {
+    var s = r >> 16 & 255, c = r >> 8 & 255, u = r & 255;
+    this.writeUInt8(s), this.writeUInt8(c), this.writeUInt8(u);
+  }, i.prototype.writeInt24 = i.prototype.writeUInt24, i.prototype.writeUInt32 = function(r) {
+    var s = r >> 24 & 255, c = r >> 16 & 255, u = r >> 8 & 255, l = r & 255;
+    this.writeUInt8(s), this.writeUInt8(c), this.writeUInt8(u), this.writeUInt8(l);
+  }, i.prototype.writeInt32 = i.prototype.writeUInt32, i.prototype.writeBytes = function(r) {
+    this.buffer = this.buffer.concat(Array.prototype.slice.call(r, 0));
+  }, i.prototype.writeString = function(r) {
+    var s, c = r.length, u = [];
+    for (s = 0; s < c; s++)
+      u.push(r.codePointAt(s));
+    this.writeBytes(u);
+  }, i.prototype.writeVarInt = function(r) {
+    if (r < 0) throw "Cannot write negative variable-length integer";
+    if (r <= 127)
+      this.writeUInt8(r);
+    else {
+      var s = r, c = [];
+      for (c.push(s & 127), s >>= 7; s; ) {
+        var u = s & 127 | 128;
+        c.push(u), s >>= 7;
+      }
+      this.writeBytes(c.reverse());
+    }
+  }, i.prototype.writeChunk = function(r, s) {
+    this.writeString(r), this.writeUInt32(s.length), this.writeBytes(s);
+  }, Z = a, Z;
+}
+var Tt;
+function Gt() {
+  return Tt || (Tt = 1, H.parseMidi = we(), H.writeMidi = Te()), H;
+}
+var Q = {}, E = {}, _t;
+function $t() {
+  if (_t) return E;
+  _t = 1, Object.defineProperty(E, "__esModule", { value: !0 }), E.insert = E.search = void 0;
+  function a(e, n, i) {
+    i === void 0 && (i = "ticks");
+    var r = 0, s = e.length, c = s;
+    if (s > 0 && e[s - 1][i] <= n)
+      return s - 1;
+    for (; r < c; ) {
+      var u = Math.floor(r + (c - r) / 2), l = e[u], o = e[u + 1];
+      if (l[i] === n) {
+        for (var h = u; h < e.length; h++) {
+          var f = e[h];
+          f[i] === n && (u = h);
+        }
+        return u;
+      } else {
+        if (l[i] < n && o[i] > n)
+          return u;
+        l[i] > n ? c = u : l[i] < n && (r = u + 1);
+      }
+    }
+    return -1;
+  }
+  E.search = a;
+  function t(e, n, i) {
+    if (i === void 0 && (i = "ticks"), e.length) {
+      var r = a(e, n[i], i);
+      e.splice(r + 1, 0, n);
+    } else
+      e.push(n);
+  }
+  return E.insert = t, E;
+}
+var Ct;
+function it() {
+  return Ct || (Ct = 1, (function(a) {
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.Header = a.keySignatureKeys = void 0;
+    var t = $t(), e = /* @__PURE__ */ new WeakMap();
+    a.keySignatureKeys = [
+      "Cb",
+      "Gb",
+      "Db",
+      "Ab",
+      "Eb",
+      "Bb",
+      "F",
+      "C",
+      "G",
+      "D",
+      "A",
+      "E",
+      "B",
+      "F#",
+      "C#"
+    ];
+    var n = (
+      /** @class */
+      (function() {
+        function i(r) {
+          var s = this;
+          if (this.tempos = [], this.timeSignatures = [], this.keySignatures = [], this.meta = [], this.name = "", e.set(this, 480), r) {
+            e.set(this, r.header.ticksPerBeat), r.tracks.forEach(function(u) {
+              u.forEach(function(l) {
+                l.meta && (l.type === "timeSignature" ? s.timeSignatures.push({
+                  ticks: l.absoluteTime,
+                  timeSignature: [
+                    l.numerator,
+                    l.denominator
+                  ]
+                }) : l.type === "setTempo" ? s.tempos.push({
+                  bpm: 6e7 / l.microsecondsPerBeat,
+                  ticks: l.absoluteTime
+                }) : l.type === "keySignature" && s.keySignatures.push({
+                  key: a.keySignatureKeys[l.key + 7],
+                  scale: l.scale === 0 ? "major" : "minor",
+                  ticks: l.absoluteTime
+                }));
+              });
+            });
+            var c = 0;
+            r.tracks[0].forEach(function(u) {
+              c += u.deltaTime, u.meta && (u.type === "trackName" ? s.name = u.text : (u.type === "text" || u.type === "cuePoint" || u.type === "marker" || u.type === "lyrics") && s.meta.push({
+                text: u.text,
+                ticks: c,
+                type: u.type
+              }));
+            }), this.update();
+          }
+        }
+        return i.prototype.update = function() {
+          var r = this, s = 0, c = 0;
+          this.tempos.sort(function(u, l) {
+            return u.ticks - l.ticks;
+          }), this.tempos.forEach(function(u, l) {
+            var o = l > 0 ? r.tempos[l - 1].bpm : r.tempos[0].bpm, h = u.ticks / r.ppq - c, f = 60 / o * h;
+            u.time = f + s, s = u.time, c += h;
+          }), this.timeSignatures.sort(function(u, l) {
+            return u.ticks - l.ticks;
+          }), this.timeSignatures.forEach(function(u, l) {
+            var o = l > 0 ? r.timeSignatures[l - 1] : r.timeSignatures[0], h = (u.ticks - o.ticks) / r.ppq, f = h / o.timeSignature[0] / (o.timeSignature[1] / 4);
+            o.measures = o.measures || 0, u.measures = f + o.measures;
+          });
+        }, i.prototype.ticksToSeconds = function(r) {
+          var s = (0, t.search)(this.tempos, r);
+          if (s !== -1) {
+            var c = this.tempos[s], u = c.time, l = (r - c.ticks) / this.ppq;
+            return u + 60 / c.bpm * l;
+          } else {
+            var o = r / this.ppq;
+            return 60 / 120 * o;
+          }
+        }, i.prototype.ticksToMeasures = function(r) {
+          var s = (0, t.search)(this.timeSignatures, r);
+          if (s !== -1) {
+            var c = this.timeSignatures[s], u = (r - c.ticks) / this.ppq;
+            return c.measures + u / (c.timeSignature[0] / c.timeSignature[1]) / 4;
+          } else
+            return r / this.ppq / 4;
+        }, Object.defineProperty(i.prototype, "ppq", {
+          /**
+           * The number of ticks per quarter note.
+           */
+          get: function() {
+            return e.get(this);
+          },
+          enumerable: !1,
+          configurable: !0
+        }), i.prototype.secondsToTicks = function(r) {
+          var s = (0, t.search)(this.tempos, r, "time");
+          if (s !== -1) {
+            var c = this.tempos[s], u = c.time, l = r - u, o = l / (60 / c.bpm);
+            return Math.round(c.ticks + o * this.ppq);
+          } else {
+            var h = r / 0.5;
+            return Math.round(h * this.ppq);
+          }
+        }, i.prototype.toJSON = function() {
+          return {
+            keySignatures: this.keySignatures,
+            meta: this.meta,
+            name: this.name,
+            ppq: this.ppq,
+            tempos: this.tempos.map(function(r) {
+              return {
+                bpm: r.bpm,
+                ticks: r.ticks
+              };
+            }),
+            timeSignatures: this.timeSignatures
+          };
+        }, i.prototype.fromJSON = function(r) {
+          this.name = r.name, this.tempos = r.tempos.map(function(s) {
+            return Object.assign({}, s);
+          }), this.timeSignatures = r.timeSignatures.map(function(s) {
+            return Object.assign({}, s);
+          }), this.keySignatures = r.keySignatures.map(function(s) {
+            return Object.assign({}, s);
+          }), this.meta = r.meta.map(function(s) {
+            return Object.assign({}, s);
+          }), e.set(this, r.ppq), this.update();
+        }, i.prototype.setTempo = function(r) {
+          this.tempos = [
+            {
+              bpm: r,
+              ticks: 0
+            }
+          ], this.update();
+        }, i;
+      })()
+    );
+    a.Header = n;
+  })(Q)), Q;
+}
+var U = {}, Y = {}, It;
+function qt() {
+  return It || (It = 1, (function(a) {
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.ControlChange = a.controlChangeIds = a.controlChangeNames = void 0, a.controlChangeNames = {
+      1: "modulationWheel",
+      2: "breath",
+      4: "footController",
+      5: "portamentoTime",
+      7: "volume",
+      8: "balance",
+      10: "pan",
+      64: "sustain",
+      65: "portamentoTime",
+      66: "sostenuto",
+      67: "softPedal",
+      68: "legatoFootswitch",
+      84: "portamentoControl"
+    }, a.controlChangeIds = Object.keys(a.controlChangeNames).reduce(function(i, r) {
+      return i[a.controlChangeNames[r]] = r, i;
+    }, {});
+    var t = /* @__PURE__ */ new WeakMap(), e = /* @__PURE__ */ new WeakMap(), n = (
+      /** @class */
+      (function() {
+        function i(r, s) {
+          t.set(this, s), e.set(this, r.controllerType), this.ticks = r.absoluteTime, this.value = r.value;
+        }
+        return Object.defineProperty(i.prototype, "number", {
+          /**
+           * The controller number
+           */
+          get: function() {
+            return e.get(this);
+          },
+          enumerable: !1,
+          configurable: !0
+        }), Object.defineProperty(i.prototype, "name", {
+          /**
+           * return the common name of the control number if it exists
+           */
+          get: function() {
+            return a.controlChangeNames[this.number] ? a.controlChangeNames[this.number] : null;
+          },
+          enumerable: !1,
+          configurable: !0
+        }), Object.defineProperty(i.prototype, "time", {
+          /**
+           * The time of the event in seconds
+           */
+          get: function() {
+            var r = t.get(this);
+            return r.ticksToSeconds(this.ticks);
+          },
+          set: function(r) {
+            var s = t.get(this);
+            this.ticks = s.secondsToTicks(r);
+          },
+          enumerable: !1,
+          configurable: !0
+        }), i.prototype.toJSON = function() {
+          return {
+            number: this.number,
+            ticks: this.ticks,
+            time: this.time,
+            value: this.value
+          };
+        }, i;
+      })()
+    );
+    a.ControlChange = n;
+  })(Y)), Y;
+}
+var O = {}, xt;
+function _e() {
+  if (xt) return O;
+  xt = 1, Object.defineProperty(O, "__esModule", { value: !0 }), O.createControlChanges = void 0;
+  var a = qt();
+  function t() {
+    return new Proxy({}, {
+      // tslint:disable-next-line: typedef
+      get: function(e, n) {
+        if (e[n])
+          return e[n];
+        if (a.controlChangeIds.hasOwnProperty(n))
+          return e[a.controlChangeIds[n]];
+      },
+      // tslint:disable-next-line: typedef
+      set: function(e, n, i) {
+        return a.controlChangeIds.hasOwnProperty(n) ? e[a.controlChangeIds[n]] = i : e[n] = i, !0;
+      }
+    });
+  }
+  return O.createControlChanges = t, O;
+}
+var A = {}, Mt;
+function Ce() {
+  if (Mt) return A;
+  Mt = 1, Object.defineProperty(A, "__esModule", { value: !0 }), A.PitchBend = void 0;
+  var a = /* @__PURE__ */ new WeakMap(), t = (
+    /** @class */
+    (function() {
+      function e(n, i) {
+        a.set(this, i), this.ticks = n.absoluteTime, this.value = n.value;
+      }
+      return Object.defineProperty(e.prototype, "time", {
+        /**
+         * The time of the event in seconds
+         */
+        get: function() {
+          var n = a.get(this);
+          return n.ticksToSeconds(this.ticks);
+        },
+        set: function(n) {
+          var i = a.get(this);
+          this.ticks = i.secondsToTicks(n);
+        },
+        enumerable: !1,
+        configurable: !0
+      }), e.prototype.toJSON = function() {
+        return {
+          ticks: this.ticks,
+          time: this.time,
+          value: this.value
+        };
+      }, e;
+    })()
+  );
+  return A.PitchBend = t, A;
+}
+var D = {}, C = {}, Et;
+function Ie() {
+  return Et || (Et = 1, Object.defineProperty(C, "__esModule", { value: !0 }), C.DrumKitByPatchID = C.InstrumentFamilyByID = C.instrumentByPatchID = void 0, C.instrumentByPatchID = [
+    "acoustic grand piano",
+    "bright acoustic piano",
+    "electric grand piano",
+    "honky-tonk piano",
+    "electric piano 1",
+    "electric piano 2",
+    "harpsichord",
+    "clavi",
+    "celesta",
+    "glockenspiel",
+    "music box",
+    "vibraphone",
+    "marimba",
+    "xylophone",
+    "tubular bells",
+    "dulcimer",
+    "drawbar organ",
+    "percussive organ",
+    "rock organ",
+    "church organ",
+    "reed organ",
+    "accordion",
+    "harmonica",
+    "tango accordion",
+    "acoustic guitar (nylon)",
+    "acoustic guitar (steel)",
+    "electric guitar (jazz)",
+    "electric guitar (clean)",
+    "electric guitar (muted)",
+    "overdriven guitar",
+    "distortion guitar",
+    "guitar harmonics",
+    "acoustic bass",
+    "electric bass (finger)",
+    "electric bass (pick)",
+    "fretless bass",
+    "slap bass 1",
+    "slap bass 2",
+    "synth bass 1",
+    "synth bass 2",
+    "violin",
+    "viola",
+    "cello",
+    "contrabass",
+    "tremolo strings",
+    "pizzicato strings",
+    "orchestral harp",
+    "timpani",
+    "string ensemble 1",
+    "string ensemble 2",
+    "synthstrings 1",
+    "synthstrings 2",
+    "choir aahs",
+    "voice oohs",
+    "synth voice",
+    "orchestra hit",
+    "trumpet",
+    "trombone",
+    "tuba",
+    "muted trumpet",
+    "french horn",
+    "brass section",
+    "synthbrass 1",
+    "synthbrass 2",
+    "soprano sax",
+    "alto sax",
+    "tenor sax",
+    "baritone sax",
+    "oboe",
+    "english horn",
+    "bassoon",
+    "clarinet",
+    "piccolo",
+    "flute",
+    "recorder",
+    "pan flute",
+    "blown bottle",
+    "shakuhachi",
+    "whistle",
+    "ocarina",
+    "lead 1 (square)",
+    "lead 2 (sawtooth)",
+    "lead 3 (calliope)",
+    "lead 4 (chiff)",
+    "lead 5 (charang)",
+    "lead 6 (voice)",
+    "lead 7 (fifths)",
+    "lead 8 (bass + lead)",
+    "pad 1 (new age)",
+    "pad 2 (warm)",
+    "pad 3 (polysynth)",
+    "pad 4 (choir)",
+    "pad 5 (bowed)",
+    "pad 6 (metallic)",
+    "pad 7 (halo)",
+    "pad 8 (sweep)",
+    "fx 1 (rain)",
+    "fx 2 (soundtrack)",
+    "fx 3 (crystal)",
+    "fx 4 (atmosphere)",
+    "fx 5 (brightness)",
+    "fx 6 (goblins)",
+    "fx 7 (echoes)",
+    "fx 8 (sci-fi)",
+    "sitar",
+    "banjo",
+    "shamisen",
+    "koto",
+    "kalimba",
+    "bag pipe",
+    "fiddle",
+    "shanai",
+    "tinkle bell",
+    "agogo",
+    "steel drums",
+    "woodblock",
+    "taiko drum",
+    "melodic tom",
+    "synth drum",
+    "reverse cymbal",
+    "guitar fret noise",
+    "breath noise",
+    "seashore",
+    "bird tweet",
+    "telephone ring",
+    "helicopter",
+    "applause",
+    "gunshot"
+  ], C.InstrumentFamilyByID = [
+    "piano",
+    "chromatic percussion",
+    "organ",
+    "guitar",
+    "bass",
+    "strings",
+    "ensemble",
+    "brass",
+    "reed",
+    "pipe",
+    "synth lead",
+    "synth pad",
+    "synth effects",
+    "world",
+    "percussive",
+    "sound effects"
+  ], C.DrumKitByPatchID = {
+    0: "standard kit",
+    8: "room kit",
+    16: "power kit",
+    24: "electronic kit",
+    25: "tr-808 kit",
+    32: "jazz kit",
+    40: "brush kit",
+    48: "orchestra kit",
+    56: "sound fx kit"
+  }), C;
+}
+var Pt;
+function xe() {
+  if (Pt) return D;
+  Pt = 1, Object.defineProperty(D, "__esModule", { value: !0 }), D.Instrument = void 0;
+  var a = Ie(), t = /* @__PURE__ */ new WeakMap(), e = (
+    /** @class */
+    (function() {
+      function n(i, r) {
+        if (this.number = 0, t.set(this, r), this.number = 0, i) {
+          var s = i.find(function(c) {
+            return c.type === "programChange";
+          });
+          s && (this.number = s.programNumber);
+        }
+      }
+      return Object.defineProperty(n.prototype, "name", {
+        /**
+         * The common name of the instrument.
+         */
+        get: function() {
+          return this.percussion ? a.DrumKitByPatchID[this.number] : a.instrumentByPatchID[this.number];
+        },
+        set: function(i) {
+          var r = a.instrumentByPatchID.indexOf(i);
+          r !== -1 && (this.number = r);
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(n.prototype, "family", {
+        /**
+         * The instrument family, e.g. "piano".
+         */
+        get: function() {
+          return this.percussion ? "drums" : a.InstrumentFamilyByID[Math.floor(this.number / 8)];
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(n.prototype, "percussion", {
+        /**
+         * If the instrument is a percussion instrument.
+         */
+        get: function() {
+          var i = t.get(this);
+          return i.channel === 9;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), n.prototype.toJSON = function() {
+        return {
+          family: this.family,
+          number: this.number,
+          name: this.name
+        };
+      }, n.prototype.fromJSON = function(i) {
+        this.number = i.number;
+      }, n;
+    })()
+  );
+  return D.Instrument = e, D;
+}
+var B = {}, Ft;
+function Me() {
+  if (Ft) return B;
+  Ft = 1, Object.defineProperty(B, "__esModule", { value: !0 }), B.Note = void 0;
+  function a(s) {
+    var c = Math.floor(s / 12) - 1;
+    return t(s) + c.toString();
+  }
+  function t(s) {
+    var c = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], u = s % 12;
+    return c[u];
+  }
+  function e(s) {
+    var c = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+    return c.indexOf(s);
+  }
+  var n = /* @__PURE__ */ (function() {
+    var s = /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i, c = {
+      // tslint:disable-next-line: object-literal-sort-keys
+      cbb: -2,
+      cb: -1,
+      c: 0,
+      "c#": 1,
+      cx: 2,
+      dbb: 0,
+      db: 1,
+      d: 2,
+      "d#": 3,
+      dx: 4,
+      ebb: 2,
+      eb: 3,
+      e: 4,
+      "e#": 5,
+      ex: 6,
+      fbb: 3,
+      fb: 4,
+      f: 5,
+      "f#": 6,
+      fx: 7,
+      gbb: 5,
+      gb: 6,
+      g: 7,
+      "g#": 8,
+      gx: 9,
+      abb: 7,
+      ab: 8,
+      a: 9,
+      "a#": 10,
+      ax: 11,
+      bbb: 9,
+      bb: 10,
+      b: 11,
+      "b#": 12,
+      bx: 13
+    };
+    return function(u) {
+      var l = s.exec(u), o = l[1], h = l[2], f = c[o.toLowerCase()];
+      return f + (parseInt(h, 10) + 1) * 12;
+    };
+  })(), i = /* @__PURE__ */ new WeakMap(), r = (
+    /** @class */
+    (function() {
+      function s(c, u, l) {
+        i.set(this, l), this.midi = c.midi, this.velocity = c.velocity, this.noteOffVelocity = u.velocity, this.ticks = c.ticks, this.durationTicks = u.ticks - c.ticks;
+      }
+      return Object.defineProperty(s.prototype, "name", {
+        /**
+         * The note name and octave in scientific pitch notation, e.g. "C4".
+         */
+        get: function() {
+          return a(this.midi);
+        },
+        set: function(c) {
+          this.midi = n(c);
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(s.prototype, "octave", {
+        /**
+         * The notes octave number.
+         */
+        get: function() {
+          return Math.floor(this.midi / 12) - 1;
+        },
+        set: function(c) {
+          var u = c - this.octave;
+          this.midi += u * 12;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(s.prototype, "pitch", {
+        /**
+         * The pitch class name. e.g. "A".
+         */
+        get: function() {
+          return t(this.midi);
+        },
+        set: function(c) {
+          this.midi = 12 * (this.octave + 1) + e(c);
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(s.prototype, "duration", {
+        /**
+         * The duration of the segment in seconds.
+         */
+        get: function() {
+          var c = i.get(this);
+          return c.ticksToSeconds(this.ticks + this.durationTicks) - c.ticksToSeconds(this.ticks);
+        },
+        set: function(c) {
+          var u = i.get(this), l = u.secondsToTicks(this.time + c);
+          this.durationTicks = l - this.ticks;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(s.prototype, "time", {
+        /**
+         * The time of the event in seconds.
+         */
+        get: function() {
+          var c = i.get(this);
+          return c.ticksToSeconds(this.ticks);
+        },
+        set: function(c) {
+          var u = i.get(this);
+          this.ticks = u.secondsToTicks(c);
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(s.prototype, "bars", {
+        /**
+         * The number of measures (and partial measures) to this beat.
+         * Takes into account time signature changes.
+         * @readonly
+         */
+        get: function() {
+          var c = i.get(this);
+          return c.ticksToMeasures(this.ticks);
+        },
+        enumerable: !1,
+        configurable: !0
+      }), s.prototype.toJSON = function() {
+        return {
+          duration: this.duration,
+          durationTicks: this.durationTicks,
+          midi: this.midi,
+          name: this.name,
+          ticks: this.ticks,
+          time: this.time,
+          velocity: this.velocity
+        };
+      }, s;
+    })()
+  );
+  return B.Note = r, B;
+}
+var Nt;
+function Ut() {
+  if (Nt) return U;
+  Nt = 1, Object.defineProperty(U, "__esModule", { value: !0 }), U.Track = void 0;
+  var a = $t(), t = qt(), e = _e(), n = Ce(), i = xe(), r = Me(), s = /* @__PURE__ */ new WeakMap(), c = (
+    /** @class */
+    (function() {
+      function u(l, o) {
+        var h = this;
+        if (this.name = "", this.notes = [], this.controlChanges = (0, e.createControlChanges)(), this.pitchBends = [], s.set(this, o), l) {
+          var f = l.find(function(p) {
+            return p.type === "trackName";
+          });
+          this.name = f ? f.text : "";
+        }
+        if (this.instrument = new i.Instrument(l, this), this.channel = 0, l) {
+          for (var d = l.filter(function(p) {
+            return p.type === "noteOn";
+          }), g = l.filter(function(p) {
+            return p.type === "noteOff";
+          }), b = function() {
+            var p = d.shift();
+            y.channel = p.channel;
+            var S = g.findIndex(function(N) {
+              return N.noteNumber === p.noteNumber && N.absoluteTime >= p.absoluteTime;
+            });
+            if (S !== -1) {
+              var w = g.splice(S, 1)[0];
+              y.addNote({
+                durationTicks: w.absoluteTime - p.absoluteTime,
+                midi: p.noteNumber,
+                noteOffVelocity: w.velocity / 127,
+                ticks: p.absoluteTime,
+                velocity: p.velocity / 127
+              });
+            }
+          }, y = this; d.length; )
+            b();
+          var m = l.filter(function(p) {
+            return p.type === "controller";
+          });
+          m.forEach(function(p) {
+            h.addCC({
+              number: p.controllerType,
+              ticks: p.absoluteTime,
+              value: p.value / 127
+            });
+          });
+          var v = l.filter(function(p) {
+            return p.type === "pitchBend";
+          });
+          v.forEach(function(p) {
+            h.addPitchBend({
+              ticks: p.absoluteTime,
+              // Scale the value between -2^13 to 2^13 to -2 to 2.
+              value: p.value / Math.pow(2, 13)
+            });
+          });
+          var k = l.find(function(p) {
+            return p.type === "endOfTrack";
+          });
+          this.endOfTrackTicks = k !== void 0 ? k.absoluteTime : void 0;
+        }
+      }
+      return u.prototype.addNote = function(l) {
+        var o = s.get(this), h = new r.Note({
+          midi: 0,
+          ticks: 0,
+          velocity: 1
+        }, {
+          ticks: 0,
+          velocity: 0
+        }, o);
+        return Object.assign(h, l), (0, a.insert)(this.notes, h, "ticks"), this;
+      }, u.prototype.addCC = function(l) {
+        var o = s.get(this), h = new t.ControlChange({
+          controllerType: l.number
+        }, o);
+        return delete l.number, Object.assign(h, l), Array.isArray(this.controlChanges[h.number]) || (this.controlChanges[h.number] = []), (0, a.insert)(this.controlChanges[h.number], h, "ticks"), this;
+      }, u.prototype.addPitchBend = function(l) {
+        var o = s.get(this), h = new n.PitchBend({}, o);
+        return Object.assign(h, l), (0, a.insert)(this.pitchBends, h, "ticks"), this;
+      }, Object.defineProperty(u.prototype, "duration", {
+        /**
+         * The end time of the last event in the track.
+         */
+        get: function() {
+          if (!this.notes.length)
+            return 0;
+          for (var l = this.notes[this.notes.length - 1].time + this.notes[this.notes.length - 1].duration, o = 0; o < this.notes.length - 1; o++) {
+            var h = this.notes[o].time + this.notes[o].duration;
+            l < h && (l = h);
+          }
+          return l;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), Object.defineProperty(u.prototype, "durationTicks", {
+        /**
+         * The end time of the last event in the track in ticks.
+         */
+        get: function() {
+          if (!this.notes.length)
+            return 0;
+          for (var l = this.notes[this.notes.length - 1].ticks + this.notes[this.notes.length - 1].durationTicks, o = 0; o < this.notes.length - 1; o++) {
+            var h = this.notes[o].ticks + this.notes[o].durationTicks;
+            l < h && (l = h);
+          }
+          return l;
+        },
+        enumerable: !1,
+        configurable: !0
+      }), u.prototype.fromJSON = function(l) {
+        var o = this;
+        this.name = l.name, this.channel = l.channel, this.instrument = new i.Instrument(void 0, this), this.instrument.fromJSON(l.instrument), l.endOfTrackTicks !== void 0 && (this.endOfTrackTicks = l.endOfTrackTicks);
+        for (var h in l.controlChanges)
+          l.controlChanges[h] && l.controlChanges[h].forEach(function(f) {
+            o.addCC({
+              number: f.number,
+              ticks: f.ticks,
+              value: f.value
+            });
+          });
+        l.notes.forEach(function(f) {
+          o.addNote({
+            durationTicks: f.durationTicks,
+            midi: f.midi,
+            ticks: f.ticks,
+            velocity: f.velocity
+          });
+        });
+      }, u.prototype.toJSON = function() {
+        for (var l = {}, o = 0; o < 127; o++)
+          this.controlChanges.hasOwnProperty(o) && (l[o] = this.controlChanges[o].map(function(f) {
+            return f.toJSON();
+          }));
+        var h = {
+          channel: this.channel,
+          controlChanges: l,
+          pitchBends: this.pitchBends.map(function(f) {
+            return f.toJSON();
+          }),
+          instrument: this.instrument.toJSON(),
+          name: this.name,
+          notes: this.notes.map(function(f) {
+            return f.toJSON();
+          })
+        };
+        return this.endOfTrackTicks !== void 0 && (h.endOfTrackTicks = this.endOfTrackTicks), h;
+      }, u;
+    })()
+  );
+  return U.Track = c, U;
+}
+var P = {};
+function Ee(a) {
+  var t = [];
+  return zt(a, t), t;
+}
+function zt(a, t) {
+  for (var e = 0; e < a.length; e++) {
+    var n = a[e];
+    Array.isArray(n) ? zt(n, t) : t.push(n);
+  }
+}
+const Pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  flatten: Ee
+}, Symbol.toStringTag, { value: "Module" })), Fe = /* @__PURE__ */ Se(Pe);
+var Ot;
+function Ne() {
+  if (Ot) return P;
+  Ot = 1;
+  var a = P && P.__spreadArray || function(m, v, k) {
+    if (k || arguments.length === 2) for (var p = 0, S = v.length, w; p < S; p++)
+      (w || !(p in v)) && (w || (w = Array.prototype.slice.call(v, 0, p)), w[p] = v[p]);
+    return m.concat(w || Array.prototype.slice.call(v));
+  };
+  Object.defineProperty(P, "__esModule", { value: !0 }), P.encode = void 0;
+  var t = Gt(), e = it(), n = Fe;
+  function i(m, v) {
+    return [
+      {
+        absoluteTime: m.ticks,
+        channel: v,
+        deltaTime: 0,
+        noteNumber: m.midi,
+        type: "noteOn",
+        velocity: Math.floor(m.velocity * 127)
+      },
+      {
+        absoluteTime: m.ticks + m.durationTicks,
+        channel: v,
+        deltaTime: 0,
+        noteNumber: m.midi,
+        type: "noteOff",
+        velocity: Math.floor(m.noteOffVelocity * 127)
+      }
+    ];
+  }
+  function r(m) {
+    return (0, n.flatten)(m.notes.map(function(v) {
+      return i(v, m.channel);
+    }));
+  }
+  function s(m, v) {
+    return {
+      absoluteTime: m.ticks,
+      channel: v,
+      controllerType: m.number,
+      deltaTime: 0,
+      type: "controller",
+      value: Math.floor(m.value * 127)
+    };
+  }
+  function c(m) {
+    for (var v = [], k = 0; k < 127; k++)
+      m.controlChanges.hasOwnProperty(k) && m.controlChanges[k].forEach(function(p) {
+        v.push(s(p, m.channel));
+      });
+    return v;
+  }
+  function u(m, v) {
+    return {
+      absoluteTime: m.ticks,
+      channel: v,
+      deltaTime: 0,
+      type: "pitchBend",
+      value: m.value
+    };
+  }
+  function l(m) {
+    var v = [];
+    return m.pitchBends.forEach(function(k) {
+      v.push(u(k, m.channel));
+    }), v;
+  }
+  function o(m) {
+    return {
+      absoluteTime: 0,
+      channel: m.channel,
+      deltaTime: 0,
+      programNumber: m.instrument.number,
+      type: "programChange"
+    };
+  }
+  function h(m) {
+    return {
+      absoluteTime: 0,
+      deltaTime: 0,
+      meta: !0,
+      text: m,
+      type: "trackName"
+    };
+  }
+  function f(m) {
+    return {
+      absoluteTime: m.ticks,
+      deltaTime: 0,
+      meta: !0,
+      microsecondsPerBeat: Math.floor(6e7 / m.bpm),
+      type: "setTempo"
+    };
+  }
+  function d(m) {
+    return {
+      absoluteTime: m.ticks,
+      deltaTime: 0,
+      denominator: m.timeSignature[1],
+      meta: !0,
+      metronome: 24,
+      numerator: m.timeSignature[0],
+      thirtyseconds: 8,
+      type: "timeSignature"
+    };
+  }
+  function g(m) {
+    var v = e.keySignatureKeys.indexOf(m.key);
+    return {
+      absoluteTime: m.ticks,
+      deltaTime: 0,
+      key: v + 7,
+      meta: !0,
+      scale: m.scale === "major" ? 0 : 1,
+      type: "keySignature"
+    };
+  }
+  function b(m) {
+    return {
+      absoluteTime: m.ticks,
+      deltaTime: 0,
+      meta: !0,
+      text: m.text,
+      type: m.type
+    };
+  }
+  function y(m) {
+    var v = {
+      header: {
+        format: 1,
+        numTracks: m.tracks.length + 1,
+        ticksPerBeat: m.header.ppq
+      },
+      tracks: a([
+        a(a(a(a([
+          // The name data.
+          {
+            absoluteTime: 0,
+            deltaTime: 0,
+            meta: !0,
+            text: m.header.name,
+            type: "trackName"
+          }
+        ], m.header.keySignatures.map(function(k) {
+          return g(k);
+        }), !0), m.header.meta.map(function(k) {
+          return b(k);
+        }), !0), m.header.tempos.map(function(k) {
+          return f(k);
+        }), !0), m.header.timeSignatures.map(function(k) {
+          return d(k);
+        }), !0)
+      ], m.tracks.map(function(k) {
+        return a(a(a([
+          // Add the name
+          h(k.name),
+          // the instrument
+          o(k)
+        ], r(k), !0), c(k), !0), l(k), !0);
+      }), !0)
+    };
+    return v.tracks = v.tracks.map(function(k) {
+      k = k.sort(function(S, w) {
+        return S.absoluteTime - w.absoluteTime;
+      });
+      var p = 0;
+      return k.forEach(function(S) {
+        S.deltaTime = S.absoluteTime - p, p = S.absoluteTime, delete S.absoluteTime;
+      }), k.push({
+        deltaTime: 0,
+        meta: !0,
+        type: "endOfTrack"
+      }), k;
+    }), new Uint8Array((0, t.writeMidi)(v));
+  }
+  return P.encode = y, P;
+}
+var At;
+function Ue() {
+  return At || (At = 1, (function(a) {
+    var t = M && M.__awaiter || function(h, f, d, g) {
+      function b(y) {
+        return y instanceof d ? y : new d(function(m) {
+          m(y);
+        });
+      }
+      return new (d || (d = Promise))(function(y, m) {
+        function v(S) {
+          try {
+            p(g.next(S));
+          } catch (w) {
+            m(w);
+          }
+        }
+        function k(S) {
+          try {
+            p(g.throw(S));
+          } catch (w) {
+            m(w);
+          }
+        }
+        function p(S) {
+          S.done ? y(S.value) : b(S.value).then(v, k);
+        }
+        p((g = g.apply(h, f || [])).next());
+      });
+    }, e = M && M.__generator || function(h, f) {
+      var d = { label: 0, sent: function() {
+        if (y[0] & 1) throw y[1];
+        return y[1];
+      }, trys: [], ops: [] }, g, b, y, m;
+      return m = { next: v(0), throw: v(1), return: v(2) }, typeof Symbol == "function" && (m[Symbol.iterator] = function() {
+        return this;
+      }), m;
+      function v(p) {
+        return function(S) {
+          return k([p, S]);
+        };
+      }
+      function k(p) {
+        if (g) throw new TypeError("Generator is already executing.");
+        for (; d; ) try {
+          if (g = 1, b && (y = p[0] & 2 ? b.return : p[0] ? b.throw || ((y = b.return) && y.call(b), 0) : b.next) && !(y = y.call(b, p[1])).done) return y;
+          switch (b = 0, y && (p = [p[0] & 2, y.value]), p[0]) {
+            case 0:
+            case 1:
+              y = p;
+              break;
+            case 4:
+              return d.label++, { value: p[1], done: !1 };
+            case 5:
+              d.label++, b = p[1], p = [0];
+              continue;
+            case 7:
+              p = d.ops.pop(), d.trys.pop();
+              continue;
+            default:
+              if (y = d.trys, !(y = y.length > 0 && y[y.length - 1]) && (p[0] === 6 || p[0] === 2)) {
+                d = 0;
+                continue;
+              }
+              if (p[0] === 3 && (!y || p[1] > y[0] && p[1] < y[3])) {
+                d.label = p[1];
+                break;
+              }
+              if (p[0] === 6 && d.label < y[1]) {
+                d.label = y[1], y = p;
+                break;
+              }
+              if (y && d.label < y[2]) {
+                d.label = y[2], d.ops.push(p);
+                break;
+              }
+              y[2] && d.ops.pop(), d.trys.pop();
+              continue;
+          }
+          p = f.call(h, d);
+        } catch (S) {
+          p = [6, S], b = 0;
+        } finally {
+          g = y = 0;
+        }
+        if (p[0] & 5) throw p[1];
+        return { value: p[0] ? p[1] : void 0, done: !0 };
+      }
+    };
+    Object.defineProperty(a, "__esModule", { value: !0 }), a.Header = a.Track = a.Midi = void 0;
+    var n = Gt(), i = it(), r = Ut(), s = Ne(), c = (
+      /** @class */
+      (function() {
+        function h(f) {
+          var d = this, g = null;
+          if (f) {
+            var b = f instanceof ArrayBuffer ? new Uint8Array(f) : f;
+            g = (0, n.parseMidi)(b), g.tracks.forEach(function(y) {
+              var m = 0;
+              y.forEach(function(v) {
+                m += v.deltaTime, v.absoluteTime = m;
+              });
+            }), g.tracks = o(g.tracks);
+          }
+          this.header = new i.Header(g), this.tracks = [], f && (this.tracks = g.tracks.map(function(y) {
+            return new r.Track(y, d.header);
+          }), g.header.format === 1 && this.tracks[0].duration === 0 && this.tracks.shift());
+        }
+        return h.fromUrl = function(f) {
+          return t(this, void 0, void 0, function() {
+            var d, g;
+            return e(this, function(b) {
+              switch (b.label) {
+                case 0:
+                  return [4, fetch(f)];
+                case 1:
+                  return d = b.sent(), d.ok ? [4, d.arrayBuffer()] : [3, 3];
+                case 2:
+                  return g = b.sent(), [2, new h(g)];
+                case 3:
+                  throw new Error("Could not load '".concat(f, "'"));
+              }
+            });
+          });
+        }, Object.defineProperty(h.prototype, "name", {
+          /**
+           * The name of the midi file, taken from the first track.
+           */
+          get: function() {
+            return this.header.name;
+          },
+          set: function(f) {
+            this.header.name = f;
+          },
+          enumerable: !1,
+          configurable: !0
+        }), Object.defineProperty(h.prototype, "duration", {
+          /**
+           * The total length of the file in seconds.
+           */
+          get: function() {
+            var f = this.tracks.map(function(d) {
+              return d.duration;
+            });
+            return Math.max.apply(Math, f);
+          },
+          enumerable: !1,
+          configurable: !0
+        }), Object.defineProperty(h.prototype, "durationTicks", {
+          /**
+           * The total length of the file in ticks.
+           */
+          get: function() {
+            var f = this.tracks.map(function(d) {
+              return d.durationTicks;
+            });
+            return Math.max.apply(Math, f);
+          },
+          enumerable: !1,
+          configurable: !0
+        }), h.prototype.addTrack = function() {
+          var f = new r.Track(void 0, this.header);
+          return this.tracks.push(f), f;
+        }, h.prototype.toArray = function() {
+          return (0, s.encode)(this);
+        }, h.prototype.toJSON = function() {
+          return {
+            header: this.header.toJSON(),
+            tracks: this.tracks.map(function(f) {
+              return f.toJSON();
+            })
+          };
+        }, h.prototype.fromJSON = function(f) {
+          var d = this;
+          this.header = new i.Header(), this.header.fromJSON(f.header), this.tracks = f.tracks.map(function(g) {
+            var b = new r.Track(void 0, d.header);
+            return b.fromJSON(g), b;
+          });
+        }, h.prototype.clone = function() {
+          var f = new h();
+          return f.fromJSON(this.toJSON()), f;
+        }, h;
+      })()
+    );
+    a.Midi = c;
+    var u = Ut();
+    Object.defineProperty(a, "Track", { enumerable: !0, get: function() {
+      return u.Track;
+    } });
+    var l = it();
+    Object.defineProperty(a, "Header", { enumerable: !0, get: function() {
+      return l.Header;
+    } });
+    function o(h) {
+      for (var f = [], d = 0; d < h.length; d++)
+        for (var g = f.length, b = /* @__PURE__ */ new Map(), y = Array(16).fill(0), m = 0, v = h[d]; m < v.length; m++) {
+          var k = v[m], p = g, S = k.channel;
+          if (S !== void 0) {
+            k.type === "programChange" && (y[S] = k.programNumber);
+            var w = y[S], N = "".concat(w, " ").concat(S);
+            b.has(N) ? p = b.get(N) : (p = g + b.size, b.set(N, p));
+          }
+          f[p] || f.push([]), f[p].push(k);
+        }
+      return f;
+    }
+  })(M)), M;
+}
+var Oe = Ue();
+const Ae = [
+  // Piano (0-7)
+  "Acoustic Grand Piano",
+  "Bright Acoustic Piano",
+  "Electric Grand Piano",
+  "Honky-tonk Piano",
+  "Electric Piano 1",
+  "Electric Piano 2",
+  "Harpsichord",
+  "Clavinet",
+  // Chromatic Percussion (8-15)
+  "Celesta",
+  "Glockenspiel",
+  "Music Box",
+  "Vibraphone",
+  "Marimba",
+  "Xylophone",
+  "Tubular Bells",
+  "Dulcimer",
+  // Organ (16-23)
+  "Drawbar Organ",
+  "Percussive Organ",
+  "Rock Organ",
+  "Church Organ",
+  "Reed Organ",
+  "Accordion",
+  "Harmonica",
+  "Tango Accordion",
+  // Guitar (24-31)
+  "Acoustic Guitar (nylon)",
+  "Acoustic Guitar (steel)",
+  "Electric Guitar (jazz)",
+  "Electric Guitar (clean)",
+  "Electric Guitar (muted)",
+  "Overdriven Guitar",
+  "Distortion Guitar",
+  "Guitar Harmonics",
+  // Bass (32-39)
+  "Acoustic Bass",
+  "Electric Bass (finger)",
+  "Electric Bass (pick)",
+  "Fretless Bass",
+  "Slap Bass 1",
+  "Slap Bass 2",
+  "Synth Bass 1",
+  "Synth Bass 2",
+  // Strings (40-47)
+  "Violin",
+  "Viola",
+  "Cello",
+  "Contrabass",
+  "Tremolo Strings",
+  "Pizzicato Strings",
+  "Orchestral Harp",
+  "Timpani",
+  // Ensemble (48-55)
+  "String Ensemble 1",
+  "String Ensemble 2",
+  "Synth Strings 1",
+  "Synth Strings 2",
+  "Choir Aahs",
+  "Voice Oohs",
+  "Synth Voice",
+  "Orchestra Hit",
+  // Brass (56-63)
+  "Trumpet",
+  "Trombone",
+  "Tuba",
+  "Muted Trumpet",
+  "French Horn",
+  "Brass Section",
+  "Synth Brass 1",
+  "Synth Brass 2",
+  // Reed (64-71)
+  "Soprano Sax",
+  "Alto Sax",
+  "Tenor Sax",
+  "Baritone Sax",
+  "Oboe",
+  "English Horn",
+  "Bassoon",
+  "Clarinet",
+  // Pipe (72-79)
+  "Piccolo",
+  "Flute",
+  "Recorder",
+  "Pan Flute",
+  "Blown Bottle",
+  "Shakuhachi",
+  "Whistle",
+  "Ocarina",
+  // Synth Lead (80-87)
+  "Lead 1 (square)",
+  "Lead 2 (sawtooth)",
+  "Lead 3 (calliope)",
+  "Lead 4 (chiff)",
+  "Lead 5 (charang)",
+  "Lead 6 (voice)",
+  "Lead 7 (fifths)",
+  "Lead 8 (bass + lead)",
+  // Synth Pad (88-95)
+  "Pad 1 (new age)",
+  "Pad 2 (warm)",
+  "Pad 3 (polysynth)",
+  "Pad 4 (choir)",
+  "Pad 5 (bowed)",
+  "Pad 6 (metallic)",
+  "Pad 7 (halo)",
+  "Pad 8 (sweep)",
+  // Synth Effects (96-103)
+  "FX 1 (rain)",
+  "FX 2 (soundtrack)",
+  "FX 3 (crystal)",
+  "FX 4 (atmosphere)",
+  "FX 5 (brightness)",
+  "FX 6 (goblins)",
+  "FX 7 (echoes)",
+  "FX 8 (sci-fi)",
+  // Ethnic (104-111)
+  "Sitar",
+  "Banjo",
+  "Shamisen",
+  "Koto",
+  "Kalimba",
+  "Bagpipe",
+  "Fiddle",
+  "Shanai",
+  // Percussive (112-119)
+  "Tinkle Bell",
+  "Agogo",
+  "Steel Drums",
+  "Woodblock",
+  "Taiko Drum",
+  "Melodic Tom",
+  "Synth Drum",
+  "Reverse Cymbal",
+  // Sound Effects (120-127)
+  "Guitar Fret Noise",
+  "Breath Noise",
+  "Seashore",
+  "Bird Tweet",
+  "Telephone Ring",
+  "Helicopter",
+  "Applause",
+  "Gunshot"
+];
+function Dt(a) {
+  return Ae[a] ?? `Program ${a}`;
+}
+function De(a, t = {}) {
+  const { flatten: e = !1 } = t, n = new Oe.Midi(a), i = n.header.tempos[0]?.bpm ?? 120, r = n.header.timeSignatures[0], s = r ? [r.timeSignature[0], r.timeSignature[1]] : [4, 4], c = n.name || "Untitled", u = /* @__PURE__ */ new Map();
+  for (const h of n.tracks) {
+    const f = h.channel, d = h.instrument.number, g = h.name || Dt(d);
+    u.has(f) || u.set(f, { notes: [], programNumber: d, name: g });
+    const b = u.get(f);
+    h.name && !b.name.startsWith(h.name) && (b.name = h.name);
+    for (const y of h.notes)
+      b.notes.push({
+        midi: y.midi,
+        name: y.name,
+        time: y.time,
+        duration: y.duration,
+        velocity: y.velocity,
+        channel: f
+      });
+  }
+  let l = 0;
+  if (u.forEach(({ notes: h }) => {
+    for (const f of h) {
+      const d = f.time + f.duration;
+      d > l && (l = d);
+    }
+  }), e) {
+    const h = [];
+    return u.forEach(({ notes: f }) => {
+      h.push(...f);
+    }), h.sort((f, d) => f.time - d.time), {
+      tracks: [{
+        name: c,
+        notes: h,
+        duration: l,
+        channel: 0,
+        instrument: "Mixed",
+        programNumber: 0
+      }],
+      duration: l,
+      name: c,
+      bpm: i,
+      timeSignature: s
+    };
+  }
+  const o = [];
+  return u.forEach(({ notes: h, programNumber: f, name: d }, g) => {
+    if (h.length === 0) return;
+    h.sort((y, m) => y.time - m.time);
+    let b = 0;
+    for (const y of h) {
+      const m = y.time + y.duration;
+      m > b && (b = m);
+    }
+    o.push({
+      name: d,
+      notes: h,
+      duration: b,
+      channel: g,
+      instrument: g === 9 ? "Percussion" : Dt(f),
+      programNumber: f
+    });
+  }), {
+    tracks: o,
+    duration: l,
+    name: c,
+    bpm: i,
+    timeSignature: s
+  };
+}
+async function Er(a, t = {}, e) {
+  const n = await fetch(a, { signal: e });
+  if (!n.ok)
+    throw new Error(`Failed to fetch MIDI file: ${n.status} ${n.statusText}`);
+  const i = await n.arrayBuffer();
+  return De(i, t);
+}
+function Pr(a) {
+  const t = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], e = Math.floor(a / 12) - 1;
+  return `${t[a % 12]}${e}`;
+}
+function Fr(a) {
+  const t = a.match(/^([A-Ga-g])([#b]?)(-?\d+)$/);
+  if (!t) throw new Error(`Invalid note name: ${a}`);
+  const [, e, n, i] = t;
+  let s = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 }[e.toUpperCase()];
+  return n === "#" && (s += 1), n === "b" && (s -= 1), (parseInt(i, 10) + 1) * 12 + s;
+}
+const Nr = {
+  NOTE_OFF: 8,
+  NOTE_ON: 9,
+  POLY_AFTERTOUCH: 10,
+  CONTROL_CHANGE: 11,
+  PROGRAM_CHANGE: 12,
+  CHANNEL_AFTERTOUCH: 13,
+  PITCH_BEND: 14
+}, Ur = {
+  MODULATION: 1,
+  BREATH: 2,
+  VOLUME: 7,
+  PAN: 10,
+  EXPRESSION: 11,
+  SUSTAIN: 64,
+  PORTAMENTO: 65,
+  SOSTENUTO: 66,
+  SOFT_PEDAL: 67,
+  ALL_SOUND_OFF: 120,
+  RESET_ALL: 121,
+  ALL_NOTES_OFF: 123
+};
+function Be(a, t) {
+  const e = a[0], n = e >> 4 & 15, i = e & 15;
+  return {
+    command: n,
+    channel: i,
+    data1: a[1] ?? 0,
+    data2: a[2] ?? 0,
+    raw: a,
+    timestamp: t
+  };
+}
+function Ve() {
+  return typeof navigator < "u" && "requestMIDIAccess" in navigator;
+}
+async function Le(a = !1) {
+  if (!Ve())
+    return console.warn("[MIDI] Web MIDI API not supported in this browser"), null;
+  try {
+    return await navigator.requestMIDIAccess({ sysex: a });
+  } catch (t) {
+    return console.error("[MIDI] Failed to request MIDI access:", t), null;
+  }
+}
+function Re(a) {
+  const t = [];
+  return a.inputs.forEach((e) => {
+    t.push({
+      id: e.id,
+      name: e.name || "Unknown Device",
+      manufacturer: e.manufacturer || "Unknown",
+      state: e.state
+    });
+  }), t;
+}
+function Ge(a) {
+  const t = [];
+  return a.outputs.forEach((e) => {
+    t.push({
+      id: e.id,
+      name: e.name || "Unknown Device",
+      manufacturer: e.manufacturer || "Unknown",
+      state: e.state
+    });
+  }), t;
+}
+class Or {
+  constructor() {
+    this.access = null, this.activeInputId = null, this.messageCallbacks = /* @__PURE__ */ new Set(), this.stateChangeCallbacks = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Initialize MIDI access
+   */
+  async init(t = !1) {
+    return this.access = await Le(t), this.access ? (this.access.onstatechange = () => {
+      this.stateChangeCallbacks.forEach((e) => e());
+    }, !0) : !1;
+  }
+  /**
+   * Check if initialized
+   */
+  get isInitialized() {
+    return this.access !== null;
+  }
+  /**
+   * Get available input devices
+   */
+  getInputs() {
+    return this.access ? Re(this.access) : [];
+  }
+  /**
+   * Get available output devices
+   */
+  getOutputs() {
+    return this.access ? Ge(this.access) : [];
+  }
+  /**
+   * Connect to a specific MIDI input
+   */
+  connectInput(t) {
+    if (!this.access) return !1;
+    this.disconnectInput();
+    const e = this.access.inputs.get(t);
+    return e ? (this.activeInputId = t, e.onmidimessage = (n) => {
+      if (!n.data) return;
+      const i = Be(n.data, n.timeStamp);
+      this.messageCallbacks.forEach((r) => r(i));
+    }, console.log(`[MIDI] Connected to input: ${e.name}`), !0) : (console.warn(`[MIDI] Input device not found: ${t}`), !1);
+  }
+  /**
+   * Connect to the first available MIDI input
+   */
+  connectFirstInput() {
+    const t = this.getInputs();
+    return t.length === 0 ? !1 : this.connectInput(t[0].id);
+  }
+  /**
+   * Disconnect from current MIDI input
+   */
+  disconnectInput() {
+    if (!this.access || !this.activeInputId) return;
+    const t = this.access.inputs.get(this.activeInputId);
+    t && (t.onmidimessage = null), this.activeInputId = null;
+  }
+  /**
+   * Get the currently connected input ID
+   */
+  get connectedInputId() {
+    return this.activeInputId;
+  }
+  /**
+   * Subscribe to MIDI messages
+   */
+  onMessage(t) {
+    return this.messageCallbacks.add(t), () => this.messageCallbacks.delete(t);
+  }
+  /**
+   * Subscribe to device state changes (connect/disconnect)
+   */
+  onStateChange(t) {
+    return this.stateChangeCallbacks.add(t), () => this.stateChangeCallbacks.delete(t);
+  }
+  /**
+   * Send MIDI message to an output device
+   */
+  sendMessage(t, e) {
+    if (!this.access) return !1;
+    const n = this.access.outputs.get(t);
+    return n ? (n.send(e), !0) : !1;
+  }
+  /**
+   * Clean up resources
+   */
+  dispose() {
+    this.disconnectInput(), this.messageCallbacks.clear(), this.stateChangeCallbacks.clear(), this.access = null;
+  }
+}
+function Ar(a, t, e) {
+  return [144 | a & 15, t & 127, e & 127];
+}
+function Dr(a, t, e = 0) {
+  return [128 | a & 15, t & 127, e & 127];
+}
+function Br(a, t, e) {
+  return [176 | a & 15, t & 127, e & 127];
+}
+class $e {
+  constructor() {
+    this.emitter = new Ht();
+  }
+  on(t, e) {
+    this.emitter.on(String(t), e);
+  }
+  off(t, e) {
+    this.emitter.off(String(t), e);
+  }
+  once(t, e) {
+    this.emitter.once(String(t), e);
+  }
+  emit(t, ...e) {
+    this.emitter.emit(String(t), ...e);
+  }
+  removeAllListeners() {
+    this.emitter.removeAllListeners();
+  }
+}
+class qe {
+  constructor(t) {
+    this.plugins = /* @__PURE__ */ new Map(), this.disposers = /* @__PURE__ */ new Map(), this.context = t;
+  }
+  getAll() {
+    return [...this.plugins.values()];
+  }
+  async register(t) {
+    if (this.plugins.has(t.id))
+      throw new Error(`Songram engine plugin "${t.id}" is already registered.`);
+    if (this.plugins.set(t.id, t), t.setup) {
+      const e = await t.setup(this.context);
+      typeof e == "function" && this.disposers.set(t.id, e);
+    }
+    this.context.events.emit("plugins:registered", t.id);
+  }
+  async unregister(t) {
+    const e = this.disposers.get(t);
+    e && (await e(), this.disposers.delete(t)), this.plugins.delete(t) && this.context.events.emit("plugins:unregistered", t);
+  }
+  async dispose() {
+    const t = [...this.plugins.keys()];
+    for (const e of t)
+      await this.unregister(e);
+  }
+}
+class ze {
+  constructor(t = {}) {
+    this.events = new $e(), this.plugins = new qe({
+      events: this.events,
+      requestAssistant: (c, u, l) => {
+        this.events.emit("assistant:request", { assistantId: c, action: u, payload: l });
+      }
+    }), this.transport = {
+      play: (c, u) => this.playlist.play(c, u),
+      pause: () => this.playlist.pause(),
+      stop: () => this.playlist.stop(),
+      seek: (c) => {
+        this.playlist.seek(c), this.events.emit("transport:seek", c);
+      },
+      getCurrentTime: () => this.playlist.getCurrentTime()
+    }, this.tracks = {
+      set: (c) => {
+        this.playlist.setTracks(c), this.events.emit(
+          "tracks:set",
+          c.map((u) => u.id)
+        );
+      },
+      add: (c) => {
+        this.playlist.addTrack(c), this.events.emit("tracks:add", c.id);
+      },
+      remove: (c) => {
+        this.playlist.removeTrack(c), this.events.emit("tracks:remove", c);
+      },
+      select: (c) => this.playlist.selectTrack(c)
+    }, this.state = {
+      getSnapshot: () => this.playlist.getState()
+    }, this.handleStateChange = (c) => {
+      this.events.emit("statechange", c);
+    }, this.handleTimeUpdate = (c) => {
+      this.events.emit("timeupdate", c);
+    }, this.handlePlay = () => {
+      this.events.emit("play");
+    }, this.handlePause = () => {
+      this.events.emit("pause");
+    }, this.handleStop = () => {
+      this.events.emit("stop");
+    };
+    const { adapter: e, audio: n, plugins: i = [], ...r } = t, s = e ?? ke(n);
+    this.playlist = new ce({
+      ...r,
+      adapter: s
+    }), this.initialPlugins = i, this.playlist.on("statechange", this.handleStateChange), this.playlist.on("timeupdate", this.handleTimeUpdate), this.playlist.on("play", this.handlePlay), this.playlist.on("pause", this.handlePause), this.playlist.on("stop", this.handleStop);
+  }
+  async init() {
+    await this.playlist.init();
+    for (const t of this.initialPlugins)
+      await this.plugins.register(t);
+    this.events.emit("ready");
+  }
+  async registerPlugin(t) {
+    await this.plugins.register(t);
+  }
+  async unregisterPlugin(t) {
+    await this.plugins.unregister(t);
+  }
+  async dispose() {
+    this.playlist.off("statechange", this.handleStateChange), this.playlist.off("timeupdate", this.handleTimeUpdate), this.playlist.off("play", this.handlePlay), this.playlist.off("pause", this.handlePause), this.playlist.off("stop", this.handleStop), this.playlist.dispose(), await this.plugins.dispose(), this.events.emit("dispose"), this.events.removeAllListeners();
+  }
+}
+function Vr(a = {}) {
+  return new ze(a);
+}
+export {
+  $e as EventBus,
+  Zt as InteractionState,
+  Je as MAX_CANVAS_WIDTH,
+  Ur as MIDI_CC,
+  Nr as MIDI_COMMANDS,
+  Or as MidiController,
+  me as MidiToneTrack,
+  R as PPQN,
+  ce as PlaylistEngine,
+  qe as PluginHost,
+  ze as SongramEngine,
+  kr as SoundFontCache,
+  nt as SoundFontToneTrack,
+  pe as TonePlayout,
+  de as ToneTrack,
+  bt as applyFadeIn,
+  kt as applyFadeOut,
+  K as calculateDuration,
+  ve as calculatePlaybackRate,
+  pr as calculateSplitPoint,
+  gr as calculateViewportBounds,
+  br as calculateZoomScrollPosition,
+  ne as canSplitAt,
+  pt as clampSeekPosition,
+  mt as clipDurationTime,
+  dt as clipEndTime,
+  ft as clipOffsetTime,
+  mr as clipPixelWidth,
+  q as clipStartTime,
+  tr as clipsOverlap,
+  Cr as closeGlobalAudioContext,
+  ee as constrainBoundaryTrim,
+  te as constrainClipDrag,
+  et as createClip,
+  Ke as createClipFromSeconds,
+  Br as createControlChange,
+  Dr as createNoteOff,
+  Ar as createNoteOn,
+  Vr as createSongramEngine,
+  Ze as createTimeline,
+  ke as createToneAdapter,
+  Xe as createTrack,
+  Yt as dBToNormalized,
+  be as extractLoopAndEnvelope,
+  ae as findClosestZoomIndex,
+  er as findGaps,
+  fr as gainToNormalized,
+  Ye as getClipsAtSample,
+  Qe as getClipsInRange,
+  _ as getGeneratorValue,
+  Sr as getGlobalAudioContext,
+  _r as getGlobalAudioContextState,
+  ut as getGlobalContext,
+  wr as getGlobalToneContext,
+  Dt as getInstrumentName,
+  Ir as getMediaStreamSource,
+  Re as getMidiInputs,
+  Ge as getMidiOutputs,
+  ct as getUnderlyingAudioParam,
+  yr as getVisibleChunkIndices,
+  Mr as hasMediaStreamSource,
+  ye as int16ToFloat32,
+  Ve as isWebMidiSupported,
+  Pr as midiNoteToName,
+  dr as normalizedToDb,
+  Fr as noteNameToMidi,
+  De as parseMidiFile,
+  Be as parseMidiMessage,
+  Er as parseMidiUrl,
+  ir as pixelsToSamples,
+  sr as pixelsToSeconds,
+  xr as releaseMediaStreamSource,
+  Le as requestMidiAccess,
+  Tr as resumeGlobalAudioContext,
+  ar as samplesToPixels,
+  rr as samplesToSeconds,
+  ur as samplesToTicks,
+  or as secondsToPixels,
+  nr as secondsToSamples,
+  vr as shouldUpdateViewport,
+  lr as snapToGrid,
+  rt as sortClipsByTime,
+  re as splitClip,
+  Qt as ticksPerBar,
+  Lt as ticksPerBeat,
+  hr as ticksToBarBeatLabel,
+  cr as ticksToSamples,
+  z as timecentsToSeconds
+};
+//# sourceMappingURL=index.js.map