@coderline/alphatab 1.6.0-alpha.1408 → 1.6.0-alpha.1415

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1408 (develop, build 1408)
+ * alphaTab v1.6.0-alpha.1415 (develop, build 1415)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -3377,18 +3377,26 @@
             const lookup = new Map();
             const score = tracks[0].score;
             let currentIndex = startIndex;
+            let tempo = score.tempo;
             while (currentIndex <= endIndexInclusive) {
                 const currentGroupStartIndex = currentIndex;
                 let currentGroup = null;
                 while (currentIndex <= endIndexInclusive) {
                     const masterBar = score.masterBars[currentIndex];
+                    let hasTempoChange = false;
+                    for (const a of masterBar.tempoAutomations) {
+                        if (a.value !== tempo) {
+                            hasTempoChange = true;
+                        }
+                        tempo = a.value;
+                    }
                     // check if masterbar breaks multibar rests, it must be fully empty with no annotations
                     if (masterBar.alternateEndings ||
                         (masterBar.isRepeatStart && masterBar.index !== currentGroupStartIndex) ||
                         masterBar.isFreeTime ||
                         masterBar.isAnacrusis ||
                         masterBar.section !== null ||
-                        (masterBar.index !== currentGroupStartIndex && masterBar.tempoAutomations.length > 0) ||
+                        (masterBar.index !== currentGroupStartIndex && hasTempoChange) ||
                         (masterBar.fermata !== null && masterBar.fermata.size > 0) ||
                         (masterBar.directions !== null && masterBar.directions.size > 0)) {
                         break;
@@ -20221,7 +20229,11 @@
             for (const c of element.childElements()) {
                 switch (c.localName) {
                     case 'direction-type':
-                        directionTypes.push(c.firstElement);
+                        // See https://github.com/CoderLine/alphaTab/issues/2102
+                        const type = c.firstElement;
+                        if (type) {
+                            directionTypes.push(type);
+                        }
                         break;
                     case 'offset':
                         offset = Number.parseFloat(c.innerText);
@@ -22403,6 +22415,11 @@
                 this._mainState.eventIndex = 0;
                 this._mainState.syncPointIndex = 0;
                 this._mainState.tempoChangeIndex = 0;
+                this._mainState.currentTempo = this._mainState.tempoChanges[0].bpm;
+                this._mainState.modifiedTempo =
+                    this._mainState.syncPoints.length > 0
+                        ? this._mainState.syncPoints[0].data.modifiedTempo
+                        : this._mainState.currentTempo;
                 if (this.isPlayingMain) {
                     const metronomeVolume = this._synthesizer.metronomeVolume;
                     this._synthesizer.noteOffAll(true);
@@ -22541,18 +22558,6 @@
                 this._currentState.synthData[this._currentState.eventIndex].time < this._currentState.currentTime) {
                 const synthEvent = this._currentState.synthData[this._currentState.eventIndex];
                 this._synthesizer.dispatchEvent(synthEvent);
-                while (this._currentState.syncPointIndex < this._currentState.syncPoints.length &&
-                    this._currentState.syncPoints[this._currentState.syncPointIndex].tick < synthEvent.event.tick) {
-                    this._currentState.modifiedTempo =
-                        this._currentState.syncPoints[this._currentState.syncPointIndex].data.modifiedTempo;
-                    this._currentState.syncPointIndex++;
-                }
-                while (this._currentState.tempoChangeIndex < this._currentState.tempoChanges.length &&
-                    this._currentState.tempoChanges[this._currentState.tempoChangeIndex].time <= synthEvent.time) {
-                    this._currentState.currentTempo =
-                        this._currentState.tempoChanges[this._currentState.tempoChangeIndex].bpm;
-                    this._currentState.tempoChangeIndex++;
-                }
                 this._currentState.eventIndex++;
                 anyEventsDispatched = true;
             }
@@ -22582,9 +22587,6 @@
         mainTickPositionToTimePosition(tickPosition) {
             return this.tickPositionToTimePositionWithSpeed(this._mainState, tickPosition, this.playbackSpeed);
         }
-        mainTimePositionToTickPosition(timePosition) {
-            return this.timePositionToTickPositionWithSpeed(this._mainState, timePosition, this.playbackSpeed);
-        }
         mainUpdateSyncPoints(syncPoints) {
             const state = this._mainState;
             syncPoints.sort((a, b) => a.tick - b.tick); // just in case
@@ -22612,7 +22614,49 @@
             state.syncPointIndex = 0;
         }
         currentTimePositionToTickPosition(timePosition) {
-            return this.timePositionToTickPositionWithSpeed(this._currentState, timePosition, this.playbackSpeed);
+            const state = this._currentState;
+            if (state.tempoChanges.length === 0) {
+                return 0;
+            }
+            timePosition *= this.playbackSpeed;
+            this.updateCurrentTempo(state, timePosition);
+            const lastTempoChange = state.tempoChanges[state.tempoChangeIndex];
+            const timeDiff = timePosition - lastTempoChange.time;
+            const ticks = ((timeDiff / (60000.0 / (lastTempoChange.bpm * state.division))) | 0);
+            // we add 1 for possible rounding errors.(floating point issuses)
+            return lastTempoChange.ticks + ticks + 1;
+        }
+        updateCurrentTempo(state, timePosition) {
+            let tempoChangeIndex = state.tempoChangeIndex;
+            if (timePosition < state.tempoChanges[tempoChangeIndex].time) {
+                tempoChangeIndex = 0;
+            }
+            while (tempoChangeIndex + 1 < state.tempoChanges.length &&
+                state.tempoChanges[tempoChangeIndex + 1].time <= timePosition) {
+                tempoChangeIndex++;
+            }
+            if (tempoChangeIndex !== state.tempoChangeIndex) {
+                state.tempoChangeIndex = tempoChangeIndex;
+                state.currentTempo = state.tempoChanges[state.tempoChangeIndex].bpm;
+            }
+            const syncPoints = state.syncPoints;
+            if (syncPoints.length > 0) {
+                let syncPointIndex = Math.min(state.syncPointIndex, syncPoints.length - 1);
+                if (timePosition < syncPoints[syncPointIndex].data.millisecondOffset) {
+                    syncPointIndex = 0;
+                }
+                while (syncPointIndex + 1 < syncPoints.length &&
+                    syncPoints[syncPointIndex + 1].data.millisecondOffset <= timePosition) {
+                    syncPointIndex++;
+                }
+                if (syncPointIndex !== state.syncPointIndex) {
+                    state.syncPointIndex = syncPointIndex;
+                    state.modifiedTempo = syncPoints[syncPointIndex].data.modifiedTempo;
+                }
+            }
+            else {
+                state.modifiedTempo = state.currentTempo;
+            }
         }
         mainTimePositionFromBackingTrack(timePosition, backingTrackLength) {
             const mainState = this._mainState;
@@ -22620,11 +22664,8 @@
             if (timePosition < 0 || syncPoints.length === 0) {
                 return timePosition;
             }
-            let syncPointIndex = timePosition >= syncPoints[mainState.syncPointIndex].data.millisecondOffset ? mainState.syncPointIndex : 0;
-            while (syncPointIndex + 1 < syncPoints.length &&
-                syncPoints[syncPointIndex + 1].data.millisecondOffset <= timePosition) {
-                syncPointIndex++;
-            }
+            this.updateCurrentTempo(this._mainState, timePosition);
+            const syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
             const currentSyncPoint = syncPoints[syncPointIndex];
             const timeDiff = timePosition - currentSyncPoint.data.millisecondOffset;
             let alphaTabTimeDiff;
@@ -22646,7 +22687,10 @@
                 return timePosition;
             }
             timePosition *= this.playbackSpeed;
-            let syncPointIndex = timePosition >= syncPoints[mainState.syncPointIndex].time ? mainState.syncPointIndex : 0;
+            let syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
+            if (timePosition < syncPoints[syncPointIndex].time) {
+                syncPointIndex = 0;
+            }
             while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].time <= timePosition) {
                 syncPointIndex++;
             }
@@ -22684,26 +22728,6 @@
             timePosition += tickPosition * (60000.0 / (bpm * state.division));
             return timePosition / playbackSpeed;
         }
-        timePositionToTickPositionWithSpeed(state, timePosition, playbackSpeed) {
-            timePosition *= playbackSpeed;
-            let ticks = 0;
-            let bpm = 120.0;
-            let lastChange = 0;
-            // find start and bpm of last tempo change before time
-            for (const c of state.tempoChanges) {
-                if (timePosition < c.time) {
-                    break;
-                }
-                ticks = c.ticks;
-                bpm = c.bpm;
-                lastChange = c.time;
-            }
-            // add the missing ticks
-            timePosition -= lastChange;
-            ticks += (timePosition / (60000.0 / (bpm * state.division))) | 0;
-            // we add 1 for possible rounding errors.(floating point issuses)
-            return ticks + 1;
-        }
         get internalEndTime() {
             if (this.isPlayingMain) {
                 return !this.mainPlaybackRange ? this._currentState.endTime : this._currentState.playbackRangeEndTime;
@@ -26922,7 +26946,7 @@
             return processedEvents;
         }
         processMidiMessage(e) {
-            Logger.debug('Midi', `Processing Midi message ${MidiEventType[e.type]}/${e.tick}`);
+            //Logger.debug('Midi', `Processing Midi message ${MidiEventType[e.type]}/${e.tick}`);
             const command = e.type;
             switch (command) {
                 case MidiEventType.TimeSignature:
@@ -28043,6 +28067,9 @@
         }
         on(value) {
             this._listeners.push(value);
+            return () => {
+                this.off(value);
+            };
         }
         off(value) {
             this._listeners = this._listeners.filter(l => l !== value);
@@ -28062,6 +28089,9 @@
         }
         on(value) {
             this._listeners.push(value);
+            return () => {
+                this.off(value);
+            };
         }
         off(value) {
             this._listeners = this._listeners.filter(l => l !== value);
@@ -28458,7 +28488,7 @@
                 endTick = this.sequencer.currentEndTick;
             }
             if (this._tickPosition >= endTick) {
-                // fully done with playback of remaining samples? 
+                // fully done with playback of remaining samples?
                 if (this._notPlayedSamples <= 0) {
                     this._notPlayedSamples = 0;
                     if (this.sequencer.isPlayingCountIn) {
@@ -35808,6 +35838,27 @@
                 controller.moveNext();
                 previousMasterBar = bar;
             }
+            // here we interpolate the sync point which marks the end of the sync.
+            // Sync points define new tempos at certain positions.
+            // looking from the last sync point to the end we do not assume the end where the audio ends,
+            // but where it ends according to the BPM and the remaining ticks.
+            if (this.syncPoints.length > 0) {
+                const lastSyncPoint = this.syncPoints[this.syncPoints.length - 1];
+                const endTick = controller.currentTick;
+                const remainingTicks = endTick - lastSyncPoint.tick;
+                if (remainingTicks > 0) {
+                    const syncPointData = new SyncPointData();
+                    // last occurence of the last bar
+                    syncPointData.barOccurence = barOccurence.get(this._score.masterBars.length - 1);
+                    // same tempo as last point
+                    syncPointData.modifiedTempo = lastSyncPoint.data.modifiedTempo;
+                    // interpolated end from last syncPoint
+                    syncPointData.millisecondOffset =
+                        lastSyncPoint.data.millisecondOffset +
+                            MidiUtils.ticksToMillis(remainingTicks, syncPointData.modifiedTempo);
+                    this.syncPoints.push(new BackingTrackSyncPoint(endTick, syncPointData));
+                }
+            }
             for (const track of this._score.tracks) {
                 this._handler.finishTrack(track.index, controller.currentTick);
             }
@@ -38299,6 +38350,357 @@
         }
     }
 
+    /**
+     * A {@link IAlphaSynth} implementation wrapping and underling other {@link IAlphaSynth}
+     * allowing dynamic changing of the underlying instance without loosing aspects like the
+     * main playback information and event listeners.
+     *
+     * @remarks
+     * This wrapper is used when re-exposing the underlying player via {@link AlphaTabApiBase} to integrators.
+     * Even with dynamic switching between synthesizer, backing tracks etc. aspects like volume, playbackspeed,
+     * event listeners etc. should not be lost.
+     */
+    class AlphaSynthWrapper {
+        constructor() {
+            // relevant state information we want to remember when switching between player instances
+            this._masterVolume = 1;
+            this._metronomeVolume = 0;
+            this._countInVolume = 0;
+            this._playbackSpeed = 1;
+            this._isLooping = false;
+            this._midiEventsPlayedFilter = [];
+            this.ready = new EventEmitter();
+            this.readyForPlayback = new EventEmitter();
+            this.finished = new EventEmitter();
+            this.soundFontLoaded = new EventEmitter();
+            this.soundFontLoadFailed = new EventEmitterOfT();
+            this.midiLoaded = new EventEmitterOfT();
+            this.midiLoadFailed = new EventEmitterOfT();
+            this.stateChanged = new EventEmitterOfT();
+            this.positionChanged = new EventEmitterOfT();
+            this.midiEventsPlayed = new EventEmitterOfT();
+            this.playbackRangeChanged = new EventEmitterOfT();
+        }
+        get instance() {
+            return this._instance;
+        }
+        set instance(value) {
+            this._instance = value;
+            // unregister all events from previous instance
+            const unregister = this._instanceEventUnregister;
+            if (unregister) {
+                for (const e of unregister) {
+                    e();
+                }
+            }
+            if (value) {
+                // regsiter to events of new player and forward them to existing listeners
+                const newUnregister = [];
+                newUnregister.push(value.ready.on(() => this.ready.trigger()));
+                newUnregister.push(value.readyForPlayback.on(() => this.readyForPlayback.trigger()));
+                newUnregister.push(value.finished.on(() => this.finished.trigger()));
+                newUnregister.push(value.soundFontLoaded.on(() => this.soundFontLoaded.trigger()));
+                newUnregister.push(value.soundFontLoadFailed.on(e => this.soundFontLoadFailed.trigger(e)));
+                newUnregister.push(value.midiLoaded.on(e => this.midiLoaded.trigger(e)));
+                newUnregister.push(value.midiLoadFailed.on(e => this.midiLoadFailed.trigger(e)));
+                newUnregister.push(value.stateChanged.on(e => this.stateChanged.trigger(e)));
+                newUnregister.push(value.positionChanged.on(e => this.positionChanged.trigger(e)));
+                newUnregister.push(value.midiEventsPlayed.on(e => this.midiEventsPlayed.trigger(e)));
+                newUnregister.push(value.playbackRangeChanged.on(e => this.playbackRangeChanged.trigger(e)));
+                this._instanceEventUnregister = newUnregister;
+                // restore state on new player
+                if (this.isReady) {
+                    value.masterVolume = this._masterVolume;
+                    value.metronomeVolume = this._metronomeVolume;
+                    value.countInVolume = this._countInVolume;
+                    value.playbackSpeed = this._playbackSpeed;
+                    value.isLooping = this._isLooping;
+                    value.midiEventsPlayedFilter = this._midiEventsPlayedFilter;
+                }
+                else {
+                    newUnregister.push(value.ready.on(() => {
+                        value.masterVolume = this._masterVolume;
+                        value.metronomeVolume = this._metronomeVolume;
+                        value.countInVolume = this._countInVolume;
+                        value.playbackSpeed = this._playbackSpeed;
+                        value.isLooping = this._isLooping;
+                        value.midiEventsPlayedFilter = this._midiEventsPlayedFilter;
+                    }));
+                }
+            }
+            else {
+                this._instanceEventUnregister = undefined;
+            }
+        }
+        get output() {
+            return this._instance.output;
+        }
+        get isReady() {
+            return this._instance ? this._instance.isReady : false;
+        }
+        get isReadyForPlayback() {
+            return this._instance ? this._instance.isReadyForPlayback : false;
+        }
+        get state() {
+            return this._instance ? this._instance.state : PlayerState.Paused;
+        }
+        get logLevel() {
+            return Logger.logLevel;
+        }
+        set logLevel(value) {
+            Logger.logLevel = value;
+            if (this._instance) {
+                this._instance.logLevel = value;
+            }
+        }
+        get masterVolume() {
+            return this._masterVolume;
+        }
+        set masterVolume(value) {
+            value = Math.max(value, SynthConstants.MinVolume);
+            this._masterVolume = value;
+            if (this._instance) {
+                this._instance.masterVolume = value;
+            }
+        }
+        get metronomeVolume() {
+            return this._metronomeVolume;
+        }
+        set metronomeVolume(value) {
+            value = Math.max(value, SynthConstants.MinVolume);
+            this._metronomeVolume = value;
+            if (this._instance) {
+                this._instance.metronomeVolume = value;
+            }
+        }
+        get playbackSpeed() {
+            return this._playbackSpeed;
+        }
+        set playbackSpeed(value) {
+            this._playbackSpeed = value;
+            if (this._instance) {
+                this._instance.playbackSpeed = value;
+            }
+        }
+        get tickPosition() {
+            return this._instance ? this._instance.tickPosition : 0;
+        }
+        set tickPosition(value) {
+            if (this._instance) {
+                this._instance.tickPosition = value;
+            }
+        }
+        get timePosition() {
+            return this._instance ? this._instance.timePosition : 0;
+        }
+        set timePosition(value) {
+            if (this._instance) {
+                this._instance.timePosition = value;
+            }
+        }
+        get playbackRange() {
+            return this._instance ? this._instance.playbackRange : null;
+        }
+        set playbackRange(value) {
+            if (this._instance) {
+                this._instance.playbackRange = value;
+            }
+        }
+        get isLooping() {
+            return this._isLooping;
+        }
+        set isLooping(value) {
+            this._isLooping = value;
+            if (this._instance) {
+                this._instance.isLooping = value;
+            }
+        }
+        get countInVolume() {
+            return this._countInVolume;
+        }
+        set countInVolume(value) {
+            this._countInVolume = value;
+            if (this._instance) {
+                this._instance.countInVolume = value;
+            }
+        }
+        get midiEventsPlayedFilter() {
+            return this._midiEventsPlayedFilter;
+        }
+        set midiEventsPlayedFilter(value) {
+            this._midiEventsPlayedFilter = value;
+            if (this._instance) {
+                this._instance.midiEventsPlayedFilter = value;
+            }
+        }
+        destroy() {
+            if (this._instance) {
+                this._instance.destroy();
+                this._instance = undefined;
+            }
+        }
+        play() {
+            return this._instance ? this._instance.play() : false;
+        }
+        pause() {
+            if (this._instance) {
+                this._instance.pause();
+            }
+        }
+        playPause() {
+            if (this._instance) {
+                this._instance.playPause();
+            }
+        }
+        stop() {
+            if (this._instance) {
+                this._instance.stop();
+            }
+        }
+        playOneTimeMidiFile(midi) {
+            if (this._instance) {
+                this._instance.playOneTimeMidiFile(midi);
+            }
+        }
+        loadSoundFont(data, append) {
+            if (this._instance) {
+                this._instance.loadSoundFont(data, append);
+            }
+        }
+        resetSoundFonts() {
+            if (this._instance) {
+                this._instance.resetSoundFonts();
+            }
+        }
+        loadMidiFile(midi) {
+            if (this._instance) {
+                this._instance.loadMidiFile(midi);
+            }
+        }
+        loadBackingTrack(score, syncPoints) {
+            if (this._instance) {
+                this._instance.loadBackingTrack(score, syncPoints);
+            }
+        }
+        applyTranspositionPitches(transpositionPitches) {
+            if (this._instance) {
+                this._instance.applyTranspositionPitches(transpositionPitches);
+            }
+        }
+        setChannelTranspositionPitch(channel, semitones) {
+            if (this._instance) {
+                this._instance.setChannelTranspositionPitch(channel, semitones);
+            }
+        }
+        setChannelMute(channel, mute) {
+            if (this._instance) {
+                this._instance.setChannelMute(channel, mute);
+            }
+        }
+        resetChannelStates() {
+            if (this._instance) {
+                this._instance.resetChannelStates();
+            }
+        }
+        setChannelSolo(channel, solo) {
+            if (this._instance) {
+                this._instance.setChannelSolo(channel, solo);
+            }
+        }
+        setChannelVolume(channel, volume) {
+            if (this._instance) {
+                this._instance.setChannelVolume(channel, volume);
+            }
+        }
+    }
+
+    /**
+     * A {@link IScoreRenderer} implementation wrapping and underling other {@link IScoreRenderer}
+     * allowing dynamic changing of the underlying instance without loosing aspects like the
+     * event listeners.
+     */
+    class ScoreRendererWrapper {
+        constructor() {
+            this._width = 0;
+            this._score = null;
+            this._trackIndexes = null;
+            this.preRender = new EventEmitterOfT();
+            this.renderFinished = new EventEmitterOfT();
+            this.partialRenderFinished = new EventEmitterOfT();
+            this.partialLayoutFinished = new EventEmitterOfT();
+            this.postRenderFinished = new EventEmitter();
+            this.error = new EventEmitterOfT();
+        }
+        get instance() {
+            return this._instance;
+        }
+        set instance(value) {
+            this._instance = value;
+            // unregister all events from previous instance
+            const unregister = this._instanceEventUnregister;
+            if (unregister) {
+                for (const e of unregister) {
+                    e();
+                }
+            }
+            if (value) {
+                // regsiter to events of new player and forward them to existing listeners
+                const newUnregister = [];
+                newUnregister.push(value.preRender.on(v => this.preRender.trigger(v)));
+                newUnregister.push(value.renderFinished.on(v => this.renderFinished.trigger(v)));
+                newUnregister.push(value.partialRenderFinished.on(v => this.partialRenderFinished.trigger(v)));
+                newUnregister.push(value.partialLayoutFinished.on(v => this.partialLayoutFinished.trigger(v)));
+                newUnregister.push(value.postRenderFinished.on(() => this.postRenderFinished.trigger()));
+                newUnregister.push(value.error.on(v => this.error.trigger(v)));
+                this._instanceEventUnregister = newUnregister;
+                if (this._settings) {
+                    value.updateSettings(this._settings);
+                }
+                value.width = this._width;
+                if (this._score !== null) {
+                    value.renderScore(this._score, this._trackIndexes);
+                }
+            }
+            else {
+                this._instanceEventUnregister = undefined;
+            }
+        }
+        get boundsLookup() {
+            return this._instance ? this._instance.boundsLookup : null;
+        }
+        get width() {
+            return this._instance ? this._instance.width : 0;
+        }
+        set width(value) {
+            this._width = value;
+            if (this._instance) {
+                this._instance.width = value;
+            }
+        }
+        render() {
+            this._instance?.render();
+        }
+        resizeRender() {
+            this._instance?.resizeRender();
+        }
+        renderScore(score, trackIndexes) {
+            this._score = score;
+            this._trackIndexes = trackIndexes;
+            this._instance?.renderScore(score, trackIndexes);
+        }
+        renderResult(resultId) {
+            this._instance?.renderResult(resultId);
+        }
+        updateSettings(settings) {
+            this._settings = settings;
+            this._instance?.updateSettings(settings);
+        }
+        destroy() {
+            this._instance?.destroy();
+            this._instance = undefined;
+        }
+    }
+
     class SelectionInfo {
         constructor(beat) {
             this.bounds = null;
@@ -38318,6 +38720,18 @@
         get actualPlayerMode() {
             return this._actualPlayerMode;
         }
+        /**
+         * The score renderer used for rendering the music sheet.
+         * @remarks
+         * This is the low-level API responsible for the actual rendering engine.
+         * Gets access to the underling {@link IScoreRenderer} that is used for the rendering.
+         *
+         * @category Properties - Core
+         * @since 0.9.4
+         */
+        get renderer() {
+            return this._renderer;
+        }
         /**
          * The score holding all information about the song being rendered
          * @category Properties - Core
@@ -38389,43 +38803,14 @@
             this._tracks = [];
             this._actualPlayerMode = exports.PlayerMode.Disabled;
             this._tickCache = null;
-            /**
-             * The alphaSynth player used for playback.
-             * @remarks
-             * This is the low-level API to the Midi synthesizer used for playback.
-             * Gets access to the underling {@link IAlphaSynth} that is used for the audio playback.
-             * @category Properties - Player
-             * @since 0.9.4
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * setupPlayerEvents(api.settings);
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * SetupPlayerEvents(api.Player);
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...)
-             * setupPlayerEvents(api.player)
-             * ```
-             */
-            this.player = null;
             this._cursorWrapper = null;
             this._barCursor = null;
             this._beatCursor = null;
             this._selectionWrapper = null;
             this._previousTick = 0;
-            this._playerState = PlayerState.Paused;
             this._currentBeat = null;
-            this._currentBarBounds = null;
+            this._currentBeatBounds = null;
+            this._isInitialBeatCursorUpdate = true;
             this._previousStateForCursor = PlayerState.Paused;
             this._previousCursorCache = null;
             this._lastScroll = 0;
@@ -38996,133 +39381,6 @@
              *
              */
             this.error = new EventEmitterOfT();
-            /**
-             * This event is fired when all required data for playback is loaded and ready.
-             * @remarks
-             * This event is fired when all required data for playback is loaded and ready. The player is ready for playback when
-             * all background workers are started, the audio output is initialized, a soundfont is loaded, and a song was loaded into the player as midi file.
-             *
-             * @eventProperty
-             * @category Events - Player
-             * @since 0.9.4
-             *
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.playerReady.on(() => {
-             *     enablePlayerControls();
-             * });
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * api.PlayerReady.On(() =>
-             * {
-             *     EnablePlayerControls()
-             * });
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...)
-             * api.playerReady.on {
-             *     enablePlayerControls()
-             * }
-             * ```
-             */
-            this.playerReady = new EventEmitter();
-            /**
-             * This event is fired when the playback of the whole song finished.
-             * @remarks
-             * This event is finished regardless on whether looping is enabled or not.
-             *
-             * @eventProperty
-             * @category Events - Player
-             * @since 0.9.4
-             *
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.playerFinished.on((args) => {
-             *     // speed trainer
-             *     api.playbackSpeed = Math.min(1.0, api.playbackSpeed + 0.1);
-             * });
-             * api.isLooping = true;
-             * api.playbackSpeed = 0.5;
-             * api.play()
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * api.PlayerFinished.On(() =>
-             * {
-             *     // speed trainer
-             *     api.PlaybackSpeed = Math.Min(1.0, api.PlaybackSpeed + 0.1);
-             * });
-             * api.IsLooping = true;
-             * api.PlaybackSpeed = 0.5;
-             * api.Play();
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...)
-             * api.playerFinished.on {
-             *     // speed trainer
-             *     api.playbackSpeed = min(1.0, api.playbackSpeed + 0.1);
-             * }
-             * api.isLooping = true
-             * api.playbackSpeed = 0.5
-             * api.play()
-             * ```
-             *
-             */
-            this.playerFinished = new EventEmitter();
-            /**
-             * This event is fired when the SoundFont needed for playback was loaded.
-             *
-             * @eventProperty
-             * @category Events - Player
-             * @since 0.9.4
-             *
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.soundFontLoaded.on(() => {
-             *     hideSoundFontLoadingIndicator();
-             * });
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * api.SoundFontLoaded.On(() =>
-             * {
-             *     HideSoundFontLoadingIndicator();
-             * });
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...);
-             * api.soundFontLoaded.on {
-             *     hideSoundFontLoadingIndicator();
-             * }
-             * ```
-             *
-             */
-            this.soundFontLoaded = new EventEmitter();
             /**
              * This event is fired when a Midi file is being loaded.
              *
@@ -39211,176 +39469,18 @@
              */
             this.midiLoaded = new EventEmitterOfT();
             /**
-             * This event is fired when the playback state changed.
-             *
-             * @eventProperty
-             * @category Events - Player
-             * @since 0.9.4
-             *
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.playerStateChanged.on((args) => {
-             *     updatePlayerControls(args.state, args.stopped);
-             * });
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * api.PlayerStateChanged.On(args =>
-             * {
-             *     UpdatePlayerControls(args);
-             * });
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...)
-             * api.playerStateChanged.on { args ->
-             *     updatePlayerControls(args)
-             * }
-             * ```
-             *
-             */
-            this.playerStateChanged = new EventEmitterOfT();
-            /**
-             * This event is fired when the current playback position of the song changed.
-             *
-             * @eventProperty
-             * @category Events - Player
-             * @since 0.9.4
-             *
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.playerPositionChanged.on((args) => {
-             *     updatePlayerPosition(args);
-             * });
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * api.PlayerPositionChanged.On(args =>
-             * {
-             *     UpdatePlayerPosition(args);
-             * });
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...)
-             * api.playerPositionChanged.on { args ->
-             *     updatePlayerPosition(args)
-             * }
-             * ```
-             *
-             */
-            this.playerPositionChanged = new EventEmitterOfT();
-            /**
-             * This event is fired when the synthesizer played certain midi events.
-             *
-             * @remarks
-             * This event is fired when the synthesizer played certain midi events. This allows reacing on various low level
-             * audio playback elements like notes/rests played or metronome ticks.
-             *
-             * Refer to the [related guide](https://www.alphatab.net/docs/guides/handling-midi-events) to learn more about this feature.
-             *
-             * Also note that the provided data models changed significantly in {@version 1.3.0}. We try to provide backwards compatibility
-             * until some extend but highly encourage changing to the new models in case of problems.
+             * This event is fired when a settings update was requested.
              *
              * @eventProperty
-             * @category Events - Player
-             * @since 1.2.0
-             *
-             * @example
-             * JavaScript
-             * ```js
-             * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.midiEventsPlayedFilter = [alphaTab.midi.MidiEventType.AlphaTabMetronome];
-             * api.midiEventsPlayed.on(function(e) {
-             *   for(const midi of e.events) {
-             *     if(midi.isMetronome) {
-             *       console.log('Metronome tick ' + midi.tick);
-             *     }
-             *   }
-             * });
-             * ```
-             *
-             * @example
-             * C#
-             * ```cs
-             * var api = new AlphaTabApi<MyControl>(...);
-             * api.MidiEventsPlayedFilter = new MidiEventType[] { AlphaTab.Midi.MidiEventType.AlphaTabMetronome };
-             * api.MidiEventsPlayed.On(e =>
-             * {
-             *   foreach(var midi of e.events)
-             *   {
-             *     if(midi is AlphaTab.Midi.AlphaTabMetronomeEvent sysex && sysex.IsMetronome)
-             *     {
-             *       Console.WriteLine("Metronome tick " + midi.Tick);
-             *     }
-             *   }
-             * });
-             * ```
-             *
-             * @example
-             * Android
-             * ```kotlin
-             * val api = AlphaTabApi<MyControl>(...);
-             * api.midiEventsPlayedFilter = alphaTab.collections.List<alphaTab.midi.MidiEventType>( alphaTab.midi.MidiEventType.AlphaTabMetronome )
-             * api.midiEventsPlayed.on { e ->
-             *   for (midi in e.events) {
-             *     if(midi instanceof alphaTab.midi.AlphaTabMetronomeEvent && midi.isMetronome) {
-             *       println("Metronome tick " + midi.tick);
-             *     }
-             *   }
-             * }
-             * ```
-             * @see {@link MidiEvent}
-             * @see {@link TimeSignatureEvent}
-             * @see {@link AlphaTabMetronomeEvent}
-             * @see {@link AlphaTabRestEvent}
-             * @see {@link NoteOnEvent}
-             * @see {@link NoteOffEvent}
-             * @see {@link ControlChangeEvent}
-             * @see {@link ProgramChangeEvent}
-             * @see {@link TempoChangeEvent}
-             * @see {@link PitchBendEvent}
-             * @see {@link NoteBendEvent}
-             * @see {@link EndOfTrackEvent}
-             * @see {@link MetaEvent}
-             * @see {@link MetaDataEvent}
-             * @see {@link MetaNumberEvent}
-             * @see {@link Midi20PerNotePitchBendEvent}
-             * @see {@link SystemCommonEvent}
-             * @see {@link SystemExclusiveEvent}
-             */
-            this.midiEventsPlayed = new EventEmitterOfT();
-            /**
-             * This event is fired when the playback range changed.
-             *
-             * @eventProperty
-             * @category Events - Player
-             * @since 1.2.3
+             * @category Events - Core
+             * @since 1.6.0
              *
              * @example
              * JavaScript
              * ```js
              * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-             * api.playbackRangeChanged.on((args) => {
-             *     if (args.playbackRange) {
-             *         highlightRangeInProgressBar(args.playbackRange.startTick, args.playbackRange.endTick);
-             *     } else {
-             *         clearHighlightInProgressBar();
-             *     }
+             * api.settingsUpdated.on(() => {
+             *     updateSettingsUI(api.settings);
              * });
              * ```
              *
@@ -39388,16 +39488,9 @@
              * C#
              * ```cs
              * var api = new AlphaTabApi<MyControl>(...);
-             * api.PlaybackRangeChanged.On(args =>
+             * api.SettingsUpdated.On(() =>
              * {
-             *     if (args.PlaybackRange != null)
-             *     {
-             *         HighlightRangeInProgressBar(args.PlaybackRange.StartTick, args.PlaybackRange.EndTick);
-             *     }
-             *     else
-             *     {
-             *         ClearHighlightInProgressBar();
-             *     }
+             *     UpdateSettingsUI(api.settings);
              * });
              * ```
              *
@@ -39405,21 +39498,12 @@
              * Android
              * ```kotlin
              * val api = AlphaTabApi<MyControl>(...)
-             * api.playbackRangeChanged.on { args ->
-             *     val playbackRange = args.playbackRange
-             *     if (playbackRange != null) {
-             *         highlightRangeInProgressBar(playbackRange.startTick, playbackRange.endTick)
-             *     } else {
-             *         clearHighlightInProgressBar()
-             *     }
+             * api.SettingsUpdated.on {
+             *     updateSettingsUI(api.settings)
              * }
              * ```
              *
              */
-            this.playbackRangeChanged = new EventEmitterOfT();
-            /**
-             * @internal
-             */
             this.settingsUpdated = new EventEmitter();
             this.uiFacade = uiFacade;
             this.container = uiFacade.rootContainer;
@@ -39432,48 +39516,49 @@
             Environment.printEnvironmentInfo(false);
             this.canvasElement = uiFacade.createCanvasElement();
             this.container.appendChild(this.canvasElement);
+            this._renderer = new ScoreRendererWrapper();
             if (this.settings.core.useWorkers &&
                 this.uiFacade.areWorkersSupported &&
                 Environment.getRenderEngineFactory(this.settings.core.engine).supportsWorkers) {
-                this.renderer = this.uiFacade.createWorkerRenderer();
+                this._renderer.instance = this.uiFacade.createWorkerRenderer();
             }
             else {
-                this.renderer = new ScoreRenderer(this.settings);
+                this._renderer.instance = new ScoreRenderer(this.settings);
             }
             this.container.resize.on(Environment.throttle(() => {
                 if (this._isDestroyed) {
                     return;
                 }
-                if (this.container.width !== this.renderer.width) {
+                if (this.container.width !== this._renderer.width) {
                     this.triggerResize();
                 }
             }, uiFacade.resizeThrottle));
             const initialResizeEventInfo = new ResizeEventArgs();
-            initialResizeEventInfo.oldWidth = this.renderer.width;
+            initialResizeEventInfo.oldWidth = this._renderer.width;
             initialResizeEventInfo.newWidth = this.container.width | 0;
             initialResizeEventInfo.settings = this.settings;
             this.onResize(initialResizeEventInfo);
-            this.renderer.preRender.on(this.onRenderStarted.bind(this));
-            this.renderer.renderFinished.on(renderingResult => {
+            this._renderer.preRender.on(this.onRenderStarted.bind(this));
+            this._renderer.renderFinished.on(renderingResult => {
                 this.onRenderFinished(renderingResult);
             });
-            this.renderer.postRenderFinished.on(() => {
+            this._renderer.postRenderFinished.on(() => {
                 const duration = Date.now() - this._startTime;
                 Logger.debug('rendering', `Rendering completed in ${duration}ms`);
                 this.onPostRenderFinished();
             });
-            this.renderer.preRender.on(_ => {
+            this._renderer.preRender.on(_ => {
                 this._startTime = Date.now();
             });
-            this.renderer.partialLayoutFinished.on(this.appendRenderResult.bind(this));
-            this.renderer.partialRenderFinished.on(this.updateRenderResult.bind(this));
-            this.renderer.renderFinished.on(r => {
-                this.appendRenderResult(r);
-                this.appendRenderResult(null); // marks last element
+            this._renderer.partialLayoutFinished.on(r => this.appendRenderResult(r, false));
+            this._renderer.partialRenderFinished.on(this.updateRenderResult.bind(this));
+            this._renderer.renderFinished.on(r => {
+                this.appendRenderResult(r, true);
             });
-            this.renderer.error.on(this.onError.bind(this));
+            this._renderer.error.on(this.onError.bind(this));
+            this.setupPlayerWrapper();
             if (this.settings.player.playerMode !== exports.PlayerMode.Disabled) {
-                this.setupPlayer();
+                this.setupOrDestroyPlayer();
             }
             this.setupClickHandling();
             // delay rendering to allow ui to hook up with events first.
@@ -39481,6 +39566,36 @@
                 this.uiFacade.initialRender();
             });
         }
+        setupPlayerWrapper() {
+            const player = new AlphaSynthWrapper();
+            this._player = player;
+            player.ready.on(() => {
+                this.loadMidiForScore();
+            });
+            player.readyForPlayback.on(() => {
+                this.onPlayerReady();
+                if (this.tracks) {
+                    for (const track of this.tracks) {
+                        const volume = track.playbackInfo.volume / 16;
+                        player.setChannelVolume(track.playbackInfo.primaryChannel, volume);
+                        player.setChannelVolume(track.playbackInfo.secondaryChannel, volume);
+                    }
+                }
+            });
+            player.soundFontLoaded.on(this.onSoundFontLoaded.bind(this));
+            player.soundFontLoadFailed.on(e => {
+                this.onError(e);
+            });
+            player.midiLoaded.on(this.onMidiLoaded.bind(this));
+            player.midiLoadFailed.on(e => {
+                this.onError(e);
+            });
+            player.stateChanged.on(this.onPlayerStateChanged.bind(this));
+            player.positionChanged.on(this.onPlayerPositionChanged.bind(this));
+            player.midiEventsPlayed.on(this.onMidiEventsPlayed.bind(this));
+            player.playbackRangeChanged.on(this.onPlaybackRangeChanged.bind(this));
+            player.finished.on(this.onPlayerFinished.bind(this));
+        }
         /**
          * Destroys the alphaTab control and restores the initial state of the UI.
          * @remarks
@@ -39513,11 +39628,9 @@
          */
         destroy() {
             this._isDestroyed = true;
-            if (this.player) {
-                this.player.destroy();
-            }
+            this._player.destroy();
             this.uiFacade.destroy();
-            this.renderer.destroy();
+            this._renderer.destroy();
         }
         /**
          * Applies any changes that were done to the settings object.
@@ -39562,17 +39675,29 @@
             if (score) {
                 ModelUtils.applyPitchOffsets(this.settings, score);
             }
-            this.renderer.updateSettings(this.settings);
-            // enable/disable player if needed
-            if (this.settings.player.playerMode !== exports.PlayerMode.Disabled) {
-                if (this.setupPlayer() && score) {
-                    this.loadMidiForScore();
+            this.updateRenderer();
+            this._renderer.updateSettings(this.settings);
+            this.setupOrDestroyPlayer();
+            this.onSettingsUpdated();
+        }
+        updateRenderer() {
+            const renderer = this._renderer;
+            if (this.settings.core.useWorkers &&
+                this.uiFacade.areWorkersSupported &&
+                Environment.getRenderEngineFactory(this.settings.core.engine).supportsWorkers) {
+                // switch from non-worker to worker renderer
+                if (renderer.instance instanceof ScoreRenderer) {
+                    renderer.destroy();
+                    renderer.instance = this.uiFacade.createWorkerRenderer();
                 }
             }
             else {
-                this.destroyPlayer();
+                // switch from worker to non-worker renderer
+                if (!(renderer.instance instanceof ScoreRenderer)) {
+                    renderer.destroy();
+                    renderer.instance = new ScoreRenderer(this.settings);
+                }
             }
-            this.onSettingsUpdated();
         }
         /**
          * Initiates a load of the score using the given data.
@@ -39768,30 +39893,33 @@
             }
             else {
                 const resizeEventInfo = new ResizeEventArgs();
-                resizeEventInfo.oldWidth = this.renderer.width;
+                resizeEventInfo.oldWidth = this._renderer.width;
                 resizeEventInfo.newWidth = this.container.width;
                 resizeEventInfo.settings = this.settings;
                 this.onResize(resizeEventInfo);
-                this.renderer.updateSettings(this.settings);
-                this.renderer.width = this.container.width;
-                this.renderer.resizeRender();
+                this._renderer.updateSettings(this.settings);
+                this._renderer.width = this.container.width;
+                this._renderer.resizeRender();
             }
         }
-        appendRenderResult(result) {
-            if (result) {
+        appendRenderResult(result, isLast) {
+            // resizing the canvas and wrapper elements at the end is enough
+            // it avoids flickering on resizes and re-renders. 
+            // the individual partials are anyhow sized correctly
+            if (isLast) {
                 this.canvasElement.width = result.totalWidth;
                 this.canvasElement.height = result.totalHeight;
                 if (this._cursorWrapper) {
                     this._cursorWrapper.width = result.totalWidth;
                     this._cursorWrapper.height = result.totalHeight;
                 }
-                if (result.width > 0 || result.height > 0) {
-                    this.uiFacade.beginAppendRenderResults(result);
-                }
             }
-            else {
+            if (result.width > 0 || result.height > 0) {
                 this.uiFacade.beginAppendRenderResults(result);
             }
+            if (isLast) {
+                this.uiFacade.beginAppendRenderResults(null);
+            }
         }
         updateRenderResult(result) {
             if (result && result.renderResult) {
@@ -39877,9 +40005,6 @@
          * ```
          */
         loadSoundFont(data, append = false) {
-            if (!this.player) {
-                return false;
-            }
             return this.uiFacade.loadSoundFont(data, append);
         }
         /**
@@ -39925,10 +40050,7 @@
          * ```
          */
         resetSoundFonts() {
-            if (!this.player) {
-                return;
-            }
-            this.player.resetSoundFonts();
+            this._player.resetSoundFonts();
         }
         /**
          * Initiates a re-rendering of the current setup.
@@ -39959,13 +40081,10 @@
          * ```
          */
         render() {
-            if (!this.renderer) {
-                return;
-            }
             if (this.uiFacade.canRender) {
                 // when font is finally loaded, start rendering
-                this.renderer.width = this.container.width;
-                this.renderer.renderScore(this.score, this._trackIndexes);
+                this._renderer.width = this.container.width;
+                this._renderer.renderScore(this.score, this._trackIndexes);
             }
             else {
                 this.uiFacade.canRenderChanged.on(() => this.render());
@@ -40040,7 +40159,38 @@
          * @since 1.5.0
          */
         get boundsLookup() {
-            return this.renderer.boundsLookup;
+            return this._renderer.boundsLookup;
+        }
+        /**
+         * The alphaSynth player used for playback.
+         * @remarks
+         * This is the low-level API to the Midi synthesizer used for playback.
+         * Gets access to the underling {@link IAlphaSynth} that is used for the audio playback.
+         * @category Properties - Player
+         * @since 0.9.4
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * setupPlayerEvents(api.settings);
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * SetupPlayerEvents(api.Player);
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...)
+         * setupPlayerEvents(api.player)
+         * ```
+         */
+        get player() {
+            return this._player.instance ? this._player : null;
         }
         /**
          * Whether the player is ready for starting the playback.
@@ -40071,10 +40221,7 @@
          * ```
          */
         get isReadyForPlayback() {
-            if (!this.player) {
-                return false;
-            }
-            return this.player.isReadyForPlayback;
+            return this._player.isReadyForPlayback;
         }
         /**
          * The current player state.
@@ -40104,10 +40251,7 @@
          * ```
          */
         get playerState() {
-            if (!this.player) {
-                return PlayerState.Paused;
-            }
-            return this.player.state;
+            return this._player.state;
         }
         /**
          * The current master volume as percentage (0-1).
@@ -40137,15 +40281,10 @@
          * ```
          */
         get masterVolume() {
-            if (!this.player) {
-                return 0;
-            }
-            return this.player.masterVolume;
+            return this._player.masterVolume;
         }
         set masterVolume(value) {
-            if (this.player) {
-                this.player.masterVolume = value;
-            }
+            this._player.masterVolume = value;
         }
         /**
          * The metronome volume as percentage (0-1).
@@ -40176,15 +40315,10 @@
          * ```
          */
         get metronomeVolume() {
-            if (!this.player) {
-                return 0;
-            }
-            return this.player.metronomeVolume;
+            return this._player.metronomeVolume;
         }
         set metronomeVolume(value) {
-            if (this.player) {
-                this.player.metronomeVolume = value;
-            }
+            this._player.metronomeVolume = value;
         }
         /**
          * The volume of the count-in metronome ticks.
@@ -40215,15 +40349,10 @@
          * ```
          */
         get countInVolume() {
-            if (!this.player) {
-                return 0;
-            }
-            return this.player.countInVolume;
+            return this._player.countInVolume;
         }
         set countInVolume(value) {
-            if (this.player) {
-                this.player.countInVolume = value;
-            }
+            this._player.countInVolume = value;
         }
         /**
          * The midi events which will trigger the `midiEventsPlayed` event
@@ -40282,15 +40411,10 @@
          * ```
          */
         get midiEventsPlayedFilter() {
-            if (!this.player) {
-                return [];
-            }
-            return this.player.midiEventsPlayedFilter;
+            return this._player.midiEventsPlayedFilter;
         }
         set midiEventsPlayedFilter(value) {
-            if (this.player) {
-                this.player.midiEventsPlayedFilter = value;
-            }
+            this._player.midiEventsPlayedFilter = value;
         }
         /**
          * The position within the song in midi ticks.
@@ -40318,15 +40442,10 @@
          * ```
          */
         get tickPosition() {
-            if (!this.player) {
-                return 0;
-            }
-            return this.player.tickPosition;
+            return this._player.tickPosition;
         }
         set tickPosition(value) {
-            if (this.player) {
-                this.player.tickPosition = value;
-            }
+            this._player.tickPosition = value;
         }
         /**
          * The position within the song in milliseconds
@@ -40354,15 +40473,10 @@
          * ```
          */
         get timePosition() {
-            if (!this.player) {
-                return 0;
-            }
-            return this.player.timePosition;
+            return this._player.timePosition;
         }
         set timePosition(value) {
-            if (this.player) {
-                this.player.timePosition = value;
-            }
+            this._player.timePosition = value;
         }
         /**
          * The range of the song that should be played.
@@ -40396,17 +40510,12 @@
          * ```
          */
         get playbackRange() {
-            if (!this.player) {
-                return null;
-            }
-            return this.player.playbackRange;
+            return this._player.playbackRange;
         }
         set playbackRange(value) {
-            if (this.player) {
-                this.player.playbackRange = value;
-                if (this.settings.player.enableCursor) {
-                    this.updateSelectionCursor(value);
-                }
+            this._player.playbackRange = value;
+            if (this.settings.player.enableCursor) {
+                this.updateSelectionCursor(value);
             }
         }
         /**
@@ -40438,15 +40547,10 @@
          * ```
          */
         get playbackSpeed() {
-            if (!this.player) {
-                return 0;
-            }
-            return this.player.playbackSpeed;
+            return this._player.playbackSpeed;
         }
         set playbackSpeed(value) {
-            if (this.player) {
-                this.player.playbackSpeed = value;
-            }
+            this._player.playbackSpeed = value;
         }
         /**
          * Whether the playback should automatically restart after it finished.
@@ -40477,27 +40581,21 @@
          * ```
          */
         get isLooping() {
-            if (!this.player) {
-                return false;
-            }
-            return this.player.isLooping;
+            return this._player.isLooping;
         }
         set isLooping(value) {
-            if (this.player) {
-                this.player.isLooping = value;
-            }
+            this._player.isLooping = value;
         }
         destroyPlayer() {
-            if (!this.player) {
-                return;
-            }
-            this.player.destroy();
-            this.player = null;
+            this._player.destroy();
             this._previousTick = 0;
-            this._playerState = PlayerState.Paused;
             this.destroyCursors();
         }
-        setupPlayer() {
+        /**
+         *
+         * @returns true if a new player was created, false if no player was created (includes destroy & reuse of the current one)
+         */
+        setupOrDestroyPlayer() {
             let mode = this.settings.player.playerMode;
             if (mode === exports.PlayerMode.EnabledAutomatic) {
                 const score = this.score;
@@ -40511,68 +40609,44 @@
                     mode = exports.PlayerMode.EnabledSynthesizer;
                 }
             }
+            let newPlayer = null;
             if (mode !== this._actualPlayerMode) {
                 this.destroyPlayer();
+                this.updateCursors();
+                switch (mode) {
+                    case exports.PlayerMode.Disabled:
+                        newPlayer = null;
+                        break;
+                    case exports.PlayerMode.EnabledSynthesizer:
+                        newPlayer = this.uiFacade.createWorkerPlayer();
+                        break;
+                    case exports.PlayerMode.EnabledBackingTrack:
+                        newPlayer = this.uiFacade.createBackingTrackPlayer();
+                        break;
+                    case exports.PlayerMode.EnabledExternalMedia:
+                        newPlayer = new ExternalMediaPlayer(this.settings.player.bufferTimeInMilliseconds);
+                        break;
+                }
             }
-            this.updateCursors();
-            this._actualPlayerMode = mode;
-            switch (mode) {
-                case exports.PlayerMode.Disabled:
-                    this.destroyPlayer();
-                    return false;
-                case exports.PlayerMode.EnabledSynthesizer:
-                    if (this.player) {
-                        return true;
-                    }
-                    // new player needed
-                    this.player = this.uiFacade.createWorkerPlayer();
-                    break;
-                case exports.PlayerMode.EnabledBackingTrack:
-                    if (this.player) {
-                        return true;
-                    }
-                    // new player needed
-                    this.player = this.uiFacade.createBackingTrackPlayer();
-                    break;
-                case exports.PlayerMode.EnabledExternalMedia:
-                    if (this.player) {
-                        return true;
-                    }
-                    this.player = new ExternalMediaPlayer(this.settings.player.bufferTimeInMilliseconds);
-                    break;
+            else {
+                // no change in player mode, just update song info if needed
+                this.updateCursors();
+                return false;
             }
-            if (!this.player) {
+            this._actualPlayerMode = mode;
+            if (!newPlayer) {
                 return false;
             }
-            this.player.ready.on(() => {
-                this.loadMidiForScore();
-            });
-            this.player.readyForPlayback.on(() => {
-                this.onPlayerReady();
-                if (this.tracks) {
-                    for (const track of this.tracks) {
-                        const volume = track.playbackInfo.volume / 16;
-                        this.player.setChannelVolume(track.playbackInfo.primaryChannel, volume);
-                        this.player.setChannelVolume(track.playbackInfo.secondaryChannel, volume);
-                    }
-                }
-            });
-            this.player.soundFontLoaded.on(this.onSoundFontLoaded.bind(this));
-            this.player.soundFontLoadFailed.on(e => {
-                this.onError(e);
-            });
-            this.player.midiLoaded.on(this.onMidiLoaded.bind(this));
-            this.player.midiLoadFailed.on(e => {
-                this.onError(e);
-            });
-            this.player.stateChanged.on(this.onPlayerStateChanged.bind(this));
-            this.player.positionChanged.on(this.onPlayerPositionChanged.bind(this));
-            this.player.midiEventsPlayed.on(this.onMidiEventsPlayed.bind(this));
-            this.player.playbackRangeChanged.on(this.onPlaybackRangeChanged.bind(this));
-            this.player.finished.on(this.onPlayerFinished.bind(this));
-            this.setupPlayerEvents();
+            this._player.instance = newPlayer;
             return false;
         }
+        /**
+         * Re-creates the midi for the current score and loads it.
+         * @remarks
+         * This will result in the player to stop playback. Some setting changes require re-genration of the midi song.
+         * @category Methods - Player
+         * @since 1.6.0
+         */
         loadMidiForScore() {
             if (!this.score) {
                 return;
@@ -40590,12 +40664,10 @@
             generator.generate();
             this._tickCache = generator.tickLookup;
             this.onMidiLoad(midiFile);
-            const player = this.player;
-            if (player) {
-                player.loadMidiFile(midiFile);
-                player.loadBackingTrack(score, generator.syncPoints);
-                player.applyTranspositionPitches(generator.transpositionPitches);
-            }
+            const player = this._player;
+            player.loadMidiFile(midiFile);
+            player.loadBackingTrack(score, generator.syncPoints);
+            player.applyTranspositionPitches(generator.transpositionPitches);
         }
         /**
          * Changes the volume of the given tracks.
@@ -40633,12 +40705,9 @@
          * ```
          */
         changeTrackVolume(tracks, volume) {
-            if (!this.player) {
-                return;
-            }
             for (const track of tracks) {
-                this.player.setChannelVolume(track.playbackInfo.primaryChannel, volume);
-                this.player.setChannelVolume(track.playbackInfo.secondaryChannel, volume);
+                this._player.setChannelVolume(track.playbackInfo.primaryChannel, volume);
+                this._player.setChannelVolume(track.playbackInfo.secondaryChannel, volume);
             }
         }
         /**
@@ -40675,12 +40744,9 @@
          * ```
          */
         changeTrackSolo(tracks, solo) {
-            if (!this.player) {
-                return;
-            }
             for (const track of tracks) {
-                this.player.setChannelSolo(track.playbackInfo.primaryChannel, solo);
-                this.player.setChannelSolo(track.playbackInfo.secondaryChannel, solo);
+                this._player.setChannelSolo(track.playbackInfo.primaryChannel, solo);
+                this._player.setChannelSolo(track.playbackInfo.secondaryChannel, solo);
             }
         }
         /**
@@ -40716,12 +40782,9 @@
          * ```
          */
         changeTrackMute(tracks, mute) {
-            if (!this.player) {
-                return;
-            }
             for (const track of tracks) {
-                this.player.setChannelMute(track.playbackInfo.primaryChannel, mute);
-                this.player.setChannelMute(track.playbackInfo.secondaryChannel, mute);
+                this._player.setChannelMute(track.playbackInfo.primaryChannel, mute);
+                this._player.setChannelMute(track.playbackInfo.secondaryChannel, mute);
             }
         }
         /**
@@ -40759,12 +40822,9 @@
          * ```
          */
         changeTrackTranspositionPitch(tracks, semitones) {
-            if (!this.player) {
-                return;
-            }
             for (const track of tracks) {
-                this.player.setChannelTranspositionPitch(track.playbackInfo.primaryChannel, semitones);
-                this.player.setChannelTranspositionPitch(track.playbackInfo.secondaryChannel, semitones);
+                this._player.setChannelTranspositionPitch(track.playbackInfo.primaryChannel, semitones);
+                this._player.setChannelTranspositionPitch(track.playbackInfo.secondaryChannel, semitones);
             }
         }
         /**
@@ -40795,10 +40855,7 @@
          * ```
          */
         play() {
-            if (!this.player) {
-                return false;
-            }
-            return this.player.play();
+            return this._player.play();
         }
         /**
          * Pauses the playback of the current song.
@@ -40827,10 +40884,7 @@
          * ```
          */
         pause() {
-            if (!this.player) {
-                return;
-            }
-            this.player.pause();
+            this._player.pause();
         }
         /**
          * Toggles between play/pause depending on the current player state.
@@ -40861,10 +40915,7 @@
          * ```
          */
         playPause() {
-            if (!this.player) {
-                return;
-            }
-            this.player.playPause();
+            this._player.playPause();
         }
         /**
          * Stops the playback of the current song, and moves the playback position back to the start.
@@ -40895,10 +40946,7 @@
          * ```
          */
         stop() {
-            if (!this.player) {
-                return;
-            }
-            this.player.stop();
+            this._player.stop();
         }
         /**
          * Triggers the play of the given beat.
@@ -40934,15 +40982,12 @@
          * ```
          */
         playBeat(beat) {
-            if (!this.player) {
-                return;
-            }
             // we generate a new midi file containing only the beat
             const midiFile = new MidiFile();
             const handler = new AlphaSynthMidiFileHandler(midiFile);
             const generator = new MidiFileGenerator(beat.voice.bar.staff.track.score, this.settings, handler);
             generator.generateSingleBeat(beat);
-            this.player.playOneTimeMidiFile(midiFile);
+            this._player.playOneTimeMidiFile(midiFile);
         }
         /**
          * Triggers the play of the given note.
@@ -40977,15 +41022,12 @@
          * ```
          */
         playNote(note) {
-            if (!this.player) {
-                return;
-            }
             // we generate a new midi file containing only the beat
             const midiFile = new MidiFile();
             const handler = new AlphaSynthMidiFileHandler(midiFile);
             const generator = new MidiFileGenerator(note.beat.voice.bar.staff.track.score, this.settings, handler);
             generator.generateSingleNote(note);
-            this.player.playOneTimeMidiFile(midiFile);
+            this._player.playOneTimeMidiFile(midiFile);
         }
         destroyCursors() {
             if (!this._cursorWrapper) {
@@ -41008,6 +41050,7 @@
                     this._barCursor = cursors.barCursor;
                     this._beatCursor = cursors.beatCursor;
                     this._selectionWrapper = cursors.selectionWrapper;
+                    this._isInitialBeatCursorUpdate = true;
                 }
                 if (this._currentBeat !== null) {
                     this.cursorUpdateBeat(this._currentBeat, false, this._previousTick > 10, 1, true);
@@ -41017,36 +41060,6 @@
                 this.destroyCursors();
             }
         }
-        setupPlayerEvents() {
-            //
-            // Hook into events
-            this._previousTick = 0;
-            this._playerState = PlayerState.Paused;
-            // we need to update our position caches if we render a tablature
-            this.renderer.postRenderFinished.on(() => {
-                this._currentBeat = null;
-                this.cursorUpdateTick(this._previousTick, false, 1, this._previousTick > 10);
-            });
-            if (this.player) {
-                this.player.positionChanged.on(e => {
-                    this._previousTick = e.currentTick;
-                    this.uiFacade.beginInvoke(() => {
-                        const cursorSpeed = e.modifiedTempo / e.originalTempo;
-                        this.cursorUpdateTick(e.currentTick, false, cursorSpeed, false, e.isSeek);
-                    });
-                });
-                this.player.stateChanged.on(e => {
-                    this._playerState = e.state;
-                    if (!e.stopped && e.state === PlayerState.Paused) {
-                        const currentBeat = this._currentBeat;
-                        const tickCache = this._tickCache;
-                        if (currentBeat && tickCache) {
-                            this.player.tickPosition = tickCache.getBeatStart(currentBeat.beat);
-                        }
-                    }
-                });
-            }
-        }
         /**
          * updates the cursors to highlight the beat at the specified tick position
          * @param tick
@@ -41077,7 +41090,7 @@
             if (!beat) {
                 return;
             }
-            const cache = this.renderer.boundsLookup;
+            const cache = this._renderer.boundsLookup;
             if (!cache) {
                 return;
             }
@@ -41087,7 +41100,7 @@
             if (!forceUpdate &&
                 beat === previousBeat?.beat &&
                 cache === previousCache &&
-                previousState === this._playerState &&
+                previousState === this._player.state &&
                 previousBeat?.start === lookupResult.start) {
                 return;
             }
@@ -41099,7 +41112,7 @@
             // actually show the cursor
             this._currentBeat = lookupResult;
             this._previousCursorCache = cache;
-            this._previousStateForCursor = this._playerState;
+            this._previousStateForCursor = this._player.state;
             this.uiFacade.beginInvoke(() => {
                 this.internalCursorUpdateBeat(beat, nextBeat, duration, stop, beatsToHighlight, cache, beatBoundings, shouldScroll, lookupResult.cursorMode, cursorSpeed);
             });
@@ -41110,9 +41123,9 @@
          * @category Methods - Player
          */
         scrollToCursor() {
-            const barBounds = this._currentBarBounds;
-            if (barBounds) {
-                this.internalScrollToCursor(barBounds);
+            const beatBounds = this._currentBeatBounds;
+            if (beatBounds) {
+                this.internalScrollToCursor(beatBounds.barBounds.masterBarBounds);
             }
         }
         internalScrollToCursor(barBoundings) {
@@ -41171,10 +41184,12 @@
             const beatCursor = this._beatCursor;
             const barBoundings = beatBoundings.barBounds.masterBarBounds;
             const barBounds = barBoundings.visualBounds;
-            this._currentBarBounds = barBoundings;
+            const previousBeatBounds = this._currentBeatBounds;
+            this._currentBeatBounds = beatBoundings;
             if (barCursor) {
                 barCursor.setBounds(barBounds.x, barBounds.y, barBounds.w, barBounds.h);
             }
+            const isPlayingUpdate = this._player.state === PlayerState.Playing && !stop;
             let nextBeatX = barBoundings.visualBounds.x + barBoundings.visualBounds.w;
             // get position of next beat on same system
             if (nextBeat && cursorMode === MidiTickLookupFindBeatResultCursorMode.ToNextBext) {
@@ -41192,20 +41207,49 @@
                 if (this.settings.player.enableAnimatedBeatCursor) {
                     const animationWidth = nextBeatX - beatBoundings.onNotesX;
                     const relativePosition = this._previousTick - this._currentBeat.start;
-                    const ratioPosition = relativePosition / this._currentBeat.tickDuration;
+                    const ratioPosition = this._currentBeat.tickDuration > 0 ? relativePosition / this._currentBeat.tickDuration : 0;
                     startBeatX = beatBoundings.onNotesX + animationWidth * ratioPosition;
                     duration -= duration * ratioPosition;
+                    if (isPlayingUpdate) {
+                        // we do not "reset" the cursor if we are smoothly moving from left to right.
+                        const jumpCursor = !previousBeatBounds ||
+                            this._isInitialBeatCursorUpdate ||
+                            barBounds.y !== previousBeatBounds.barBounds.masterBarBounds.visualBounds.y ||
+                            startBeatX < previousBeatBounds.onNotesX ||
+                            barBoundings.index > previousBeatBounds.barBounds.masterBarBounds.index + 1;
+                        if (jumpCursor) {
+                            beatCursor.transitionToX(0, startBeatX);
+                            beatCursor.setBounds(startBeatX, barBounds.y, 1, barBounds.h);
+                        }
+                        // we need to put the transition to an own animation frame
+                        // otherwise the stop animation above is not applied.
+                        this.uiFacade.beginInvoke(() => {
+                            // it can happen that the cursor reaches the target position slightly too early (especially on backing tracks)
+                            // to avoid the cursor stopping, causing a wierd look, we animate the cursor to the double position in double time.
+                            // beatCursor!.transitionToX((duration / cursorSpeed), nextBeatX);
+                            const doubleEndBeatX = startBeatX + (nextBeatX - startBeatX) * 2;
+                            beatCursor.transitionToX((duration / cursorSpeed) * 2, doubleEndBeatX);
+                        });
+                    }
+                    else {
+                        beatCursor.transitionToX(0, startBeatX);
+                        beatCursor.setBounds(startBeatX, barBounds.y, 1, barBounds.h);
+                    }
+                }
+                else {
+                    // ticking cursor
                     beatCursor.transitionToX(0, startBeatX);
+                    beatCursor.setBounds(startBeatX, barBounds.y, 1, barBounds.h);
                 }
-                beatCursor.setBounds(startBeatX, barBounds.y, 1, barBounds.h);
+                this._isInitialBeatCursorUpdate = false;
             }
-            // if playing, animate the cursor to the next beat
-            if (this.settings.player.enableElementHighlighting) {
-                this.uiFacade.removeHighlights();
+            else {
+                this._isInitialBeatCursorUpdate = true;
             }
+            // if playing, animate the cursor to the next beat
+            this.uiFacade.removeHighlights();
             // actively playing? -> animate cursor and highlight items
             let shouldNotifyBeatChange = false;
-            const isPlayingUpdate = this._playerState === PlayerState.Playing && !stop;
             if (isPlayingUpdate) {
                 if (this.settings.player.enableElementHighlighting) {
                     for (const highlight of beatsToHighlight) {
@@ -41216,15 +41260,6 @@
                 shouldScroll = !stop;
                 shouldNotifyBeatChange = true;
             }
-            if (this.settings.player.enableAnimatedBeatCursor && beatCursor) {
-                if (isPlayingUpdate) {
-                    // we need to put the transition to an own animation frame
-                    // otherwise the stop animation above is not applied.
-                    this.uiFacade.beginInvoke(() => {
-                        beatCursor.transitionToX(duration / cursorSpeed, nextBeatX);
-                    });
-                }
-            }
             if (shouldScroll && !this._beatMouseDown && this.settings.player.scrollMode !== exports.ScrollMode.Off) {
                 this.internalScrollToCursor(barBoundings);
             }
@@ -41314,7 +41349,7 @@
                     const realMasterBarStart = tickCache.getMasterBarStart(this._selectionStart.beat.voice.bar.masterBar);
                     // move to selection start
                     this._currentBeat = null; // reset current beat so it is updating the cursor
-                    if (this._playerState === PlayerState.Paused) {
+                    if (this._player.state === PlayerState.Paused) {
                         this.cursorUpdateTick(this._tickCache.getBeatStart(this._selectionStart.beat), false, 1);
                     }
                     this.tickPosition = realMasterBarStart + this._selectionStart.beat.playbackStart;
@@ -41376,11 +41411,11 @@
                 }
                 const relX = e.getX(this.canvasElement);
                 const relY = e.getY(this.canvasElement);
-                const beat = this.renderer.boundsLookup?.getBeatAtPos(relX, relY) ?? null;
+                const beat = this._renderer.boundsLookup?.getBeatAtPos(relX, relY) ?? null;
                 if (beat) {
                     this.onBeatMouseDown(e, beat);
                     if (this.settings.core.includeNoteBounds) {
-                        const note = this.renderer.boundsLookup?.getNoteAtPos(beat, relX, relY);
+                        const note = this._renderer.boundsLookup?.getNoteAtPos(beat, relX, relY);
                         if (note) {
                             this.onNoteMouseDown(e, note);
                         }
@@ -41393,11 +41428,11 @@
                 }
                 const relX = e.getX(this.canvasElement);
                 const relY = e.getY(this.canvasElement);
-                const beat = this.renderer.boundsLookup?.getBeatAtPos(relX, relY) ?? null;
+                const beat = this._renderer.boundsLookup?.getBeatAtPos(relX, relY) ?? null;
                 if (beat) {
                     this.onBeatMouseMove(e, beat);
                     if (this._noteMouseDown) {
-                        const note = this.renderer.boundsLookup?.getNoteAtPos(beat, relX, relY);
+                        const note = this._renderer.boundsLookup?.getNoteAtPos(beat, relX, relY);
                         if (note) {
                             this.onNoteMouseMove(e, note);
                         }
@@ -41413,11 +41448,11 @@
                 }
                 const relX = e.getX(this.canvasElement);
                 const relY = e.getY(this.canvasElement);
-                const beat = this.renderer.boundsLookup?.getBeatAtPos(relX, relY) ?? null;
+                const beat = this._renderer.boundsLookup?.getBeatAtPos(relX, relY) ?? null;
                 this.onBeatMouseUp(e, beat);
                 if (this._noteMouseDown) {
                     if (beat) {
-                        const note = this.renderer.boundsLookup?.getNoteAtPos(beat, relX, relY) ?? null;
+                        const note = this._renderer.boundsLookup?.getNoteAtPos(beat, relX, relY) ?? null;
                         this.onNoteMouseUp(e, note);
                     }
                     else {
@@ -41425,7 +41460,7 @@
                     }
                 }
             });
-            this.renderer.postRenderFinished.on(() => {
+            this._renderer.postRenderFinished.on(() => {
                 if (!this._selectionStart ||
                     this.settings.player.playerMode === exports.PlayerMode.Disabled ||
                     !this.settings.player.enableCursor ||
@@ -41436,7 +41471,7 @@
             });
         }
         cursorSelectRange(startBeat, endBeat) {
-            const cache = this.renderer.boundsLookup;
+            const cache = this._renderer.boundsLookup;
             if (!cache) {
                 return;
             }
@@ -41505,7 +41540,8 @@
             }
             this.scoreLoaded.trigger(score);
             this.uiFacade.triggerEvent(this.container, 'scoreLoaded', score);
-            if (this.setupPlayer()) {
+            if (!this.setupOrDestroyPlayer()) {
+                // feed midi into current player (a new player will trigger a midi generation once the player is ready)
                 this.loadMidiForScore();
             }
         }
@@ -41534,6 +41570,8 @@
             if (this._isDestroyed) {
                 return;
             }
+            this._currentBeat = null;
+            this.cursorUpdateTick(this._previousTick, false, 1, true, true);
             this.postRenderFinished.trigger();
             this.uiFacade.triggerEvent(this.container, 'postRenderFinished', null);
         }
@@ -41548,25 +41586,155 @@
             this.error.trigger(error);
             this.uiFacade.triggerEvent(this.container, 'error', error);
         }
+        /**
+         * This event is fired when all required data for playback is loaded and ready.
+         * @remarks
+         * This event is fired when all required data for playback is loaded and ready. The player is ready for playback when
+         * all background workers are started, the audio output is initialized, a soundfont is loaded, and a song was loaded into the player as midi file.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 0.9.4
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.playerReady.on(() => {
+         *     enablePlayerControls();
+         * });
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.PlayerReady.On(() =>
+         * {
+         *     EnablePlayerControls()
+         * });
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...)
+         * api.playerReady.on {
+         *     enablePlayerControls()
+         * }
+         * ```
+         */
+        get playerReady() {
+            return this._player.readyForPlayback;
+        }
         onPlayerReady() {
             if (this._isDestroyed) {
                 return;
             }
-            this.playerReady.trigger();
             this.uiFacade.triggerEvent(this.container, 'playerReady', null);
         }
+        /**
+         * This event is fired when the playback of the whole song finished.
+         * @remarks
+         * This event is finished regardless on whether looping is enabled or not.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 0.9.4
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.playerFinished.on((args) => {
+         *     // speed trainer
+         *     api.playbackSpeed = Math.min(1.0, api.playbackSpeed + 0.1);
+         * });
+         * api.isLooping = true;
+         * api.playbackSpeed = 0.5;
+         * api.play()
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.PlayerFinished.On(() =>
+         * {
+         *     // speed trainer
+         *     api.PlaybackSpeed = Math.Min(1.0, api.PlaybackSpeed + 0.1);
+         * });
+         * api.IsLooping = true;
+         * api.PlaybackSpeed = 0.5;
+         * api.Play();
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...)
+         * api.playerFinished.on {
+         *     // speed trainer
+         *     api.playbackSpeed = min(1.0, api.playbackSpeed + 0.1);
+         * }
+         * api.isLooping = true
+         * api.playbackSpeed = 0.5
+         * api.play()
+         * ```
+         *
+         */
+        get playerFinished() {
+            return this._player.finished;
+        }
         onPlayerFinished() {
             if (this._isDestroyed) {
                 return;
             }
-            this.playerFinished.trigger();
             this.uiFacade.triggerEvent(this.container, 'playerFinished', null);
         }
+        /**
+         * This event is fired when the SoundFont needed for playback was loaded.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 0.9.4
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.soundFontLoaded.on(() => {
+         *     hideSoundFontLoadingIndicator();
+         * });
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.SoundFontLoaded.On(() =>
+         * {
+         *     HideSoundFontLoadingIndicator();
+         * });
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...);
+         * api.soundFontLoaded.on {
+         *     hideSoundFontLoadingIndicator();
+         * }
+         * ```
+         *
+         */
+        get soundFontLoaded() {
+            return this._player.soundFontLoaded;
+        }
         onSoundFontLoaded() {
             if (this._isDestroyed) {
                 return;
             }
-            this.soundFontLoaded.trigger();
             this.uiFacade.triggerEvent(this.container, 'soundFontLoaded', null);
         }
         onMidiLoad(e) {
@@ -41583,34 +41751,255 @@
             this.midiLoaded.trigger(e);
             this.uiFacade.triggerEvent(this.container, 'midiFileLoaded', e);
         }
+        /**
+         * This event is fired when the playback state changed.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 0.9.4
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.playerStateChanged.on((args) => {
+         *     updatePlayerControls(args.state, args.stopped);
+         * });
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.PlayerStateChanged.On(args =>
+         * {
+         *     UpdatePlayerControls(args);
+         * });
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...)
+         * api.playerStateChanged.on { args ->
+         *     updatePlayerControls(args)
+         * }
+         * ```
+         *
+         */
+        get playerStateChanged() {
+            return this._player.stateChanged;
+        }
         onPlayerStateChanged(e) {
             if (this._isDestroyed) {
                 return;
             }
-            this.playerStateChanged.trigger(e);
+            if (!e.stopped && e.state === PlayerState.Paused) {
+                const currentBeat = this._currentBeat;
+                const tickCache = this._tickCache;
+                if (currentBeat && tickCache) {
+                    this._player.tickPosition = tickCache.getBeatStart(currentBeat.beat);
+                }
+            }
             this.uiFacade.triggerEvent(this.container, 'playerStateChanged', e);
         }
+        /**
+         * This event is fired when the current playback position of the song changed.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 0.9.4
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.playerPositionChanged.on((args) => {
+         *     updatePlayerPosition(args);
+         * });
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.PlayerPositionChanged.On(args =>
+         * {
+         *     UpdatePlayerPosition(args);
+         * });
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...)
+         * api.playerPositionChanged.on { args ->
+         *     updatePlayerPosition(args)
+         * }
+         * ```
+         *
+         */
+        get playerPositionChanged() {
+            return this._player.positionChanged;
+        }
         onPlayerPositionChanged(e) {
             if (this._isDestroyed) {
                 return;
             }
-            if (this.score !== null && this.tracks.length > 0) {
-                this.playerPositionChanged.trigger(e);
-                this.uiFacade.triggerEvent(this.container, 'playerPositionChanged', e);
-            }
+            this._previousTick = e.currentTick;
+            this.uiFacade.beginInvoke(() => {
+                const cursorSpeed = e.modifiedTempo / e.originalTempo;
+                this.cursorUpdateTick(e.currentTick, false, cursorSpeed, false, e.isSeek);
+            });
+            this.uiFacade.triggerEvent(this.container, 'playerPositionChanged', e);
+        }
+        /**
+         * This event is fired when the synthesizer played certain midi events.
+         *
+         * @remarks
+         * This event is fired when the synthesizer played certain midi events. This allows reacing on various low level
+         * audio playback elements like notes/rests played or metronome ticks.
+         *
+         * Refer to the [related guide](https://www.alphatab.net/docs/guides/handling-midi-events) to learn more about this feature.
+         *
+         * Also note that the provided data models changed significantly in {@version 1.3.0}. We try to provide backwards compatibility
+         * until some extend but highly encourage changing to the new models in case of problems.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 1.2.0
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.midiEventsPlayedFilter = [alphaTab.midi.MidiEventType.AlphaTabMetronome];
+         * api.midiEventsPlayed.on(function(e) {
+         *   for(const midi of e.events) {
+         *     if(midi.isMetronome) {
+         *       console.log('Metronome tick ' + midi.tick);
+         *     }
+         *   }
+         * });
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.MidiEventsPlayedFilter = new MidiEventType[] { AlphaTab.Midi.MidiEventType.AlphaTabMetronome };
+         * api.MidiEventsPlayed.On(e =>
+         * {
+         *   foreach(var midi of e.events)
+         *   {
+         *     if(midi is AlphaTab.Midi.AlphaTabMetronomeEvent sysex && sysex.IsMetronome)
+         *     {
+         *       Console.WriteLine("Metronome tick " + midi.Tick);
+         *     }
+         *   }
+         * });
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...);
+         * api.midiEventsPlayedFilter = alphaTab.collections.List<alphaTab.midi.MidiEventType>( alphaTab.midi.MidiEventType.AlphaTabMetronome )
+         * api.midiEventsPlayed.on { e ->
+         *   for (midi in e.events) {
+         *     if(midi instanceof alphaTab.midi.AlphaTabMetronomeEvent && midi.isMetronome) {
+         *       println("Metronome tick " + midi.tick);
+         *     }
+         *   }
+         * }
+         * ```
+         * @see {@link MidiEvent}
+         * @see {@link TimeSignatureEvent}
+         * @see {@link AlphaTabMetronomeEvent}
+         * @see {@link AlphaTabRestEvent}
+         * @see {@link NoteOnEvent}
+         * @see {@link NoteOffEvent}
+         * @see {@link ControlChangeEvent}
+         * @see {@link ProgramChangeEvent}
+         * @see {@link TempoChangeEvent}
+         * @see {@link PitchBendEvent}
+         * @see {@link NoteBendEvent}
+         * @see {@link EndOfTrackEvent}
+         * @see {@link MetaEvent}
+         * @see {@link MetaDataEvent}
+         * @see {@link MetaNumberEvent}
+         * @see {@link Midi20PerNotePitchBendEvent}
+         * @see {@link SystemCommonEvent}
+         * @see {@link SystemExclusiveEvent}
+         */
+        get midiEventsPlayed() {
+            return this._player.midiEventsPlayed;
         }
         onMidiEventsPlayed(e) {
             if (this._isDestroyed) {
                 return;
             }
-            this.midiEventsPlayed.trigger(e);
             this.uiFacade.triggerEvent(this.container, 'midiEventsPlayed', e);
         }
+        /**
+         * This event is fired when the playback range changed.
+         *
+         * @eventProperty
+         * @category Events - Player
+         * @since 1.2.3
+         *
+         * @example
+         * JavaScript
+         * ```js
+         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
+         * api.playbackRangeChanged.on((args) => {
+         *     if (args.playbackRange) {
+         *         highlightRangeInProgressBar(args.playbackRange.startTick, args.playbackRange.endTick);
+         *     } else {
+         *         clearHighlightInProgressBar();
+         *     }
+         * });
+         * ```
+         *
+         * @example
+         * C#
+         * ```cs
+         * var api = new AlphaTabApi<MyControl>(...);
+         * api.PlaybackRangeChanged.On(args =>
+         * {
+         *     if (args.PlaybackRange != null)
+         *     {
+         *         HighlightRangeInProgressBar(args.PlaybackRange.StartTick, args.PlaybackRange.EndTick);
+         *     }
+         *     else
+         *     {
+         *         ClearHighlightInProgressBar();
+         *     }
+         * });
+         * ```
+         *
+         * @example
+         * Android
+         * ```kotlin
+         * val api = AlphaTabApi<MyControl>(...)
+         * api.playbackRangeChanged.on { args ->
+         *     val playbackRange = args.playbackRange
+         *     if (playbackRange != null) {
+         *         highlightRangeInProgressBar(playbackRange.startTick, playbackRange.endTick)
+         *     } else {
+         *         clearHighlightInProgressBar()
+         *     }
+         * }
+         * ```
+         *
+         */
+        get playbackRangeChanged() {
+            return this._player.playbackRangeChanged;
+        }
         onPlaybackRangeChanged(e) {
             if (this._isDestroyed) {
                 return;
             }
-            this.playbackRangeChanged.trigger(e);
             this.uiFacade.triggerEvent(this.container, 'playbackRangeChanged', e);
         }
         onSettingsUpdated() {
@@ -41672,10 +42061,7 @@
          * ```
          */
         async enumerateOutputDevices() {
-            if (this.player) {
-                return await this.player.output.enumerateOutputDevices();
-            }
-            return [];
+            return await this._player.output.enumerateOutputDevices();
         }
         /**
          * Changes the output device which should be used for playing the audio (player must be enabled).
@@ -41726,9 +42112,7 @@
          * ```
          */
         async setOutputDevice(device) {
-            if (this.player) {
-                await this.player.output.setOutputDevice(device);
-            }
+            await this._player.output.setOutputDevice(device);
         }
         /**
          * The currently configured output device if changed via {@link setOutputDevice}.
@@ -41768,10 +42152,7 @@
          *
          */
         async getOutputDevice() {
-            if (this.player) {
-                return await this.player.output.getOutputDevice();
-            }
-            return null;
+            return await this._player.output.getOutputDevice();
         }
     }
 
@@ -41948,38 +42329,52 @@
             this.element = element;
             this.mouseDown = {
                 on: (value) => {
-                    this.element.addEventListener('mousedown', e => {
+                    const nativeListener = e => {
                         value(new BrowserMouseEventArgs(e));
-                    }, true);
+                    };
+                    this.element.addEventListener('mousedown', nativeListener, true);
+                    return () => {
+                        this.element.removeEventListener('mousedown', nativeListener, true);
+                    };
                 },
                 off: (value) => {
                 }
             };
             this.mouseUp = {
                 on: (value) => {
-                    this.element.addEventListener('mouseup', e => {
+                    const nativeListener = e => {
                         value(new BrowserMouseEventArgs(e));
-                    }, true);
+                    };
+                    this.element.addEventListener('mouseup', nativeListener, true);
+                    return () => {
+                        this.element.removeEventListener('mouseup', nativeListener, true);
+                    };
                 },
                 off: (value) => {
                 }
             };
             this.mouseMove = {
                 on: (value) => {
-                    this.element.addEventListener('mousemove', e => {
+                    const nativeListener = e => {
                         value(new BrowserMouseEventArgs(e));
-                    }, true);
+                    };
+                    this.element.addEventListener('mousemove', nativeListener, true);
+                    return () => {
+                        this.element.removeEventListener('mousemove', nativeListener, true);
+                    };
                 },
                 off: (_) => {
                 }
             };
+            const container = this;
             this.resize = {
-                on: (value) => {
-                    if (this._resizeListeners === 0) {
-                        HtmlElementContainer.resizeObserver.value.observe(this.element);
+                on: function (value) {
+                    if (container._resizeListeners === 0) {
+                        HtmlElementContainer.resizeObserver.value.observe(container.element);
                     }
-                    this.element.addEventListener('resize', value, true);
-                    this._resizeListeners++;
+                    container.element.addEventListener('resize', value, true);
+                    container._resizeListeners++;
+                    return () => this.off(value);
                 },
                 off: (value) => {
                     this.element.removeEventListener('resize', value, true);
@@ -42560,21 +42955,6 @@
         }
     }
 
-    /**
-     * Represents the progress of any data being loaded.
-     */
-    class ProgressEventArgs {
-        /**
-         * Initializes a new instance of the {@link ProgressEventArgs} class.
-         * @param loaded
-         * @param total
-         */
-        constructor(loaded, total) {
-            this.loaded = loaded;
-            this.total = total;
-        }
-    }
-
     /**
      * a WebWorker based alphaSynth which uses the given player as output.
      * @target web
@@ -42811,25 +43191,6 @@
                 append: append
             });
         }
-        loadSoundFontFromUrl(url, append, progress) {
-            Logger.debug('AlphaSynth', `Start loading Soundfont from url ${url}`);
-            const request = new XMLHttpRequest();
-            request.open('GET', url, true, null, null);
-            request.responseType = 'arraybuffer';
-            request.onload = _ => {
-                const buffer = new Uint8Array(request.response);
-                this.loadSoundFont(buffer, append);
-            };
-            request.onerror = e => {
-                Logger.error('AlphaSynth', `Loading failed: ${e.message}`);
-                this.soundFontLoadFailed.trigger(new FileLoadError(e.message, request));
-            };
-            request.onprogress = e => {
-                Logger.debug('AlphaSynth', `Soundfont downloading: ${e.loaded}/${e.total} bytes`);
-                progress(new ProgressEventArgs(e.loaded, e.total));
-            };
-            request.send();
-        }
         resetSoundFonts() {
             this._synth.postMessage({
                 cmd: 'alphaSynth.resetSoundFonts'
@@ -43381,7 +43742,11 @@
             }
             this._padding = backingTrack.padding / 1000;
             const blob = new Blob([backingTrack.rawAudioFile]);
+            // https://html.spec.whatwg.org/multipage/media.html#loading-the-media-resource
+            // Step 8. resets the playbackRate, we need to remember and restore it. 
+            const playbackRate = this.audioElement.playbackRate;
             this.audioElement.src = URL.createObjectURL(blob);
+            this.audioElement.playbackRate = playbackRate;
         }
         open(_bufferTimeInMilliseconds) {
             const audioElement = document.createElement('audio');
@@ -44100,6 +44465,21 @@
         }
     }
 
+    /**
+     * Represents the progress of any data being loaded.
+     */
+    class ProgressEventArgs {
+        /**
+         * Initializes a new instance of the {@link ProgressEventArgs} class.
+         * @param loaded
+         * @param total
+         */
+        constructor(loaded, total) {
+            this.loaded = loaded;
+            this.total = total;
+        }
+    }
+
     /**
      * @target web
      */
@@ -44343,13 +44723,29 @@
          * @since 0.9.4
          */
         loadSoundFontFromUrl(url, append) {
-            if (!this.player) {
+            const player = this.player;
+            if (!player) {
                 return;
             }
-            this.player.loadSoundFontFromUrl(url, append, e => {
-                this.soundFontLoad.trigger(e);
-                this.uiFacade.triggerEvent(this.container, 'soundFontLoad', e);
-            });
+            Logger.debug('AlphaSynth', `Start loading Soundfont from url ${url}`);
+            const request = new XMLHttpRequest();
+            request.open('GET', url, true, null, null);
+            request.responseType = 'arraybuffer';
+            request.onload = _ => {
+                const buffer = new Uint8Array(request.response);
+                this.loadSoundFont(buffer, append);
+            };
+            request.onerror = e => {
+                Logger.error('AlphaSynth', `Loading failed: ${e.message}`);
+                player.soundFontLoadFailed.trigger(new FileLoadError(e.message, request));
+            };
+            request.onprogress = e => {
+                Logger.debug('AlphaSynth', `Soundfont downloading: ${e.loaded}/${e.total} bytes`);
+                const args = new ProgressEventArgs(e.loaded, e.total);
+                this.soundFontLoad.trigger(args);
+                this.uiFacade.triggerEvent(this.container, 'soundFontLoad', args);
+            };
+            request.send();
         }
     }
 
@@ -46731,7 +47127,7 @@
             return this.masterBarsRenderers[0].masterBar.index;
         }
         get lastBarIndex() {
-            return this.masterBarsRenderers[this.masterBarsRenderers.length - 1].masterBar.index;
+            return this.masterBarsRenderers[this.masterBarsRenderers.length - 1].lastMasterBarIndex;
         }
         addMasterBarRenderers(tracks, renderers) {
             if (tracks.length === 0) {
@@ -47545,6 +47941,9 @@
                         }
                     }
                 }
+                else {
+                    this.tuningGlyph = null;
+                }
             }
             // chord diagram glyphs
             if (notation.isNotationElementVisible(exports.NotationElement.ChordDiagrams)) {
@@ -47573,6 +47972,12 @@
                         }
                     }
                 }
+                if (this.chordDiagrams.isEmpty) {
+                    this.chordDiagrams = null;
+                }
+            }
+            else {
+                this.chordDiagrams = null;
             }
         }
         createEmptyStaffSystem() {
@@ -60316,9 +60721,9 @@
             print(`build date: ${VersionInfo.date}`);
         }
     }
-    VersionInfo.version = '1.6.0-alpha.1408';
-    VersionInfo.date = '2025-05-13T02:08:06.970Z';
-    VersionInfo.commit = '37b936b4f5eb8bf759bc78bdb4dd1812d7b2a072';
+    VersionInfo.version = '1.6.0-alpha.1415';
+    VersionInfo.date = '2025-05-19T16:08:22.342Z';
+    VersionInfo.commit = '459db69f8896a2ea8822ce5d49dcc824edd36521';
 
     /**
      * A factory for custom layout engines.