@coderline/alphatab 1.3.0-alpha.870 → 1.3.0-alpha.873

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /**
- * alphaTab v1.3.0-alpha.870 (develop, build 870)
+ * alphaTab v1.3.0-alpha.873 (develop, build 873)
  * 
  * Copyright © 2023, Daniel Kuschny and Contributors, All rights reserved.
  * 
@@ -16810,38 +16810,61 @@
     }
 
     /**
-     * Represents the time period, for which a {@link Beat} is played.
+     * Represents the time period, for which one or multiple {@link Beat}s are played
      */
     class BeatTickLookup {
-        constructor() {
+        /**
+         * Gets the tick duration of this lookup.
+         */
+        get duration() {
+            return this.end - this.start;
+        }
+        constructor(start, end) {
             this._highlightedBeats = new Map();
             /**
-             * Gets or sets the index of the lookup within the parent MasterBarTickLookup.
-             */
-            this.index = 0;
-            /**
-             * Gets or sets the start time in midi ticks at which the given beat is played.
-             */
-            this.start = 0;
-            /**
-             * Gets or sets the end time in midi ticks at which the given beat is played.
+             * Gets or sets a list of all beats that should be highlighted when
+             * the beat of this lookup starts playing. This might not mean
+             * the beats start at this position.
              */
-            this.end = 0;
+            this.highlightedBeats = [];
             /**
-             * Gets or sets whether the beat is the placeholder beat for an empty bar.
+             * Gets the next BeatTickLookup which comes after this one and is in the same
+             * MasterBarTickLookup.
              */
-            this.isEmptyBar = false;
+            this.nextBeat = null;
             /**
-             * Gets or sets a list of all beats that should be highlighted when
-             * the beat of this lookup starts playing.
+             * Gets the preivous BeatTickLookup which comes before this one and is in the same
+             * MasterBarTickLookup.
              */
-            this.beatsToHighlight = [];
+            this.previousBeat = null;
+            this.start = start;
+            this.end = end;
         }
+        /**
+         * Marks the given beat as highlighed as part of this lookup.
+         * @param beat The beat to add.
+         */
         highlightBeat(beat) {
+            if (beat.isEmpty) {
+                return;
+            }
             if (!this._highlightedBeats.has(beat.id)) {
                 this._highlightedBeats.set(beat.id, true);
-                this.beatsToHighlight.push(beat);
+                this.highlightedBeats.push(beat);
+            }
+        }
+        /**
+         * Looks for the first visible beat which starts at this lookup so it can be used for cursor placement.
+         * @param visibleTracks The visible tracks.
+         * @returns The first beat which is visible according to the given tracks or null.
+         */
+        getVisibleBeatAtStart(visibleTracks) {
+            for (const b of this.highlightedBeats) {
+                if (b.playbackStart == this.start && visibleTracks.has(b.voice.bar.staff.track.index)) {
+                    return b;
+                }
             }
+            return null;
         }
     }
 
@@ -16862,32 +16885,288 @@
              * Gets or sets the current tempo when the MasterBar is played.
              */
             this.tempo = 0;
-            /**
-             * Gets or sets the list of {@link BeatTickLookup} object which define the durations
-             * for all {@link Beats} played within the period of this MasterBar.
-             */
-            this.beats = [];
+            this.firstBeat = null;
+            this.lastBeat = null;
             /**
              * Gets or sets the {@link MasterBarTickLookup} of the next masterbar in the {@link Score}
              */
             this.nextMasterBar = null;
         }
         /**
-         * Performs the neccessary finalization steps after all information was written.
+         * Inserts `newNextBeat` after `currentBeat` in the linked list of items and updates.
+         * the `firstBeat` and `lastBeat` respectively too.
+         * @param currentBeat The item in which to insert the new item afterwards
+         * @param newBeat The new item to insert
          */
-        finish() {
-            this.beats.sort((a, b) => {
-                return a.start - b.start;
-            });
+        insertAfter(currentBeat, newBeat) {
+            if (this.firstBeat == null || currentBeat == null || this.lastBeat == null) {
+                this.firstBeat = newBeat;
+                this.lastBeat = newBeat;
+            }
+            else {
+                // link new node into sequence
+                newBeat.nextBeat = currentBeat.nextBeat;
+                newBeat.previousBeat = currentBeat;
+                // update this node accordinly
+                if (currentBeat.nextBeat) {
+                    currentBeat.nextBeat.previousBeat = newBeat;
+                }
+                currentBeat.nextBeat = newBeat;
+                if (currentBeat == this.lastBeat) {
+                    this.lastBeat = newBeat;
+                }
+            }
         }
         /**
-         * Adds a new {@link BeatTickLookup} to the list of played beats during this MasterBar period.
-         * @param beat
-         */
-        addBeat(beat) {
-            beat.masterBar = this;
-            beat.index = this.beats.length;
-            this.beats.push(beat);
+           * Inserts `newNextBeat` before `currentBeat` in the linked list of items and updates.
+           * the `firstBeat` and `lastBeat` respectively too.
+           * @param currentBeat The item in which to insert the new item afterwards
+           * @param newBeat The new item to insert
+           */
+        insertBefore(currentBeat, newBeat) {
+            if (this.firstBeat == null || currentBeat == null || this.lastBeat == null) {
+                this.firstBeat = newBeat;
+                this.lastBeat = newBeat;
+            }
+            else {
+                // link new node into sequence
+                newBeat.previousBeat = currentBeat.previousBeat;
+                newBeat.nextBeat = currentBeat;
+                // update this node accordingly
+                if (currentBeat.previousBeat) {
+                    currentBeat.previousBeat.nextBeat = newBeat;
+                }
+                currentBeat.previousBeat = newBeat;
+                if (currentBeat == this.firstBeat) {
+                    this.firstBeat = newBeat;
+                }
+            }
+        }
+        /**
+         * Adds a new beat to this masterbar following the slicing logic required by the MidiTickLookup.
+         * @returns The first item of the chain which was affected.
+         */
+        addBeat(beat, start, duration) {
+            const end = start + duration;
+            // We have following scenarios we cover overall on inserts
+            // Technically it would be possible to merge some code paths and work with loops
+            // to handle all scenarios in a shorter piece of code. 
+            // but this would make the core a lot harder to understand an less readable 
+            // and maintainable for the different scenarios. 
+            // we keep them separate here for that purpose and sacrifice some bytes of code for that.
+            // Variant A (initial Insert)
+            //              |    New     |
+            // Result A
+            //              |    New     |
+            // Variant B (insert at end, start matches)
+            //              |     L1     |    L2     |
+            //                                       |   New   |
+            // Result B
+            //              |     L1     |    L2     |   N1    |
+            // Variant C (insert at end, with gap)
+            //              |     L1     |    L2     |
+            //                                             |   New   |
+            // Result C
+            //              |     L1     |    L2     |       N1      |
+            // Variant D (Starts before, ends exactly):
+            //              |     L1     |    L2     |
+            //      |  New  |
+            // Result D:
+            //      |  N1   |     L1     |    L2     |
+            // Variant E (Starts before, with gap):
+            //              |     L1     |    L2     |
+            //    |  New  |   
+            // Result E:
+            //    |  N1     |     L1     |    L2     |
+            // Variant F (starts before, overlaps partially):
+            //              |     L1     |    L2     |
+            //      |      New      | 
+            // Result F:
+            //      |  N1   | N2    | L1 |    L2     |
+            // Variant G (starts before, ends the same):
+            //              |     L1     |    L2     |
+            //      |      New           | 
+            // Result G:
+            //      |  N1   | L1         |    L2     |
+            // Variant H (starts before, ends after L1):
+            //              |     L1     |    L2     |        
+            //      |      New                  | 
+            // Result H:
+            //      Step 1 (only slice L1): 
+            //      |  N1   | L1          |    L2     |
+            //      Step 2 (call recursively with start time of 'new' adjusted): 
+            //                            | New  |
+            //      |  N1   | L1          |  N2  | L2 |
+            // Variant I (starts in the middle, ends exactly)
+            //              |     L1     |    L2     |
+            //                    | New  |
+            // Result I
+            //              | N1  |  L1  |    L2     |
+            // Variant J (starts in the middle, ends before)
+            //              |     L1     |    L2     |
+            //                 | New |  
+            // Result J
+            //              |N1| N2  |L1 |    L2     |
+            // Variant K (starts in the middle, ends after L1)
+            //              |     L1     |    L2     |
+            //                     | New       |
+            // Result K
+            //      Step 1 (only slice L1): 
+            //              |  N1  | L1  |    L2     |
+            //      Step 2 (call recursively with start time of 'new' adjusted): 
+            //                           | New  |
+            //              |  N1  | L1  |    L2     |
+            // Variant L (starts exactly, ends exactly)
+            //              |     L1     |    L2     |
+            //              |    New     |
+            // Result L
+            //              |     L1     |    L2     |
+            // Variant M (starts exactly, ends before)
+            //              |     L1     |    L2     |
+            //              |  New |  
+            // Result M
+            //              | N1   | L1  |    L2     |
+            // Variant N (starts exactly, ends after L1)
+            //              |     L1     |    L2     |
+            //              | New              |
+            // Result N
+            //      Step 1 (only update L1): 
+            //              |      L1    |    L2     |
+            //      Step 2 (call recursively with start time of 'new' adjusted): 
+            //                           | New |
+            //              |     L 1    |    L2     |
+            // Variant A
+            if (this.firstBeat == null) {
+                const n1 = new BeatTickLookup(start, end);
+                n1.highlightBeat(beat);
+                this.insertAfter(this.firstBeat, n1);
+            }
+            // Variant B
+            // Variant C
+            else if (start >= this.lastBeat.end) {
+                // using the end here allows merge of B & C
+                const n1 = new BeatTickLookup(this.lastBeat.end, end);
+                n1.highlightBeat(beat);
+                this.insertAfter(this.lastBeat, n1);
+            }
+            else {
+                let l1 = null;
+                if (start < this.firstBeat.start) {
+                    l1 = this.firstBeat;
+                }
+                else {
+                    let current = this.firstBeat;
+                    while (current != null) {
+                        // find item where we fall into
+                        if (start >= current.start && start < current.end) {
+                            l1 = current;
+                            break;
+                        }
+                        current = current.nextBeat;
+                    }
+                    if (l1 === null) {
+                        // should not be possible
+                        throw new AlphaTabError(exports.AlphaTabErrorType.General, "Error on building lookup, unknown variant");
+                    }
+                }
+                // those scenarios should only happen if we insert before the 
+                // first item (e.g. for grace notes starting < 0)
+                if (start < l1.start) {
+                    // Variant D
+                    // Variant E
+                    if (end == l1.start) {
+                        // using firstBeat.start here allows merge of D & E
+                        const n1 = new BeatTickLookup(start, l1.start);
+                        n1.highlightBeat(beat);
+                        this.insertBefore(this.firstBeat, n1);
+                    }
+                    // Variant F
+                    else if (end < l1.end) {
+                        const n1 = new BeatTickLookup(start, l1.start);
+                        n1.highlightBeat(beat);
+                        this.insertBefore(l1, n1);
+                        const n2 = new BeatTickLookup(l1.start, end);
+                        for (const b of l1.highlightedBeats) {
+                            n2.highlightBeat(b);
+                        }
+                        n2.highlightBeat(beat);
+                        this.insertBefore(l1, n2);
+                        l1.start = end;
+                    }
+                    // Variant G
+                    else if (end == l1.end) {
+                        const n1 = new BeatTickLookup(start, l1.start);
+                        n1.highlightBeat(beat);
+                        l1.highlightBeat(beat);
+                        this.insertBefore(l1, n1);
+                    }
+                    // Variant H
+                    else /* end > this.firstBeat.end */ {
+                        const n1 = new BeatTickLookup(start, l1.start);
+                        n1.highlightBeat(beat);
+                        l1.highlightBeat(beat);
+                        this.insertBefore(l1, n1);
+                        this.addBeat(beat, l1.end, end - l1.end);
+                    }
+                }
+                else if (start > l1.start) {
+                    // variant I
+                    if (end == l1.end) {
+                        const n1 = new BeatTickLookup(l1.start, start);
+                        for (const b of l1.highlightedBeats) {
+                            n1.highlightBeat(b);
+                        }
+                        l1.start = start;
+                        l1.highlightBeat(beat);
+                        this.insertBefore(l1, n1);
+                    }
+                    // Variant J
+                    else if (end < l1.end) {
+                        const n1 = new BeatTickLookup(l1.start, start);
+                        this.insertBefore(l1, n1);
+                        const n2 = new BeatTickLookup(start, end);
+                        this.insertBefore(l1, n2);
+                        for (const b of l1.highlightedBeats) {
+                            n1.highlightBeat(b);
+                            n2.highlightBeat(b);
+                        }
+                        n2.highlightBeat(beat);
+                        l1.start = end;
+                    }
+                    // Variant K
+                    else /* end > l1.end */ {
+                        const n1 = new BeatTickLookup(l1.start, start);
+                        for (const b of l1.highlightedBeats) {
+                            n1.highlightBeat(b);
+                        }
+                        l1.start = start;
+                        l1.highlightBeat(beat);
+                        this.insertBefore(l1, n1);
+                        this.addBeat(beat, l1.end, end - l1.end);
+                    }
+                }
+                else /* start == l1.start */ {
+                    // Variant L
+                    if (end === l1.end) {
+                        l1.highlightBeat(beat);
+                    }
+                    // Variant M
+                    else if (end < l1.end) {
+                        const n1 = new BeatTickLookup(l1.start, end);
+                        for (const b of l1.highlightedBeats) {
+                            n1.highlightBeat(b);
+                        }
+                        n1.highlightBeat(beat);
+                        l1.start = end;
+                        this.insertBefore(l1, n1);
+                    }
+                    // variant N
+                    else /* end > l1.end */ {
+                        l1.highlightBeat(beat);
+                        this.addBeat(beat, l1.end, end - l1.end);
+                    }
+                }
+            }
         }
     }
 
@@ -16896,37 +17175,60 @@
      * @see MidiTickLookup.FindBeat
      */
     class MidiTickLookupFindBeatResult {
-        constructor() {
+        get start() {
+            return this.masterBar.start + this.beatLookup.start;
+        }
+        get end() {
+            return this.start + this.tickDuration;
+        }
+        constructor(masterBar) {
             /**
-             * Gets or sets the duration in milliseconds how long this beat is playing.
+             * Gets or sets the beat that will be played next.
              */
-            this.duration = 0;
+            this.nextBeat = null;
             /**
-             * Gets or sets the duration in midi ticks for how long this tick lookup is valid
-             * starting at the `currentBeatLookup.start`
+             * Gets or sets the duration in midi ticks how long this lookup is valid.
              */
             this.tickDuration = 0;
             /**
-             * Gets or sets the beat lookup for the next beat.
+             * Gets or sets the duration in milliseconds how long this lookup is valid.
              */
-            this.nextBeatLookup = null;
-        }
-        /**
-         * Gets or sets the beat that is currently played.
-         */
-        get currentBeat() {
-            return this.currentBeatLookup.beat;
-        }
-        /**
-         * Gets or sets the beat that will be played next.
-         */
-        get nextBeat() {
-            var _a, _b;
-            return (_b = (_a = this.nextBeatLookup) === null || _a === void 0 ? void 0 : _a.beat) !== null && _b !== void 0 ? _b : null;
+            this.duration = 0;
+            this.masterBar = masterBar;
         }
     }
     /**
      * This class holds all information about when {@link MasterBar}s and {@link Beat}s are played.
+     *
+     * On top level it is organized into {@link MasterBarTickLookup} objects indicating the
+     * master bar start and end times. This information is used to highlight the currently played bars
+     * and it gives access to the played beats in this masterbar and their times.
+     *
+     * The {@link BeatTickLookup} are then the slices into which the masterbar is separated by the voices and beats
+     * of all tracks. An example how things are organized:
+     *
+     * Time (eighths):  | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 |
+     *
+     * Track 1:         |        B1         |        B2         |    B3   |    B4   |    B5   |    B6   |
+     * Track 2:         |                  B7                   |         B7        | B9 | B10| B11| B12|
+     * Track 3:         |                                      B13                                      |
+     *
+     * Lookup:          |        L1         |        L2         |    L3    |   L4   | L5 | L6 | L7 | L8 |
+     * Active Beats:
+     * - L1             B1,B7,B13
+     * - L2                                 B2,B7,B13
+     * - L3                                                      B3,B7,B13
+     * - L4                                                                 B4,B7,B13
+     * - L5                                                                          B5,B9,B13
+     * - L6                                                                               B5,B10,B13
+     * - L7                                                                                    B6,B11,B13
+     * - L8                                                                                         B6,B12,B13
+     *
+     * Then during playback we build out of this list {@link MidiTickLookupFindBeatResult} objects which are sepcific
+     * to the visible tracks displayed. This is required because if only Track 2 is displayed we cannot use the the
+     * Lookup L1 alone to determine the start and end of the beat cursor. In this case we will derive a
+     * MidiTickLookupFindBeatResult which holds for Time 01 the lookup L1 as start and L3 as end. This will be used
+     * both for the cursor and beat highlighting.
      */
     class MidiTickLookup {
         constructor() {
@@ -16943,139 +17245,153 @@
              */
             this.masterBars = [];
         }
-        /**
-         * Performs the neccessary finalization steps after all information was written.
-         * @internal
-         */
-        finish() {
-            let previous = null;
-            let activeBeats = [];
-            for (let bar of this.masterBars) {
-                bar.finish();
-                if (previous) {
-                    previous.nextMasterBar = bar;
-                }
-                for (const beat of bar.beats) {
-                    // 1. calculate newly which beats are still active
-                    const newActiveBeats = [];
-                    // TODO: only create new list if current position changed
-                    for (let activeBeat of activeBeats) {
-                        if (activeBeat.end > beat.start) {
-                            newActiveBeats.push(activeBeat);
-                            // 2. remember for current beat which active beats to highlight
-                            beat.highlightBeat(activeBeat.beat);
-                            // 3. ensure that active beat highlights current beat if they match the range
-                            if (beat.start <= activeBeat.start) {
-                                activeBeat.highlightBeat(beat.beat);
-                            }
-                        }
-                    }
-                    newActiveBeats.push(beat);
-                    activeBeats = newActiveBeats;
-                }
-                previous = bar;
-            }
-        }
         /**
          * Finds the currently played beat given a list of tracks and the current time.
-         * @param tracks The tracks in which to search the played beat for.
+         * @param trackLookup The tracks indices in which to search the played beat for.
          * @param tick The current time in midi ticks.
          * @returns The information about the current beat or null if no beat could be found.
          */
-        findBeat(tracks, tick, currentBeatHint = null) {
-            const trackLookup = new Map();
-            for (const track of tracks) {
-                trackLookup.set(track.index, true);
-            }
+        findBeat(trackLookup, tick, currentBeatHint = null) {
             let result = null;
             if (currentBeatHint) {
                 result = this.findBeatFast(trackLookup, currentBeatHint, tick);
             }
             if (!result) {
-                result = this.findBeatSlow(trackLookup, tick);
+                result = this.findBeatSlow(trackLookup, currentBeatHint, tick, false);
             }
             return result;
         }
         findBeatFast(trackLookup, currentBeatHint, tick) {
-            const end = currentBeatHint.currentBeatLookup.start + currentBeatHint.tickDuration;
-            if (tick >= currentBeatHint.currentBeatLookup.start && tick < end) {
-                // still same beat?
+            // still within current lookup.
+            if (tick >= currentBeatHint.start && tick < currentBeatHint.end) {
                 return currentBeatHint;
             }
-            else if (currentBeatHint.nextBeatLookup &&
-                tick >= currentBeatHint.nextBeatLookup.start &&
-                tick < currentBeatHint.nextBeatLookup.end) {
-                // maybe next beat?
-                return this.createResult(currentBeatHint.nextBeatLookup, trackLookup);
+            // already on the next beat?
+            else if (currentBeatHint.nextBeat &&
+                tick >= currentBeatHint.nextBeat.start &&
+                tick < currentBeatHint.nextBeat.end) {
+                const next = currentBeatHint.nextBeat;
+                // fill next in chain
+                this.fillNextBeat(next, trackLookup);
+                return next;
             }
             // likely a loop or manual seek, need to fallback to slow path
             return null;
         }
-        findBeatSlow(trackLookup, tick) {
+        fillNextBeat(current, trackLookup) {
+            current.nextBeat = this.findBeatInMasterBar(current.masterBar, current.beatLookup.nextBeat, current.end, trackLookup, false, true);
+            if (current.nextBeat == null) {
+                current.nextBeat = this.findBeatSlow(trackLookup, current, current.end, true);
+            }
+            // if we have the next beat take the difference between the times as duration
+            if (current.nextBeat) {
+                current.tickDuration = current.nextBeat.start - current.start;
+                current.duration = MidiUtils.ticksToMillis(current.tickDuration, current.masterBar.tempo);
+            }
+        }
+        findBeatSlow(trackLookup, currentBeatHint, tick, isNextSearch) {
             // get all beats within the masterbar
-            const masterBar = this.findMasterBar(tick);
+            let masterBar = null;
+            if (currentBeatHint != null) {
+                // same masterbar? 
+                if (currentBeatHint.masterBar.start <= tick &&
+                    currentBeatHint.masterBar.end > tick) {
+                    masterBar = currentBeatHint.masterBar;
+                }
+                // next masterbar
+                else if (currentBeatHint.masterBar.nextMasterBar &&
+                    currentBeatHint.masterBar.nextMasterBar.start <= tick &&
+                    currentBeatHint.masterBar.nextMasterBar.end > tick) {
+                    masterBar = currentBeatHint.masterBar.nextMasterBar;
+                }
+            }
+            // slowest lookup
+            if (!masterBar) {
+                masterBar = this.findMasterBar(tick);
+            }
+            // no match
             if (!masterBar) {
                 return null;
             }
-            let beat = null;
-            let beats = masterBar.beats;
-            for (let b = 0; b < beats.length; b++) {
-                // is the current beat played on the given tick?
-                let currentBeat = beats[b];
-                // skip non relevant beats
-                if (!trackLookup.has(currentBeat.beat.voice.bar.staff.track.index)) {
-                    continue;
+            // scan through beats and find first one which has a beat visible
+            while (masterBar) {
+                if (masterBar.firstBeat) {
+                    let beat = this.findBeatInMasterBar(masterBar, masterBar.firstBeat, tick, trackLookup, true, isNextSearch);
+                    if (beat) {
+                        return beat;
+                    }
                 }
-                if (currentBeat.start <= tick && tick < currentBeat.end) {
-                    // take the latest played beat we can find. (most right)
-                    if (!beat || beat.start < currentBeat.start) {
-                        beat = beats[b];
+                masterBar = masterBar.nextMasterBar;
+            }
+            return null;
+        }
+        /**
+         * Finds the beat at a given tick position within the known master bar.
+         * @param masterBar
+         * @param currentStartLookup
+         * @param tick
+         * @param visibleTracks
+         * @param fillNext
+         * @returns
+         */
+        findBeatInMasterBar(masterBar, currentStartLookup, tick, visibleTracks, fillNext, isNextSeach) {
+            var _a;
+            if (!currentStartLookup) {
+                return null;
+            }
+            let startBeatLookup = null;
+            let startBeat = null;
+            const relativeTick = tick - masterBar.start;
+            while (currentStartLookup != null && startBeat == null) {
+                if (currentStartLookup.start <= relativeTick && relativeTick < currentStartLookup.end) {
+                    startBeatLookup = currentStartLookup;
+                    startBeat = currentStartLookup.getVisibleBeatAtStart(visibleTracks);
+                    // found the matching beat lookup but none of the beats are visible
+                    // in this case scan further to the next lookup which has any visible beat
+                    if (!startBeat) {
+                        if (isNextSeach) {
+                            while (currentStartLookup != null) {
+                                startBeat = currentStartLookup.getVisibleBeatAtStart(visibleTracks);
+                                if (startBeat) {
+                                    startBeatLookup = currentStartLookup;
+                                    break;
+                                }
+                                currentStartLookup = currentStartLookup.nextBeat;
+                            }
+                        }
+                        else {
+                            while (currentStartLookup != null) {
+                                startBeat = currentStartLookup.getVisibleBeatAtStart(visibleTracks);
+                                if (startBeat) {
+                                    startBeatLookup = currentStartLookup;
+                                    break;
+                                }
+                                currentStartLookup = currentStartLookup.previousBeat;
+                            }
+                        }
                     }
                 }
-                else if (currentBeat.end > tick) {
+                else if (currentStartLookup.end > relativeTick) {
                     break;
                 }
+                currentStartLookup = (_a = currentStartLookup === null || currentStartLookup === void 0 ? void 0 : currentStartLookup.nextBeat) !== null && _a !== void 0 ? _a : null;
             }
-            if (!beat) {
+            if (startBeat == null) {
                 return null;
             }
-            return this.createResult(beat, trackLookup);
-        }
-        createResult(beat, trackLookup) {
-            // search for next relevant beat in masterbar
-            const nextBeat = this.findNextBeat(beat, trackLookup);
-            const result = new MidiTickLookupFindBeatResult();
-            result.currentBeatLookup = beat;
-            result.nextBeatLookup = nextBeat;
-            result.tickDuration = !nextBeat ? beat.end - beat.start : nextBeat.start - beat.start;
-            result.duration = MidiUtils.ticksToMillis(result.tickDuration, beat.masterBar.tempo);
-            result.beatsToHighlight = beat.beatsToHighlight;
+            const result = this.createResult(masterBar, startBeatLookup, startBeat, fillNext, visibleTracks);
             return result;
         }
-        findNextBeat(beat, trackLookup) {
-            const masterBar = beat.masterBar;
-            let beats = masterBar.beats;
-            // search for next relevant beat in masterbar
-            let nextBeat = null;
-            for (let b = beat.index + 1; b < beats.length; b++) {
-                const currentBeat = beats[b];
-                if (currentBeat.start > beat.start && trackLookup.has(currentBeat.beat.voice.bar.staff.track.index)) {
-                    nextBeat = currentBeat;
-                    break;
-                }
-            }
-            // first relevant beat in next bar
-            if (!nextBeat && masterBar.nextMasterBar) {
-                beats = masterBar.nextMasterBar.beats;
-                for (let b = 0; b < beats.length; b++) {
-                    const currentBeat = beats[b];
-                    if (trackLookup.has(currentBeat.beat.voice.bar.staff.track.index)) {
-                        nextBeat = currentBeat;
-                        break;
-                    }
-                }
+        createResult(masterBar, beatLookup, beat, fillNext, visibleTracks) {
+            const result = new MidiTickLookupFindBeatResult(masterBar);
+            result.beat = beat;
+            result.beatLookup = beatLookup;
+            result.tickDuration = beatLookup.end - beatLookup.start;
+            if (fillNext) {
+                this.fillNextBeat(result, visibleTracks);
             }
-            return nextBeat;
+            result.duration = MidiUtils.ticksToMillis(result.tickDuration, masterBar.tempo);
+            return result;
         }
         findMasterBar(tick) {
             const bars = this.masterBars;
@@ -17139,18 +17455,17 @@
          */
         addMasterBar(masterBar) {
             this.masterBars.push(masterBar);
+            if (this._currentMasterBar) {
+                this._currentMasterBar.nextMasterBar = masterBar;
+            }
             this._currentMasterBar = masterBar;
             if (!this.masterBarLookup.has(masterBar.masterBar.index)) {
                 this.masterBarLookup.set(masterBar.masterBar.index, masterBar);
             }
         }
-        /**
-         * Adds the given {@link BeatTickLookup} to the current {@link MidiTickLookup}.
-         * @param beat The lookup to add.
-         */
-        addBeat(beat) {
+        addBeat(beat, start, duration) {
             var _a;
-            (_a = this._currentMasterBar) === null || _a === void 0 ? void 0 : _a.addBeat(beat);
+            (_a = this._currentMasterBar) === null || _a === void 0 ? void 0 : _a.addBeat(beat, start, duration);
         }
     }
 
@@ -19024,7 +19339,6 @@
          */
         constructor(score, settings, handler) {
             this._currentTempo = 0;
-            this._currentBarRepeatLookup = null;
             this._programsPerChannel = new Map();
             /**
              * Gets a lookup object which can be used to quickly find beats and bars
@@ -19080,7 +19394,6 @@
             for (const track of this._score.tracks) {
                 this._handler.finishTrack(track.index, controller.currentTick);
             }
-            this.tickLookup.finish();
             Logger.debug('Midi', 'Midi generation done');
         }
         generateTrack(track) {
@@ -19154,7 +19467,6 @@
         }
         generateBar(bar, barStartTick) {
             let playbackBar = this.getPlaybackBar(bar);
-            this._currentBarRepeatLookup = null;
             for (const v of playbackBar.voices) {
                 this.generateVoice(v, barStartTick, bar);
             }
@@ -19207,29 +19519,16 @@
                     }
                 }
             }
-            const beatLookup = new BeatTickLookup();
-            beatLookup.start = barStartTick + beatStart;
             const realTickOffset = !beat.nextBeat
                 ? audioDuration
                 : beat.nextBeat.absolutePlaybackStart - beat.absolutePlaybackStart;
-            beatLookup.end = barStartTick + beatStart;
-            beatLookup.highlightBeat(beat);
-            beatLookup.end += realTickOffset > audioDuration ? realTickOffset : audioDuration;
             // in case of normal playback register playback
             if (realBar === beat.voice.bar) {
-                beatLookup.beat = beat;
-                this.tickLookup.addBeat(beatLookup);
+                this.tickLookup.addBeat(beat, beatStart, realTickOffset > audioDuration ? realTickOffset : audioDuration);
             }
             else {
-                beatLookup.isEmptyBar = true;
-                beatLookup.beat = realBar.voices[0].beats[0];
-                if (!this._currentBarRepeatLookup) {
-                    this._currentBarRepeatLookup = beatLookup;
-                    this.tickLookup.addBeat(this._currentBarRepeatLookup);
-                }
-                else {
-                    this._currentBarRepeatLookup.end = beatLookup.end;
-                }
+                // in case of simile marks where we repeat we also register 
+                this.tickLookup.addBeat(beat, 0, realTickOffset > audioDuration ? realTickOffset : audioDuration);
             }
             const track = beat.voice.bar.staff.track;
             for (const automation of beat.automations) {
@@ -25008,6 +25307,7 @@
         constructor(uiFacade, settings) {
             this._startTime = 0;
             this._trackIndexes = null;
+            this._trackIndexLookup = null;
             this._isDestroyed = false;
             /**
              * Gets the score holding all information about the song being rendered.
@@ -25231,6 +25531,7 @@
                 for (let track of tracks) {
                     this._trackIndexes.push(track.index);
                 }
+                this._trackIndexLookup = new Set(this._trackIndexes);
                 this.onScoreLoaded(score);
                 this.loadMidiForScore();
                 this.render();
@@ -25241,6 +25542,7 @@
                 for (let track of tracks) {
                     this._trackIndexes.push(track.index);
                 }
+                this._trackIndexLookup = new Set(this._trackIndexes);
                 this.render();
             }
         }
@@ -25687,7 +25989,7 @@
                         let currentBeat = this._currentBeat;
                         let tickCache = this._tickCache;
                         if (currentBeat && tickCache) {
-                            this.player.tickPosition = tickCache.getBeatStart(currentBeat.currentBeat);
+                            this.player.tickPosition = tickCache.getBeatStart(currentBeat.beat);
                         }
                     }
                 });
@@ -25702,8 +26004,8 @@
         cursorUpdateTick(tick, stop, shouldScroll = false) {
             let cache = this._tickCache;
             if (cache) {
-                let tracks = this.tracks;
-                if (tracks.length > 0) {
+                let tracks = this._trackIndexLookup;
+                if (tracks != null && tracks.size > 0) {
                     let beat = cache.findBeat(tracks, tick, this._currentBeat);
                     if (beat) {
                         this.cursorUpdateBeat(beat, stop, shouldScroll);
@@ -25715,10 +26017,11 @@
          * updates the cursors to highlight the specified beat
          */
         cursorUpdateBeat(lookupResult, stop, shouldScroll, forceUpdate = false) {
-            const beat = lookupResult.currentBeat;
-            const nextBeat = lookupResult.nextBeat;
+            var _a, _b;
+            const beat = lookupResult.beat;
+            const nextBeat = (_b = (_a = lookupResult.nextBeat) === null || _a === void 0 ? void 0 : _a.beat) !== null && _b !== void 0 ? _b : null;
             const duration = lookupResult.duration;
-            const beatsToHighlight = lookupResult.beatsToHighlight;
+            const beatsToHighlight = lookupResult.beatLookup.highlightedBeats;
             if (!beat) {
                 return;
             }
@@ -25730,7 +26033,7 @@
             let previousCache = this._previousCursorCache;
             let previousState = this._previousStateForCursor;
             if (!forceUpdate &&
-                beat === (previousBeat === null || previousBeat === void 0 ? void 0 : previousBeat.currentBeat) &&
+                beat === (previousBeat === null || previousBeat === void 0 ? void 0 : previousBeat.beat) &&
                 cache === previousCache &&
                 previousState === this._playerState) {
                 return;
@@ -25843,14 +26146,11 @@
                     if (nextBeat) {
                         // if we are moving within the same bar or to the next bar
                         // transition to the next beat, otherwise transition to the end of the bar.
-                        if ((nextBeat.voice.bar.index === beat.voice.bar.index && nextBeat.index > beat.index) ||
-                            nextBeat.voice.bar.index === beat.voice.bar.index + 1) {
-                            let nextBeatBoundings = cache.findBeat(nextBeat);
-                            if (nextBeatBoundings &&
-                                nextBeatBoundings.barBounds.masterBarBounds.staveGroupBounds ===
-                                    barBoundings.staveGroupBounds) {
-                                nextBeatX = nextBeatBoundings.visualBounds.x;
-                            }
+                        let nextBeatBoundings = cache.findBeat(nextBeat);
+                        if (nextBeatBoundings &&
+                            nextBeatBoundings.barBounds.masterBarBounds.staveGroupBounds ===
+                                barBoundings.staveGroupBounds) {
+                            nextBeatX = nextBeatBoundings.visualBounds.x;
                         }
                     }
                     // we need to put the transition to an own animation frame
@@ -25991,11 +26291,11 @@
                 return;
             }
             if (range) {
-                const startBeat = this._tickCache.findBeat(this.tracks, range.startTick);
-                const endBeat = this._tickCache.findBeat(this.tracks, range.endTick);
+                const startBeat = this._tickCache.findBeat(this._trackIndexLookup, range.startTick);
+                const endBeat = this._tickCache.findBeat(this._trackIndexLookup, range.endTick);
                 if (startBeat && endBeat) {
-                    const selectionStart = new SelectionInfo(startBeat.currentBeat);
-                    const selectionEnd = new SelectionInfo(endBeat.currentBeat);
+                    const selectionStart = new SelectionInfo(startBeat.beat);
+                    const selectionEnd = new SelectionInfo(endBeat.beat);
                     this.cursorSelectRange(selectionStart, selectionEnd);
                 }
             }
@@ -42499,8 +42799,8 @@
     // </auto-generated>
     class VersionInfo {
     }
-    VersionInfo.version = '1.3.0-alpha.870';
-    VersionInfo.date = '2023-12-26T01:21:15.490Z';
+    VersionInfo.version = '1.3.0-alpha.873';
+    VersionInfo.date = '2023-12-29T01:13:10.298Z';
 
     var index$5 = /*#__PURE__*/Object.freeze({
         __proto__: null,