@modernized/osmd-audio-player 1.0.1

package/.circleci/config.yml

@@ -0,0 +1,18 @@
+version: 2.1
+orbs:
+  node: circleci/node@1.1.6
+jobs:
+  build-and-test:
+    executor:
+      name: node/default
+    steps:
+      - checkout
+      - node/with-cache:
+          steps:
+            - run: npm install
+            - run: npm test
+            - run: npm run build
+workflows:
+    build-and-test:
+      jobs:
+        - build-and-test

package/.gitattributes

@@ -0,0 +1,12 @@
+# Auto detect text files and ensure LF line endings
+* text=auto eol=lf
+
+# Explicitly declare text files
+*.ts text eol=lf
+*.js text eol=lf
+*.json text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+*.md text eol=lf
+*.html text eol=lf
+*.css text eol=lf

package/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build-and-test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: yarn
+      - run: yarn install --frozen-lockfile
+      - run: yarn test
+      - run: yarn build

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "printWidth": 100,
+  "trailingComma": "all"
+}

package/.prettierrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  printWidth: 120,
+  arrowParens: "avoid",
+};

package/CLAUDE.md

@@ -0,0 +1,96 @@
+# osmd-audio-player
+
+OpenSheetMusicDisplay (OSMD) 用の非公式オーディオ再生エンジン。MusicXML楽譜の視覚表示とWeb Audio APIによる音声再生を同期する。
+
+- **作者:** Jimmy Utterström
+- **ライセンス:** MIT
+- **バージョン:** 0.7.0（開発終了・メンテナンスモード）
+- **リポジトリ:** https://github.com/modernized-js/osmd-audio-player（[jimutt/osmd-audio-player](https://github.com/jimutt/osmd-audio-player) のfork）
+
+## 主な機能
+
+- フレームワーク非依存（Vanilla JS / React / Vue で利用可能）
+- マルチ楽器対応（91種類のMIDI楽器、Musyngkiteサウンドフォント）
+- 楽器ごとの音量制御
+- MusicXMLからのテンポ自動検出・BPM変更
+- スタッカートアーティキュレーション / タイ（リガチャー）処理
+- 再生位置ジャンプ（seek）
+- イベント駆動アーキテクチャ（STATE_CHANGE / ITERATION）
+
+## アーキテクチャ
+
+```
+MusicXML → OSMD → PlaybackEngine → PlaybackScheduler → SoundfontPlayer → Web Audio API
+```
+
+### コアモジュール
+
+| ファイル | 役割 |
+|---------|------|
+| `src/PlaybackEngine.ts` | メインオーケストレーター。楽譜読込・状態管理・カーソル同期・イベント発行 |
+| `src/PlaybackScheduler.ts` | 音声タイミング制御。1024tick/全音符の精度、500msルックアヘッドスケジューリング |
+| `src/players/SoundfontPlayer.ts` | soundfont-playerによる楽器音合成 |
+| `src/players/InstrumentPlayer.ts` | 楽器プレイヤーのインターフェース定義 |
+| `src/internals/StepQueue.ts` | ノートスケジューリングキュー |
+| `src/internals/EventEmitter.ts` | 汎用イベントシステム |
+| `src/internals/noteHelpers.ts` | ノートメタデータ抽出ユーティリティ |
+| `src/midi/midiInstruments.ts` | 128種MIDI楽器マッピング |
+| `src/players/musyngkiteInstruments.ts` | サポート楽器フィルタリスト |
+
+### 再生状態遷移
+
+```
+INIT → STOPPED → PLAYING ⇄ PAUSED
+                    ↓
+                 STOPPED
+```
+
+## 技術スタック
+
+### ランタイム依存
+
+- `opensheetmusicdisplay` ^0.8.4 — MusicXMLパーサ・楽譜レンダラ
+- `soundfont-player` ^0.12.0 — サウンドフォント再生
+- `standardized-audio-context` ^24.1.25 — Web Audio API抽象化
+
+### 開発依存
+
+- TypeScript ^3.7.5
+- Jest ^26.0.1 + ts-mockito（テスト）
+- Babel（トランスパイル）
+- Rollup（UMDバンドル）
+
+## ビルド・開発コマンド
+
+```bash
+yarn dev          # TypeScript watchモード
+yarn test         # Jestテスト実行
+yarn build        # dist/ へコンパイル（CommonJS）
+yarn build-umd    # umd/OsmdAudioPlayer.min.js 生成
+yarn build-all    # 全ビルド（lib + UMD + demos）
+```
+
+## 出力
+
+- **CommonJS:** `dist/index.js` + `dist/index.d.ts`
+- **UMD:** `umd/OsmdAudioPlayer.min.js`（グローバル変数 `OsmdAudioPlayer`）
+
+## デモアプリ
+
+| ディレクトリ | フレームワーク | 内容 |
+|------------|-------------|------|
+| `demos/basic/` | Vanilla JS | 最小構成の参照実装 |
+| `demos/vue-player-demo/` | Vue 2 + Vuetify | フル機能UI（テンポ・音量・楽器選択） |
+| `demos/react-demo/` | React | React統合例 |
+| `demos/umd-web/` | Plain HTML | Node.js不要のUMDビルド例 |
+
+## テスト
+
+- Jest + babel-jest + ts-mockito
+- テストファイル: `src/internals/EventEmitter.test.ts`, `src/internals/PlaybackEngine.test.ts`
+- カバー範囲: 状態遷移イベント、EventEmitter基本動作
+
+## CI
+
+- GitHub Actions（テスト → ビルド、ubuntu/windows/macos）
+- Netlifyデプロイ（デモサイト）

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Jimmy Utterström
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# @modernized/osmd-audio-player
+
+> **Fork of [osmd-audio-player](https://github.com/jimutt/osmd-audio-player)** by Jimmy Utterström.
+> Modernized build system, updated dependencies, and stricter TypeScript typing.
+
+Unofficial audio playback engine for [OpenSheetMusicDisplay](https://github.com/opensheetmusicdisplay/opensheetmusicdisplay).
+
+## Changes from upstream
+
+- Migrated from npm/Babel/Jest to yarn/Vitest
+- Upgraded TypeScript 3.7 to 5.x
+- Upgraded opensheetmusicdisplay 0.8 to 1.9
+- Added ESLint + Prettier
+- Removed all `any` types
+- GitHub Actions CI (ubuntu/windows/macos)
+
+## Install
+
+```
+yarn add @modernized/osmd-audio-player
+```
+
+## Usage
+
+```typescript
+import { OpenSheetMusicDisplay } from "opensheetmusicdisplay";
+import AudioPlayer from "@modernized/osmd-audio-player";
+
+const osmd = new OpenSheetMusicDisplay(document.getElementById("score"));
+const audioPlayer = new AudioPlayer();
+
+await osmd.load(scoreXml);
+await osmd.render();
+await audioPlayer.loadScore(osmd);
+
+audioPlayer.play();
+```
+
+## Features
+
+- Framework agnostic (Vanilla JS / React / Vue)
+- Multi-instrument support (91 MIDI instruments via Musyngkite soundfont)
+- Individual volume controls per instrument
+- Automatic tempo detection from score / BPM control
+- Staccato articulation / tie handling
+- Seek (jump to step)
+- Event-driven architecture (STATE_CHANGE / ITERATION)
+
+## API
+
+```typescript
+const audioPlayer = new AudioPlayer();
+
+await audioPlayer.loadScore(osmd);   // Load score from OSMD instance
+await audioPlayer.play();            // Start playback
+audioPlayer.pause();                 // Pause playback
+await audioPlayer.stop();            // Stop and reset to beginning
+audioPlayer.jumpToStep(step);        // Seek to specific step
+audioPlayer.setBpm(120);             // Set tempo
+
+audioPlayer.on("state-change", (state) => { /* INIT | PLAYING | STOPPED | PAUSED */ });
+audioPlayer.on("iteration", (notes) => { /* Called for each note group */ });
+```
+
+## Development
+
+```bash
+yarn install
+yarn dev          # TypeScript watch mode
+yarn test         # Run tests (Vitest)
+yarn build        # Compile to dist/
+yarn build-umd    # UMD bundle
+yarn lint         # ESLint
+yarn format       # Prettier
+```
+
+## License
+
+MIT - Original work by [Jimmy Utterström](https://github.com/jimutt/osmd-audio-player)

package/dist/PlaybackEngine.d.ts

@@ -0,0 +1,55 @@
+import { OpenSheetMusicDisplay, Instrument, Voice } from "opensheetmusicdisplay";
+import { InstrumentPlayer, PlaybackInstrument } from "./players/InstrumentPlayer";
+import { IAudioContext } from "standardized-audio-context";
+export declare enum PlaybackState {
+    INIT = "INIT",
+    PLAYING = "PLAYING",
+    STOPPED = "STOPPED",
+    PAUSED = "PAUSED"
+}
+export declare enum PlaybackEvent {
+    STATE_CHANGE = "state-change",
+    ITERATION = "iteration"
+}
+interface PlaybackSettings {
+    bpm: number;
+    masterVolume: number;
+}
+export default class PlaybackEngine {
+    private ac;
+    private defaultBpm;
+    private cursor;
+    private sheet;
+    private scheduler;
+    private instrumentPlayer;
+    private events;
+    private iterationSteps;
+    private currentIterationStep;
+    private timeoutHandles;
+    playbackSettings: PlaybackSettings;
+    state: PlaybackState;
+    availableInstruments: PlaybackInstrument[];
+    scoreInstruments: Instrument[];
+    ready: boolean;
+    constructor(context?: IAudioContext, instrumentPlayer?: InstrumentPlayer);
+    get wholeNoteLength(): number;
+    getPlaybackInstrument(voiceId: number): PlaybackInstrument;
+    setInstrument(voice: Voice, midiInstrumentId: number): Promise<void>;
+    loadScore(osmd: OpenSheetMusicDisplay): Promise<void>;
+    private initInstruments;
+    private loadInstruments;
+    private fallbackToPiano;
+    play(): Promise<void>;
+    stop(): Promise<void>;
+    pause(): void;
+    jumpToStep(step: number): void;
+    setBpm(bpm: number): void;
+    on(event: PlaybackEvent, cb: (...args: unknown[]) => void): void;
+    private countAndSetIterationSteps;
+    private notePlaybackCallback;
+    private setState;
+    private stopPlayers;
+    private clearTimeouts;
+    private iterationCallback;
+}
+export {};

package/dist/PlaybackEngine.js

@@ -0,0 +1,211 @@
+import PlaybackScheduler from "./PlaybackScheduler";
+import { SoundfontPlayer } from "./players/SoundfontPlayer";
+import { getNoteDuration, getNoteVolume, getNoteArticulationStyle } from "./internals/noteHelpers";
+import { EventEmitter } from "./internals/EventEmitter";
+import { AudioContext } from "standardized-audio-context";
+export var PlaybackState;
+(function (PlaybackState) {
+    PlaybackState["INIT"] = "INIT";
+    PlaybackState["PLAYING"] = "PLAYING";
+    PlaybackState["STOPPED"] = "STOPPED";
+    PlaybackState["PAUSED"] = "PAUSED";
+})(PlaybackState || (PlaybackState = {}));
+export var PlaybackEvent;
+(function (PlaybackEvent) {
+    PlaybackEvent["STATE_CHANGE"] = "state-change";
+    PlaybackEvent["ITERATION"] = "iteration";
+})(PlaybackEvent || (PlaybackEvent = {}));
+export default class PlaybackEngine {
+    constructor(context = new AudioContext(), instrumentPlayer = new SoundfontPlayer()) {
+        this.defaultBpm = 100;
+        this.scoreInstruments = [];
+        this.ready = false;
+        this.ac = context;
+        this.ac.suspend();
+        this.instrumentPlayer = instrumentPlayer;
+        this.instrumentPlayer.init(this.ac);
+        this.availableInstruments = this.instrumentPlayer.instruments;
+        this.events = new EventEmitter();
+        this.cursor = null;
+        this.sheet = null;
+        this.scheduler = null;
+        this.iterationSteps = 0;
+        this.currentIterationStep = 0;
+        this.timeoutHandles = [];
+        this.playbackSettings = {
+            bpm: this.defaultBpm,
+            masterVolume: 1,
+        };
+        this.setState(PlaybackState.INIT);
+    }
+    get wholeNoteLength() {
+        return Math.round((60 / this.playbackSettings.bpm) * 4000);
+    }
+    getPlaybackInstrument(voiceId) {
+        if (!this.sheet)
+            return null;
+        const voice = this.sheet.Instruments.flatMap((i) => i.Voices).find((v) => v.VoiceId === voiceId);
+        return this.availableInstruments.find((i) => i.midiId === voice.midiInstrumentId);
+    }
+    async setInstrument(voice, midiInstrumentId) {
+        await this.instrumentPlayer.load(midiInstrumentId);
+        voice.midiInstrumentId = midiInstrumentId;
+    }
+    async loadScore(osmd) {
+        this.ready = false;
+        this.sheet = osmd.Sheet;
+        this.scoreInstruments = this.sheet.Instruments;
+        this.cursor = osmd.cursor;
+        if (this.sheet.HasBPMInfo) {
+            this.setBpm(this.sheet.DefaultStartTempoInBpm);
+        }
+        await this.loadInstruments();
+        this.initInstruments();
+        this.scheduler = new PlaybackScheduler(this.wholeNoteLength, this.ac, (delay, notes) => this.notePlaybackCallback(delay, notes));
+        this.countAndSetIterationSteps();
+        this.ready = true;
+        this.setState(PlaybackState.STOPPED);
+    }
+    initInstruments() {
+        for (const i of this.sheet.Instruments) {
+            for (const v of i.Voices) {
+                v.midiInstrumentId = i.MidiInstrumentId;
+            }
+        }
+    }
+    async loadInstruments() {
+        const playerPromises = [];
+        for (const i of this.sheet.Instruments) {
+            const pbInstrument = this.availableInstruments.find((pbi) => pbi.midiId === i.MidiInstrumentId);
+            if (pbInstrument == null) {
+                this.fallbackToPiano(i);
+            }
+            playerPromises.push(this.instrumentPlayer.load(i.MidiInstrumentId));
+        }
+        await Promise.all(playerPromises);
+    }
+    fallbackToPiano(i) {
+        console.warn(`Can't find playback instrument for midiInstrumentId ${i.MidiInstrumentId}. Falling back to piano`);
+        i.MidiInstrumentId = 0;
+        if (this.availableInstruments.find((i) => i.midiId === 0) == null) {
+            throw new Error("Piano fallback failed, grand piano not supported");
+        }
+    }
+    async play() {
+        await this.ac.resume();
+        if (this.state === PlaybackState.INIT || this.state === PlaybackState.STOPPED) {
+            this.cursor.show();
+        }
+        this.setState(PlaybackState.PLAYING);
+        this.scheduler.start();
+    }
+    async stop() {
+        this.setState(PlaybackState.STOPPED);
+        this.stopPlayers();
+        this.clearTimeouts();
+        this.scheduler.reset();
+        this.cursor.reset();
+        this.currentIterationStep = 0;
+        this.cursor.hide();
+    }
+    pause() {
+        this.setState(PlaybackState.PAUSED);
+        this.ac.suspend();
+        this.stopPlayers();
+        this.scheduler.setIterationStep(this.currentIterationStep);
+        this.scheduler.pause();
+        this.clearTimeouts();
+    }
+    jumpToStep(step) {
+        this.pause();
+        if (this.currentIterationStep > step) {
+            this.cursor.reset();
+            this.currentIterationStep = 0;
+        }
+        while (this.currentIterationStep < step) {
+            this.cursor.next();
+            ++this.currentIterationStep;
+        }
+        let schedulerStep = this.currentIterationStep;
+        if (this.currentIterationStep > 0 && this.currentIterationStep < this.iterationSteps)
+            ++schedulerStep;
+        this.scheduler.setIterationStep(schedulerStep);
+    }
+    setBpm(bpm) {
+        this.playbackSettings.bpm = bpm;
+        if (this.scheduler)
+            this.scheduler.wholeNoteLength = this.wholeNoteLength;
+    }
+    on(event, cb) {
+        this.events.on(event, cb);
+    }
+    countAndSetIterationSteps() {
+        this.cursor.reset();
+        let steps = 0;
+        while (!this.cursor.Iterator.EndReached) {
+            if (this.cursor.Iterator.CurrentVoiceEntries) {
+                this.scheduler.loadNotes(this.cursor.Iterator.CurrentVoiceEntries);
+            }
+            this.cursor.next();
+            ++steps;
+        }
+        this.iterationSteps = steps;
+        this.cursor.reset();
+    }
+    notePlaybackCallback(audioDelay, notes) {
+        if (this.state !== PlaybackState.PLAYING)
+            return;
+        const scheduledNotes = new Map();
+        for (const note of notes) {
+            if (note.isRest()) {
+                continue;
+            }
+            const noteDuration = getNoteDuration(note, this.wholeNoteLength);
+            if (noteDuration === 0)
+                continue;
+            const noteVolume = getNoteVolume(note);
+            const noteArticulation = getNoteArticulationStyle(note);
+            const midiPlaybackInstrument = note.ParentVoiceEntry.ParentVoice.midiInstrumentId;
+            const fixedKey = note.ParentVoiceEntry.ParentVoice.Parent.SubInstruments[0].fixedKey || 0;
+            if (!scheduledNotes.has(midiPlaybackInstrument)) {
+                scheduledNotes.set(midiPlaybackInstrument, []);
+            }
+            scheduledNotes.get(midiPlaybackInstrument).push({
+                note: note.halfTone - fixedKey * 12,
+                duration: noteDuration / 1000,
+                gain: noteVolume,
+                articulation: noteArticulation,
+            });
+        }
+        for (const [midiId, notes] of scheduledNotes) {
+            this.instrumentPlayer.schedule(midiId, this.ac.currentTime + audioDelay, notes);
+        }
+        this.timeoutHandles.push(window.setTimeout(() => this.iterationCallback(), Math.max(0, audioDelay * 1000 - 35)), // Subtracting 35 milliseconds to compensate for update delay
+        window.setTimeout(() => this.events.emit(PlaybackEvent.ITERATION, notes), audioDelay * 1000));
+    }
+    setState(state) {
+        this.state = state;
+        this.events.emit(PlaybackEvent.STATE_CHANGE, state);
+    }
+    stopPlayers() {
+        for (const i of this.sheet.Instruments) {
+            for (const v of i.Voices) {
+                this.instrumentPlayer.stop(v.midiInstrumentId);
+            }
+        }
+    }
+    // Used to avoid duplicate cursor movements after a rapid pause/resume action
+    clearTimeouts() {
+        for (const h of this.timeoutHandles) {
+            clearTimeout(h);
+        }
+        this.timeoutHandles = [];
+    }
+    iterationCallback() {
+        if (this.state !== PlaybackState.PLAYING)
+            return;
+        if (this.currentIterationStep > 0)
+            this.cursor.next();
+        ++this.currentIterationStep;
+    }
+}

package/dist/PlaybackScheduler.d.ts

@@ -0,0 +1,34 @@
+import { Note, VoiceEntry } from "opensheetmusicdisplay";
+import { IAudioContext } from "standardized-audio-context";
+type NoteSchedulingCallback = (delay: number, notes: Note[]) => void;
+export default class PlaybackScheduler {
+    wholeNoteLength: number;
+    private stepQueue;
+    private stepQueueIndex;
+    private scheduledTicks;
+    private currentTick;
+    private currentTickTimestamp;
+    private audioContext;
+    private audioContextStartTime;
+    private schedulerIntervalHandle;
+    private scheduleInterval;
+    private schedulePeriod;
+    private tickDenominator;
+    private lastTickOffset;
+    private playing;
+    private noteSchedulingCallback;
+    constructor(wholeNoteLength: number, audioContext: IAudioContext, noteSchedulingCallback: NoteSchedulingCallback);
+    get schedulePeriodTicks(): number;
+    get audioContextTime(): number;
+    get tickDuration(): number;
+    private get calculatedTick();
+    start(): void;
+    setIterationStep(step: number): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    loadNotes(currentVoiceEntries: VoiceEntry[]): void;
+    private scheduleIterationStep;
+    private nextTickAvailableAndWithinSchedulePeriod;
+}
+export {};

package/dist/PlaybackScheduler.js

@@ -0,0 +1,105 @@
+import StepQueue from "./internals/StepQueue";
+export default class PlaybackScheduler {
+    constructor(wholeNoteLength, audioContext, noteSchedulingCallback) {
+        this.stepQueue = new StepQueue();
+        this.stepQueueIndex = 0;
+        this.scheduledTicks = new Set();
+        this.currentTick = 0;
+        this.currentTickTimestamp = 0;
+        this.audioContextStartTime = 0;
+        this.schedulerIntervalHandle = null;
+        this.scheduleInterval = 200; // Milliseconds
+        this.schedulePeriod = 500;
+        this.tickDenominator = 1024;
+        this.lastTickOffset = 300; // Hack to get the initial notes play better
+        this.playing = false;
+        this.noteSchedulingCallback = noteSchedulingCallback;
+        this.wholeNoteLength = wholeNoteLength;
+        this.audioContext = audioContext;
+    }
+    get schedulePeriodTicks() {
+        return this.schedulePeriod / this.tickDuration;
+    }
+    get audioContextTime() {
+        if (!this.audioContext)
+            return 0;
+        return (this.audioContext.currentTime - this.audioContextStartTime) * 1000;
+    }
+    get tickDuration() {
+        return this.wholeNoteLength / this.tickDenominator;
+    }
+    get calculatedTick() {
+        return (this.currentTick +
+            Math.round((this.audioContextTime - this.currentTickTimestamp) / this.tickDuration));
+    }
+    start() {
+        this.playing = true;
+        this.stepQueue.sort();
+        this.audioContextStartTime = this.audioContext.currentTime;
+        this.currentTickTimestamp = this.audioContextTime;
+        if (!this.schedulerIntervalHandle) {
+            this.schedulerIntervalHandle = window.setInterval(() => this.scheduleIterationStep(), this.scheduleInterval);
+        }
+    }
+    setIterationStep(step) {
+        step = Math.min(this.stepQueue.steps.length - 1, step);
+        this.stepQueueIndex = step;
+        this.currentTick = this.stepQueue.steps[this.stepQueueIndex].tick;
+    }
+    pause() {
+        this.playing = false;
+    }
+    resume() {
+        this.playing = true;
+        this.currentTickTimestamp = this.audioContextTime;
+    }
+    reset() {
+        this.playing = false;
+        this.currentTick = 0;
+        this.currentTickTimestamp = 0;
+        this.stepQueueIndex = 0;
+        clearInterval(this.scheduleInterval);
+        this.schedulerIntervalHandle = null;
+    }
+    loadNotes(currentVoiceEntries) {
+        let thisTick = this.lastTickOffset;
+        if (this.stepQueue.steps.length > 0) {
+            thisTick = this.stepQueue.getFirstEmptyTick();
+        }
+        for (const entry of currentVoiceEntries) {
+            if (!entry.IsGrace) {
+                for (const note of entry.Notes) {
+                    this.stepQueue.addNote(thisTick, note);
+                    this.stepQueue.createStep(thisTick + note.Length.RealValue * this.tickDenominator);
+                }
+            }
+        }
+    }
+    scheduleIterationStep() {
+        if (!this.playing)
+            return;
+        this.currentTick = this.calculatedTick;
+        this.currentTickTimestamp = this.audioContextTime;
+        let nextTick = this.stepQueue.steps[this.stepQueueIndex]?.tick;
+        while (this.nextTickAvailableAndWithinSchedulePeriod(nextTick)) {
+            const step = this.stepQueue.steps[this.stepQueueIndex];
+            let timeToTick = (step.tick - this.currentTick) * this.tickDuration;
+            if (timeToTick < 0)
+                timeToTick = 0;
+            this.scheduledTicks.add(step.tick);
+            this.noteSchedulingCallback(timeToTick / 1000, step.notes);
+            this.stepQueueIndex++;
+            nextTick = this.stepQueue.steps[this.stepQueueIndex]?.tick;
+        }
+        for (const tick of this.scheduledTicks) {
+            if (tick <= this.currentTick) {
+                this.scheduledTicks.delete(tick);
+            }
+        }
+    }
+    nextTickAvailableAndWithinSchedulePeriod(nextTick) {
+        return (nextTick &&
+            this.currentTickTimestamp + (nextTick - this.currentTick) * this.tickDuration <=
+                this.currentTickTimestamp + this.schedulePeriod);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import PlaybackEngine from "./PlaybackEngine";
+export default PlaybackEngine;

package/dist/index.js

@@ -0,0 +1,2 @@
+import PlaybackEngine from "./PlaybackEngine";
+export default PlaybackEngine;

package/dist/internals/EventEmitter.d.ts

@@ -0,0 +1,7 @@
+type Callback = (...args: unknown[]) => void;
+export declare class EventEmitter<T> {
+    private subscribers;
+    on(event: T, callback: Callback): void;
+    emit(event: T, ...args: unknown[]): void;
+}
+export {};