@coderline/alphatab 1.7.0-alpha.1515 → 1.7.0-alpha.1522

package/dist/alphaTab.core.mjs

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.7.0-alpha.1515 (develop, build 1515)
+ * alphaTab v1.7.0-alpha.1522 (develop, build 1522)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -197,9 +197,9 @@ class VersionInfo {
         print(`build date: ${VersionInfo.date}`);
     }
 }
-VersionInfo.version = '1.7.0-alpha.1515';
-VersionInfo.date = '2025-08-17T02:26:19.392Z';
-VersionInfo.commit = '23aaf549a408c97811ff01054a773c3fa2344bf0';
+VersionInfo.version = '1.7.0-alpha.1522';
+VersionInfo.date = '2025-08-24T02:21:16.522Z';
+VersionInfo.commit = 'c80b4a66eae6b73cb2d7dacaaf74c8f9cce16318';
 
 /**
  * This public class provides names for all general midi instruments.
@@ -226,6 +226,14 @@ class GeneralMidi {
     static isGuitar(program) {
         return (program >= 24 && program <= 39) || program === 105 || program === 43;
     }
+    static isBass(program) {
+        return program >= 32 && program <= 39;
+    }
+    static bankToLsbMsb(bank) {
+        const lsb = bank & 0x7f;
+        const msb = (bank >> 7) & 0x7f;
+        return [lsb, msb];
+    }
 }
 GeneralMidi._values = new Map([
     ['acousticgrandpiano', 0],
@@ -1420,6 +1428,10 @@ var AutomationType;
      * A sync point for synchronizing the internal time axis with an external audio track.
      */
     AutomationType[AutomationType["SyncPoint"] = 4] = "SyncPoint";
+    /**
+     * Midi Bank change.
+     */
+    AutomationType[AutomationType["Bank"] = 4] = "Bank";
 })(AutomationType || (AutomationType = {}));
 /**
  * Represents the data of a sync point for synchronizing the internal time axis with
@@ -3387,6 +3399,49 @@ var MusicFontSymbol;
     MusicFontSymbol[MusicFontSymbol["FingeringCLower"] = 60700] = "FingeringCLower";
 })(MusicFontSymbol || (MusicFontSymbol = {}));
 
+/**
+ * Defines all possible accidentals for notes.
+ */
+var AccidentalType;
+(function (AccidentalType) {
+    /**
+     * No accidental
+     */
+    AccidentalType[AccidentalType["None"] = 0] = "None";
+    /**
+     * Naturalize
+     */
+    AccidentalType[AccidentalType["Natural"] = 1] = "Natural";
+    /**
+     * Sharp
+     */
+    AccidentalType[AccidentalType["Sharp"] = 2] = "Sharp";
+    /**
+     * Flat
+     */
+    AccidentalType[AccidentalType["Flat"] = 3] = "Flat";
+    /**
+     * Natural for smear bends
+     */
+    AccidentalType[AccidentalType["NaturalQuarterNoteUp"] = 4] = "NaturalQuarterNoteUp";
+    /**
+     * Sharp for smear bends
+     */
+    AccidentalType[AccidentalType["SharpQuarterNoteUp"] = 5] = "SharpQuarterNoteUp";
+    /**
+     * Flat for smear bends
+     */
+    AccidentalType[AccidentalType["FlatQuarterNoteUp"] = 6] = "FlatQuarterNoteUp";
+    /**
+     * Double Sharp, indicated by an 'x'
+     */
+    AccidentalType[AccidentalType["DoubleSharp"] = 7] = "DoubleSharp";
+    /**
+     * Double Flat, indicated by 'bb'
+     */
+    AccidentalType[AccidentalType["DoubleFlat"] = 8] = "DoubleFlat";
+})(AccidentalType || (AccidentalType = {}));
+
 class TuningParseResult {
     constructor() {
         this.note = null;
@@ -3892,6 +3947,150 @@ class ModelUtils {
         }
         return ModelUtils.allMusicFontSymbols;
     }
+    /**
+     * @internal
+     */
+    static flooredDivision(a, b) {
+        return a - b * Math.floor(a / b);
+    }
+    // NOTE: haven't figured out yet what exact formula is applied when transposing key signatures
+    // this table is simply created by checking the Guitar Pro behavior,
+    // The table is organized as [<transpose>][<key signature>] to match the table above
+    // it's also easier to read as we list every key signature per row, transposed by the same value
+    // this gives typically just a shifted list according to the transpose (with some special treatments)
+    /**
+     * Converts the key transpose table to actual key signatures.
+     * @param texts An array where every item indicates the number of accidentals and which accidental
+     * placed for the key signature.
+     *
+     * e.g. 3# is 3-sharps -> KeySignature.A
+     */
+    static translateKeyTransposeTable(texts) {
+        const keySignatures = [];
+        for (const transpose of texts) {
+            const transposeValues = [];
+            keySignatures.push(transposeValues);
+            for (const keySignatureText of transpose) {
+                const keySignature = 
+                // digit
+                (Number.parseInt(keySignatureText.charAt(0)) *
+                    // b -> negative, # positive
+                    (keySignatureText.charAt(1) === 'b' ? -1 : 1));
+                transposeValues.push(keySignature);
+            }
+        }
+        return keySignatures;
+    }
+    /**
+     * Transposes the given key signature.
+     * @internal
+     * @param keySignature The key signature to transpose
+     * @param transpose The number of semitones to transpose (+/- 0-11)
+     * @returns
+     */
+    static transposeKey(keySignature, transpose) {
+        if (transpose === 0) {
+            return keySignature;
+        }
+        if (transpose < 0) {
+            const lookup = ModelUtils.keyTransposeTable[-transpose];
+            const keySignatureIndex = lookup.indexOf(keySignature);
+            if (keySignatureIndex === -1) {
+                return keySignature;
+            }
+            return (keySignatureIndex - 7);
+        }
+        else {
+            return ModelUtils.keyTransposeTable[transpose][keySignature + 7];
+        }
+    }
+    /**
+     * @internal
+     */
+    static computeAccidental(keySignature, accidentalMode, noteValue, quarterBend, currentAccidental = null) {
+        const ks = keySignature;
+        const ksi = ks + 7;
+        const index = noteValue % 12;
+        const accidentalForKeySignature = ksi < 7 ? AccidentalType.Flat : AccidentalType.Sharp;
+        const hasKeySignatureAccidentalSetForNote = ModelUtils.KeySignatureLookup[ksi][index];
+        const hasNoteAccidentalWithinOctave = ModelUtils.AccidentalNotes[index];
+        // the general logic is like this:
+        // - we check if the key signature has an accidental defined
+        // - we calculate which accidental a note needs according to its index in the octave
+        // - if the accidental is already placed at this line, nothing needs to be done, otherwise we place it
+        // - if there should not be an accidental, but there is one in the key signature, we clear it.
+        // the exceptions are:
+        // - for quarter bends we just place the corresponding accidental
+        // - the accidental mode can enforce the accidentals for the note
+        let accidentalToSet = AccidentalType.None;
+        if (quarterBend) {
+            accidentalToSet = hasNoteAccidentalWithinOctave ? accidentalForKeySignature : AccidentalType.Natural;
+            switch (accidentalToSet) {
+                case AccidentalType.Natural:
+                    accidentalToSet = AccidentalType.NaturalQuarterNoteUp;
+                    break;
+                case AccidentalType.Sharp:
+                    accidentalToSet = AccidentalType.SharpQuarterNoteUp;
+                    break;
+                case AccidentalType.Flat:
+                    accidentalToSet = AccidentalType.FlatQuarterNoteUp;
+                    break;
+            }
+        }
+        else {
+            // define which accidental should be shown ignoring what might be set on the KS already
+            switch (accidentalMode) {
+                case NoteAccidentalMode.ForceSharp:
+                    accidentalToSet = AccidentalType.Sharp;
+                    break;
+                case NoteAccidentalMode.ForceDoubleSharp:
+                    accidentalToSet = AccidentalType.DoubleSharp;
+                    break;
+                case NoteAccidentalMode.ForceFlat:
+                    accidentalToSet = AccidentalType.Flat;
+                    break;
+                case NoteAccidentalMode.ForceDoubleFlat:
+                    accidentalToSet = AccidentalType.DoubleFlat;
+                    break;
+                default:
+                    // if note has an accidental in the octave, we place a symbol
+                    // according to the Key Signature
+                    if (hasNoteAccidentalWithinOctave) {
+                        accidentalToSet = accidentalForKeySignature;
+                    }
+                    else if (hasKeySignatureAccidentalSetForNote) {
+                        // note does not get an accidental, but KS defines one -> Naturalize
+                        accidentalToSet = AccidentalType.Natural;
+                    }
+                    break;
+            }
+            // do we need an accidental on the note?
+            if (accidentalToSet !== AccidentalType.None) {
+                // if there is no accidental on the line, and the key signature has it set already, we clear it on the note
+                if (currentAccidental != null) {
+                    if (currentAccidental === accidentalToSet) {
+                        accidentalToSet = AccidentalType.None;
+                    }
+                }
+                else if (hasKeySignatureAccidentalSetForNote && accidentalToSet === accidentalForKeySignature) {
+                    accidentalToSet = AccidentalType.None;
+                }
+            }
+            else {
+                // if we don't want an accidental, but there is already one applied, we place a naturalize accidental
+                // and clear the registration
+                if (currentAccidental !== null) {
+                    if (currentAccidental === AccidentalType.Natural) {
+                        accidentalToSet = AccidentalType.None;
+                    }
+                    else {
+                        accidentalToSet = AccidentalType.Natural;
+                    }
+                }
+            }
+        }
+        return accidentalToSet;
+    }
 }
 ModelUtils.TuningLetters = new Set([
     0x43 /* C */, 0x44 /* D */, 0x45 /* E */, 0x46 /* F */, 0x47 /* G */, 0x41 /* A */, 0x42 /* B */, 0x63 /* c */,
@@ -3944,6 +4143,66 @@ ModelUtils.displayTranspositionPitches = new Map([
     // Contrabass
     [43, -12]
 ]);
+/**
+ * @internal
+ */
+ModelUtils.keyTransposeTable = ModelUtils.translateKeyTransposeTable([
+    /*              Cb    Gb    Db    Ab    Eb    Bb    F     C     G     D     A     E     B     F     C# */
+    /* C	 0 */ ['7b', '6b', '5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#', '7#'],
+    /* Db	 1 */ ['2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#', '7#', '4b', '3b', '2b', '1b', '0#'],
+    /* D	 2 */ ['3#', '4#', '7b', '6b', '5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#'],
+    /* Eb	 3 */ ['4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#', '7#', '4b', '3b', '2b'],
+    /* E	 4 */ ['1#', '2#', '3#', '4#', '7b', '6b', '5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#'],
+    /* F	 5 */ ['6b', '5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#', '7#', '4b'],
+    /* Gb	 6 */ ['1b', '0#', '1#', '2#', '3#', '4#', '7b', '6#', '7#', '4b', '3b', '2b', '1b', '0#', '1#'],
+    /* G	 7 */ ['4#', '7b', '6b', '5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#'],
+    /* Ab	 8 */ ['3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#', '7#', '4b', '3b', '2b', '1b'],
+    /* A	 9 */ ['2#', '3#', '4#', '7b', '6b', '5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#'],
+    /* Bb	10 */ ['5b', '4b', '3b', '2b', '1b', '0#', '1#', '2#', '3#', '4#', '5#', '6#', '7#', '4b', '3b'],
+    /* B	11 */ ['0#', '1#', '2#', '3#', '4#', '7b', '6b', '6#', '4b', '3b', '2b', '1b', '0#', '1#', '2#']
+]);
+/**
+ * a lookup list containing an info whether the notes within an octave
+ * need an accidental rendered. the accidental symbol is determined based on the type of key signature.
+ */
+ModelUtils.KeySignatureLookup = [
+    // Flats (where the value is true, a flat accidental is required for the notes)
+    [true, true, true, true, true, true, true, true, true, true, true, true],
+    [true, true, true, true, true, false, true, true, true, true, true, true],
+    [false, true, true, true, true, false, true, true, true, true, true, true],
+    [false, true, true, true, true, false, false, false, true, true, true, true],
+    [false, false, false, true, true, false, false, false, true, true, true, true],
+    [false, false, false, true, true, false, false, false, false, false, true, true],
+    [false, false, false, false, false, false, false, false, false, false, true, true],
+    // natural
+    [false, false, false, false, false, false, false, false, false, false, false, false],
+    // sharps  (where the value is true, a flat accidental is required for the notes)
+    [false, false, false, false, false, true, true, false, false, false, false, false],
+    [true, true, false, false, false, true, true, false, false, false, false, false],
+    [true, true, false, false, false, true, true, true, true, false, false, false],
+    [true, true, true, true, false, true, true, true, true, false, false, false],
+    [true, true, true, true, false, true, true, true, true, true, true, false],
+    [true, true, true, true, true, true, true, true, true, true, true, false],
+    [true, true, true, true, true, true, true, true, true, true, true, true]
+];
+/**
+ * Contains the list of notes within an octave have accidentals set.
+ * @internal
+ */
+ModelUtils.AccidentalNotes = [
+    false,
+    true,
+    false,
+    true,
+    false,
+    false,
+    true,
+    false,
+    true,
+    false,
+    true,
+    false
+];
 
 /**
  * Lists all types of pick strokes.
@@ -7914,6 +8173,10 @@ class PlaybackInformation {
          * Gets or sets the midi program to use.
          */
         this.program = 0;
+        /**
+         * The midi bank to use.
+         */
+        this.bank = 0;
         /**
          * Gets or sets the primary channel for all normal midi events.
          */
@@ -7946,7 +8209,7 @@ class Tuning {
     static getTextPartsForTuning(tuning, octaveShift = -1) {
         const octave = (tuning / 12) | 0;
         const note = tuning % 12;
-        const notes = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
+        const notes = Tuning.noteNames;
         return [notes[note], (octave + octaveShift).toString()];
     }
     /**
@@ -8085,8 +8348,7 @@ Tuning._sixStrings = [];
 Tuning._fiveStrings = [];
 Tuning._fourStrings = [];
 Tuning._defaultTunings = new Map();
-Tuning.defaultAccidentals = ['', '#', '', '#', '', '', '#', '', '#', '', '#', ''];
-Tuning.defaultSteps = ['C', 'C', 'D', 'D', 'E', 'F', 'F', 'G', 'G', 'A', 'A', 'B'];
+Tuning.noteNames = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
 Tuning.initialize();
 
 /**
@@ -8309,6 +8571,12 @@ class Track {
          */
         this.percussionArticulations = [];
     }
+    /**
+     * Gets whether this track is a percussion track.
+     */
+    get isPercussion() {
+        return this.staves.some(s => s.isPercussion);
+    }
     /**
      * Adds a new line break.
      * @param index  The index of the bar before which a line break should happen.
@@ -9012,8 +9280,7 @@ class AlphaTexLexer {
                     }
                     // unicode handling
                     // https://tc39.es/ecma262/multipage/ecmascript-data-types-and-values.html#sec-ecmascript-language-types-string-type
-                    if (IOHelper.isLeadingSurrogate(previousCodepoint) &&
-                        IOHelper.isTrailingSurrogate(codepoint)) {
+                    if (IOHelper.isLeadingSurrogate(previousCodepoint) && IOHelper.isTrailingSurrogate(codepoint)) {
                         codepoint = (previousCodepoint - 0xd800) * 0x400 + (codepoint - 0xdc00) + 0x10000;
                         s += String.fromCodePoint(codepoint);
                     }
@@ -9448,10 +9715,10 @@ class AlphaTexImporter extends ScoreImporter {
             case 'bass':
                 return Clef.F4;
             case 'c3':
-            case 'tenor':
+            case 'alto':
                 return Clef.C3;
             case 'c4':
-            case 'alto':
+            case 'tenor':
                 return Clef.C4;
             case 'n':
             case 'neutral':
@@ -9468,6 +9735,8 @@ class AlphaTexImporter extends ScoreImporter {
      */
     parseClefFromInt(i) {
         switch (i) {
+            case 0:
+                return Clef.Neutral;
             case 43:
                 return Clef.G2;
             case 65:
@@ -9972,33 +10241,15 @@ class AlphaTexImporter extends ScoreImporter {
                 }
                 return StaffMetaResult.KnownStaffMeta;
             case 'instrument':
-                this.sy = this.newSy();
                 this._staffTuningApplied = false;
-                if (this.sy === AlphaTexSymbols.Number) {
-                    const instrument = this.syData;
-                    if (instrument >= 0 && instrument <= 127) {
-                        this._currentTrack.playbackInfo.program = this.syData;
-                    }
-                    else {
-                        this.error('instrument', AlphaTexSymbols.Number, false);
-                    }
-                }
-                else if (this.sy === AlphaTexSymbols.String) {
-                    const instrumentName = this.syData.toLowerCase();
-                    if (instrumentName === 'percussion') {
-                        for (const staff of this._currentTrack.staves) {
-                            this.applyPercussionStaff(staff);
-                        }
-                        this._currentTrack.playbackInfo.primaryChannel = SynthConstants.PercussionChannel;
-                        this._currentTrack.playbackInfo.secondaryChannel = SynthConstants.PercussionChannel;
-                    }
-                    else {
-                        this._currentTrack.playbackInfo.program = GeneralMidi.getValue(instrumentName);
-                    }
-                }
-                else {
-                    this.error('instrument', AlphaTexSymbols.Number, true);
+                this.readTrackInstrument();
+                return StaffMetaResult.KnownStaffMeta;
+            case 'bank':
+                this.sy = this.newSy();
+                if (this.sy !== AlphaTexSymbols.Number) {
+                    this.error('bank', AlphaTexSymbols.Number, true);
                 }
+                this._currentTrack.playbackInfo.bank = this.syData;
                 this.sy = this.newSy();
                 return StaffMetaResult.KnownStaffMeta;
             case 'lyrics':
@@ -10109,6 +10360,35 @@ class AlphaTexImporter extends ScoreImporter {
                 return StaffMetaResult.UnknownStaffMeta;
         }
     }
+    readTrackInstrument() {
+        this.sy = this.newSy();
+        if (this.sy === AlphaTexSymbols.Number) {
+            const instrument = this.syData;
+            if (instrument >= 0 && instrument <= 127) {
+                this._currentTrack.playbackInfo.program = this.syData;
+            }
+            else {
+                this.error('instrument', AlphaTexSymbols.Number, false);
+            }
+        }
+        else if (this.sy === AlphaTexSymbols.String) {
+            const instrumentName = this.syData.toLowerCase();
+            if (instrumentName === 'percussion') {
+                for (const staff of this._currentTrack.staves) {
+                    this.applyPercussionStaff(staff);
+                }
+                this._currentTrack.playbackInfo.primaryChannel = SynthConstants.PercussionChannel;
+                this._currentTrack.playbackInfo.secondaryChannel = SynthConstants.PercussionChannel;
+            }
+            else {
+                this._currentTrack.playbackInfo.program = GeneralMidi.getValue(instrumentName);
+            }
+        }
+        else {
+            this.error('instrument', AlphaTexSymbols.Number, true);
+        }
+        this.sy = this.newSy();
+    }
     handleAccidentalMode() {
         this.sy = this.newSy();
         if (this.sy !== AlphaTexSymbols.String) {
@@ -10381,6 +10661,17 @@ class AlphaTexImporter extends ScoreImporter {
                     }
                     this._score.stylesheet.perTrackMultiBarRest.add(this._currentTrack.index);
                     break;
+                case 'instrument':
+                    this.readTrackInstrument();
+                    break;
+                case 'bank':
+                    this.sy = this.newSy();
+                    if (this.sy !== AlphaTexSymbols.Number) {
+                        this.error('bank', AlphaTexSymbols.Number, true);
+                    }
+                    this._currentTrack.playbackInfo.bank = this.syData;
+                    this.sy = this.newSy();
+                    break;
                 default:
                     this.error('track-properties', AlphaTexSymbols.String, false);
                     break;
@@ -10725,6 +11016,25 @@ class AlphaTexImporter extends ScoreImporter {
             }
             beat.text = this.syData;
         }
+        else if (syData === 'lyrics') {
+            this.sy = this.newSy();
+            let lyricsLine = 0;
+            if (this.sy === AlphaTexSymbols.Number) {
+                lyricsLine = this.syData;
+                this.sy = this.newSy();
+            }
+            if (this.sy !== AlphaTexSymbols.String) {
+                this.error('lyrics', AlphaTexSymbols.String, true);
+                return false;
+            }
+            if (!beat.lyrics) {
+                beat.lyrics = [];
+            }
+            while (beat.lyrics.length <= lyricsLine) {
+                beat.lyrics.push('');
+            }
+            beat.lyrics[lyricsLine] = this.syData;
+        }
         else if (syData === 'dd') {
             beat.dots = 2;
         }
@@ -11162,6 +11472,17 @@ class AlphaTexImporter extends ScoreImporter {
             automation.value = program;
             beat.automations.push(automation);
         }
+        else if (syData === 'bank') {
+            this.sy = this.newSy();
+            if (this.sy !== AlphaTexSymbols.Number) {
+                this.error('bank-change', AlphaTexSymbols.Number, true);
+            }
+            const automation = new Automation();
+            automation.isLinear = false;
+            automation.type = AutomationType.Bank;
+            automation.value = this.syData;
+            beat.automations.push(automation);
+        }
         else if (syData === 'fermata') {
             this.sy = this.newSy();
             if (this.sy !== AlphaTexSymbols.String) {
@@ -11172,7 +11493,7 @@ class AlphaTexImporter extends ScoreImporter {
             this.sy = this.newSy(true);
             if (this.sy === AlphaTexSymbols.Number) {
                 fermata.length = this.syData;
-                this.sy = this.newSy(true);
+                this.sy = this.newSy();
             }
             beat.fermata = fermata;
             return true;
@@ -11205,13 +11526,9 @@ class AlphaTexImporter extends ScoreImporter {
                     beat.beamingMode = BeatBeamingMode.ForceSplitOnSecondaryToNext;
                     break;
             }
-            this.sy = this.newSy();
-            return true;
         }
         else if (syData === 'timer') {
             beat.showTimer = true;
-            this.sy = this.newSy();
-            return true;
         }
         else {
             // string didn't match any beat effect syntax
@@ -14771,6 +15088,7 @@ class Gp3To5Importer extends ScoreImporter {
         this._trackCount = 0;
         this._playbackInfos = [];
         this._doubleBars = new Set();
+        this._clefsPerTrack = new Map();
         this._keySignatures = new Map();
         this._beatTextChunksByTrack = new Map();
         this._directionLookup = new Map();
@@ -15155,26 +15473,74 @@ class Gp3To5Importer extends ScoreImporter {
         mainStaff.capo = IOHelper.readInt32LE(this.data);
         newTrack.color = GpBinaryHelpers.gpReadColor(this.data, false);
         if (this._versionNumber >= 500) {
-            const staveFlags = this.data.readByte();
-            mainStaff.showTablature = (staveFlags & 0x01) !== 0;
-            mainStaff.showStandardNotation = (staveFlags & 0x02) !== 0;
-            const showChordDiagramListOnTopOfScore = (staveFlags & 0x64) !== 0;
+            const staffFlags = this.data.readByte();
+            mainStaff.showTablature = (staffFlags & 0x01) !== 0;
+            mainStaff.showStandardNotation = (staffFlags & 0x02) !== 0;
+            const showChordDiagramListOnTopOfScore = (staffFlags & 0x64) !== 0;
             if (this._score.stylesheet.perTrackChordDiagramsOnTop === null) {
                 this._score.stylesheet.perTrackChordDiagramsOnTop = new Map();
             }
             this._score.stylesheet.perTrackChordDiagramsOnTop.set(newTrack.index, showChordDiagramListOnTopOfScore);
-            // flags for
+            // MIDI: Automatic
+            //  0x01 -> always set (unknown)
             //  0x02 -> auto let ring
             //  0x04 -> auto brush
             this.data.readByte();
-            // unknown
-            this.data.skip(43);
+            // RSE: Auto-Accentuation on the Beat
+            // 0 - None
+            // 1 - Very Soft
+            // 2 - Soft
+            // 3 - Medium
+            // 4 - Strong
+            // 5 - Very Strong
+            this.data.readByte();
+            newTrack.playbackInfo.bank = this.data.readByte();
+            // RSE: Human Playing (1 byte, 0-100%)
+            this.data.readByte();
+            // `12` for all tunings which have bass clefs
+            const clefMode = IOHelper.readInt32LE(this.data);
+            if (clefMode === 12) {
+                this._clefsPerTrack.set(index, Clef.F4);
+            }
+            else {
+                this._clefsPerTrack.set(index, Clef.G2);
+            }
+            // Unknown, no UI setting seem to affect this
+            IOHelper.readInt32LE(this.data);
+            // Unknown, no UI setting seem to affect this
+            // typically: 100
+            IOHelper.readInt32LE(this.data);
+            // Unknown, no UI setting seem to affect this
+            // typically: 1 2 3 4 5 6 7 8 9 10
+            this.data.skip(10);
+            // Unknown, no UI setting seem to affect this
+            // typically: 255
+            this.data.readByte();
+            // Unknown, no UI setting seem to affect this
+            // typically: 3
+            this.data.readByte();
+            this.readRseBank();
+            // this.data.skip(42);
+            if (this._versionNumber >= 510) {
+                // RSE: 3-band EQ
+                // 1 byte Low
+                // 1 byte Mid
+                // 1 byte High
+                // 1 byte PRE
+                this.data.skip(4);
+                // RSE: effect name
+                GpBinaryHelpers.gpReadStringIntByte(this.data, this.settings.importer.encoding);
+                // RSE: effect category
+                GpBinaryHelpers.gpReadStringIntByte(this.data, this.settings.importer.encoding);
+            }
         }
-        // unknown
-        if (this._versionNumber >= 510) {
-            this.data.skip(4);
-            GpBinaryHelpers.gpReadStringIntByte(this.data, this.settings.importer.encoding);
-            GpBinaryHelpers.gpReadStringIntByte(this.data, this.settings.importer.encoding);
+        else {
+            if (GeneralMidi.isBass(newTrack.playbackInfo.program)) {
+                this._clefsPerTrack.set(index, Clef.F4);
+            }
+            else {
+                this._clefsPerTrack.set(index, Clef.G2);
+            }
         }
     }
     readBars() {
@@ -15190,6 +15556,9 @@ class Gp3To5Importer extends ScoreImporter {
         if (mainStaff.isPercussion) {
             newBar.clef = Clef.Neutral;
         }
+        else if (this._clefsPerTrack.has(track.index)) {
+            newBar.clef = this._clefsPerTrack.get(track.index);
+        }
         mainStaff.addBar(newBar);
         if (this._keySignatures.has(newBar.index)) {
             const newKeySignature = this._keySignatures.get(newBar.index);
@@ -15611,11 +15980,29 @@ class Gp3To5Importer extends ScoreImporter {
                 return 0;
         }
     }
+    readRseBank() {
+        // RSE Banks on disk are having filenames like this: 033_2_002.ini
+        // 033 is the RSE instrument (selected in the instrument list)
+        // 2 seem to be some sort of style variation. e.g. bass has multiple variations (1,2), guitars have only 1, percussion has only 0
+        //   likely for organizational purposes
+        // 002 is the effective soundbank (selected in the soundbank dropdown)
+        // RSE Instrument
+        this.data.skip(4); // IOHelper.readInt32LE(this.data);
+        // RSE Style/Variation
+        this.data.skip(4); //IOHelper.readInt32LE(this.data);
+        // RSE Soundbank
+        this.data.skip(4); //IOHelper.readInt32LE(this.data);
+        // Unknown, no UI setting seem to affect this
+        // typically: -1
+        this.data.skip(4); //IOHelper.readInt32LE(this.data);
+    }
     readMixTableChange(beat) {
         const tableChange = new MixTableChange();
         tableChange.instrument = IOHelper.readSInt8(this.data);
+        // NOTE: The UI shows a Midi Bank selection, but this information is not stored in the file
+        // when reopening the file the bank is always 0
         if (this._versionNumber >= 500) {
-            this.data.skip(16); // Rse Info
+            this.readRseBank();
         }
         tableChange.volume = IOHelper.readSInt8(this.data);
         tableChange.balance = IOHelper.readSInt8(this.data);
@@ -15627,7 +16014,7 @@ class Gp3To5Importer extends ScoreImporter {
             tableChange.tempoName = GpBinaryHelpers.gpReadStringIntByte(this.data, this.settings.importer.encoding);
         }
         tableChange.tempo = IOHelper.readInt32LE(this.data);
-        // durations
+        // durations (in number of beats)
         if (tableChange.volume >= 0) {
             this.data.readByte();
         }
@@ -15757,11 +16144,11 @@ class Gp3To5Importer extends ScoreImporter {
             newNote.fret = -1;
         }
         if (swapAccidentals) {
-            const accidental = Tuning.defaultAccidentals[newNote.realValueWithoutHarmonic % 12];
-            if (accidental === '#') {
+            const accidental = ModelUtils.computeAccidental(bar.keySignature, NoteAccidentalMode.Default, newNote.realValueWithoutHarmonic, false);
+            if (accidental === AccidentalType.Sharp) {
                 newNote.accidentalMode = NoteAccidentalMode.ForceFlat;
             }
-            else if (accidental === 'b') {
+            else if (accidental === AccidentalType.Flat) {
                 newNote.accidentalMode = NoteAccidentalMode.ForceSharp;
             }
         }
@@ -16610,9 +16997,7 @@ class BinaryStylesheet {
         return writer.toArray();
     }
     static addHeaderAndFooter(binaryStylesheet, style, prefix, name) {
-        if (style.template !== undefined) {
-            binaryStylesheet.addValue(`${prefix}${name}`, style.template, DataType.String);
-        }
+        binaryStylesheet.addValue(`${prefix}${name}`, style.template, DataType.String);
         binaryStylesheet.addValue(`${prefix}${name}Alignment`, style.textAlign, DataType.Integer);
         if (style.isVisible !== undefined) {
             binaryStylesheet.addValue(`${prefix}draw${name}`, style.isVisible, DataType.Boolean);
@@ -16646,6 +17031,7 @@ class GpifSound {
         this.path = '';
         this.role = '';
         this.program = 0;
+        this.bank = 0;
     }
     get uniqueId() {
         return `${this.path};${this.name};${this.role}`;
@@ -16661,6 +17047,7 @@ class GpifParser {
         this._backingTrackPadding = 0;
         this._doubleBars = new Set();
         this._keySignatures = new Map();
+        this._transposeKeySignaturePerTrack = new Map();
     }
     parseXml(xml, settings) {
         this._masterTrackAutomations = new Map();
@@ -16891,7 +17278,8 @@ class GpifParser {
                     assetId = c.innerText;
                     break;
                 case 'FramePadding':
-                    this._backingTrackPadding = GpifParser.parseIntSafe(c.innerText, 0) / GpifParser.SampleRate * 1000;
+                    this._backingTrackPadding =
+                        (GpifParser.parseIntSafe(c.innerText, 0) / GpifParser.SampleRate) * 1000;
                     break;
             }
         }
@@ -16998,21 +17386,28 @@ class GpifParser {
         if (!type) {
             return;
         }
-        let automation = null;
+        const newAutomations = [];
         switch (type) {
             case 'Tempo':
-                automation = Automation.buildTempoAutomation(isLinear, ratioPosition, numberValue, reference);
+                newAutomations.push(Automation.buildTempoAutomation(isLinear, ratioPosition, numberValue, reference));
                 break;
             case 'SyncPoint':
-                automation = new Automation();
-                automation.type = AutomationType.SyncPoint;
-                automation.isLinear = isLinear;
-                automation.ratioPosition = ratioPosition;
-                automation.syncPointValue = syncPointValue;
+                const syncPoint = new Automation();
+                syncPoint.type = AutomationType.SyncPoint;
+                syncPoint.isLinear = isLinear;
+                syncPoint.ratioPosition = ratioPosition;
+                syncPoint.syncPointValue = syncPointValue;
+                newAutomations.push(syncPoint);
                 break;
             case 'Sound':
                 if (textValue && sounds && sounds.has(textValue)) {
-                    automation = Automation.buildInstrumentAutomation(isLinear, ratioPosition, sounds.get(textValue).program);
+                    const bankChange = new Automation();
+                    bankChange.type = AutomationType.Bank;
+                    bankChange.ratioPosition = ratioPosition;
+                    bankChange.value = sounds.get(textValue).bank;
+                    newAutomations.push(bankChange);
+                    const programChange = Automation.buildInstrumentAutomation(isLinear, ratioPosition, sounds.get(textValue).program);
+                    newAutomations.push(programChange);
                 }
                 break;
             case 'SustainPedal':
@@ -17040,15 +17435,19 @@ class GpifParser {
                 }
                 break;
         }
-        if (automation) {
+        if (newAutomations.length) {
             if (text) {
-                automation.text = text;
+                for (const a of newAutomations) {
+                    a.text = text;
+                }
             }
             if (barIndex >= 0) {
                 if (!automations.has(barIndex)) {
                     automations.set(barIndex, []);
                 }
-                automations.get(barIndex).push(automation);
+                for (const a of newAutomations) {
+                    automations.get(barIndex).push(a);
+                }
             }
         }
     }
@@ -17127,13 +17526,13 @@ class GpifParser {
                     track.playbackInfo.isMute = state === 'Mute';
                     break;
                 case 'PartSounding':
-                    this.parsePartSounding(track, c);
+                    this.parsePartSounding(trackId, track, c);
                     break;
                 case 'Staves':
                     this.parseStaves(track, c);
                     break;
                 case 'Transpose':
-                    this.parseTranspose(track, c);
+                    this.parseTranspose(trackId, track, c);
                     break;
                 case 'RSE':
                     this.parseRSE(track, c);
@@ -17640,24 +18039,33 @@ class GpifParser {
                     break;
             }
         }
-        if (sound.role === 'Factory' || track.playbackInfo.program === 0) {
-            track.playbackInfo.program = sound.program;
-        }
         if (!this._soundsByTrack.has(trackId)) {
             this._soundsByTrack.set(trackId, new Map());
+            // apply first sound
+            track.playbackInfo.program = sound.program;
+            track.playbackInfo.bank = sound.bank;
         }
         this._soundsByTrack.get(trackId).set(sound.uniqueId, sound);
     }
     parseSoundMidi(sound, node) {
+        let bankMsb = 0;
+        let bankLsb = 0;
         for (const c of node.childElements()) {
             switch (c.localName) {
                 case 'Program':
                     sound.program = GpifParser.parseIntSafe(c.innerText, 0);
                     break;
+                case 'MSB': // coarse
+                    bankMsb = GpifParser.parseIntSafe(c.innerText, 0);
+                    break;
+                case 'LSB': // Fine
+                    bankLsb = GpifParser.parseIntSafe(c.innerText, 0);
+                    break;
             }
         }
+        sound.bank = ((bankMsb & 0x7f) << 7) | bankLsb;
     }
-    parsePartSounding(track, node) {
+    parsePartSounding(trackId, track, node) {
         for (const c of node.childElements()) {
             switch (c.localName) {
                 case 'TranspositionPitch':
@@ -17665,10 +18073,14 @@ class GpifParser {
                         staff.displayTranspositionPitch = GpifParser.parseIntSafe(c.innerText, 0);
                     }
                     break;
+                case 'NominalKey':
+                    const transposeIndex = Math.max(0, Tuning.noteNames.indexOf(c.innerText));
+                    this._transposeKeySignaturePerTrack.set(trackId, transposeIndex);
+                    break;
             }
         }
     }
-    parseTranspose(track, node) {
+    parseTranspose(trackId, track, node) {
         let octave = 0;
         let chromatic = 0;
         for (const c of node.childElements()) {
@@ -17681,9 +18093,14 @@ class GpifParser {
                     break;
             }
         }
+        const pitch = octave * 12 + chromatic;
         for (const staff of track.staves) {
-            staff.displayTranspositionPitch = octave * 12 + chromatic;
+            staff.displayTranspositionPitch = pitch;
         }
+        // the chromatic transpose also causes an alternative key signature to be adjusted
+        // In Guitar Pro this feature is hidden in the track properties (more -> Transposition tonality -> 'C played as:' ).
+        const transposeIndex = ModelUtils.flooredDivision(pitch, 12);
+        this._transposeKeySignaturePerTrack.set(trackId, transposeIndex);
     }
     parseRSE(track, node) {
         for (const c of node.childElements()) {
@@ -18647,6 +19064,7 @@ class GpifParser {
         // GP6 had percussion as element+variation
         let element = -1;
         let variation = -1;
+        let hasTransposedPitch = false;
         for (const c of node.childElements()) {
             switch (c.localName) {
                 case 'Property':
@@ -18727,7 +19145,15 @@ class GpifParser {
                             note.tone = GpifParser.parseIntSafe(c.findChildElement('Step')?.innerText, 0);
                             break;
                         case 'ConcertPitch':
+                            if (!hasTransposedPitch) {
+                                this.parseConcertPitch(c, note);
+                            }
+                            break;
+                        case 'TransposedPitch':
+                            // clear potential value from concert pitch
+                            note.accidentalMode = NoteAccidentalMode.Default;
                             this.parseConcertPitch(c, note);
+                            hasTransposedPitch = true;
                             break;
                         case 'Bended':
                             isBended = true;
@@ -18941,20 +19367,29 @@ class GpifParser {
             lastMasterBar.isDoubleBar = false;
         }
         // add tracks to score
+        const trackIndexToTrackId = [];
         for (const trackId of this._tracksMapping) {
             if (!trackId) {
                 continue;
             }
             const track = this._tracksById.get(trackId);
             this.score.addTrack(track);
+            trackIndexToTrackId.push(trackId);
         }
         // process all masterbars
         let keySignature;
         for (const barIds of this._barsOfMasterBar) {
             // add all bars of masterbar vertically to all tracks
             let staffIndex = 0;
+            let trackIndex = 0;
             keySignature = [KeySignature.C, KeySignatureType.Major];
-            for (let barIndex = 0, trackIndex = 0; barIndex < barIds.length && trackIndex < this.score.tracks.length; barIndex++) {
+            if (this._transposeKeySignaturePerTrack.has(trackIndexToTrackId[0])) {
+                keySignature = [
+                    ModelUtils.transposeKey(keySignature[0], this._transposeKeySignaturePerTrack.get(trackIndexToTrackId[0])),
+                    keySignature[1]
+                ];
+            }
+            for (let barIndex = 0; barIndex < barIds.length && trackIndex < this.score.tracks.length; barIndex++) {
                 const barId = barIds[barIndex];
                 if (barId !== GpifParser.InvalidId) {
                     const bar = this._barsById.get(barId);
@@ -18964,6 +19399,12 @@ class GpifParser {
                     const masterBarIndex = staff.bars.length - 1;
                     if (this._keySignatures.has(masterBarIndex)) {
                         keySignature = this._keySignatures.get(masterBarIndex);
+                        if (this._transposeKeySignaturePerTrack.has(trackIndexToTrackId[trackIndex])) {
+                            keySignature = [
+                                ModelUtils.transposeKey(keySignature[0], this._transposeKeySignaturePerTrack.get(trackIndexToTrackId[trackIndex])),
+                                keySignature[1]
+                            ];
+                        }
                     }
                     bar.keySignature = keySignature[0];
                     bar.keySignatureType = keySignature[1];
@@ -19030,11 +19471,17 @@ class GpifParser {
                     if (staffIndex === track.staves.length - 1) {
                         trackIndex++;
                         staffIndex = 0;
-                        keySignature = [KeySignature.C, KeySignatureType.Major];
                     }
                     else {
                         staffIndex++;
-                        keySignature = [KeySignature.C, KeySignatureType.Major];
+                    }
+                    keySignature = [KeySignature.C, KeySignatureType.Major];
+                    if (trackIndex < trackIndexToTrackId.length &&
+                        this._transposeKeySignaturePerTrack.has(trackIndexToTrackId[trackIndex])) {
+                        keySignature = [
+                            ModelUtils.transposeKey(keySignature[0], this._transposeKeySignaturePerTrack.get(trackIndexToTrackId[trackIndex])),
+                            keySignature[1]
+                        ];
                     }
                 }
                 else {
@@ -19070,7 +19517,12 @@ class GpifParser {
                             for (const a of automations) {
                                 // NOTE: currently the automations of a bar are applied to the
                                 // first beat of a bar
-                                beat.automations.push(a);
+                                const skip = 
+                                // skip bank automations if they are 0 at start
+                                a.type === AutomationType.Bank && a.value === 0 && bar.index === 0;
+                                if (!skip) {
+                                    beat.automations.push(a);
+                                }
                             }
                         }
                     }
@@ -19122,7 +19574,7 @@ GpifParser.BendPointPositionFactor = BendPoint.MaxPosition / 100.0;
  */
 GpifParser.BendPointValueFactor = 1 / 25.0;
 // tests have shown that Guitar Pro seem to always work with 44100hz for the frame offsets,
-// they are NOT using the sample rate of the input file. 
+// they are NOT using the sample rate of the input file.
 // Downsampling a 44100hz ogg to 8000hz and using it in as audio track resulted in the same frame offset when placing sync points.
 GpifParser.SampleRate = 44100;
 
@@ -19817,49 +20269,6 @@ class GpxImporter extends ScoreImporter {
     }
 }
 
-/**
- * Defines all possible accidentals for notes.
- */
-var AccidentalType;
-(function (AccidentalType) {
-    /**
-     * No accidental
-     */
-    AccidentalType[AccidentalType["None"] = 0] = "None";
-    /**
-     * Naturalize
-     */
-    AccidentalType[AccidentalType["Natural"] = 1] = "Natural";
-    /**
-     * Sharp
-     */
-    AccidentalType[AccidentalType["Sharp"] = 2] = "Sharp";
-    /**
-     * Flat
-     */
-    AccidentalType[AccidentalType["Flat"] = 3] = "Flat";
-    /**
-     * Natural for smear bends
-     */
-    AccidentalType[AccidentalType["NaturalQuarterNoteUp"] = 4] = "NaturalQuarterNoteUp";
-    /**
-     * Sharp for smear bends
-     */
-    AccidentalType[AccidentalType["SharpQuarterNoteUp"] = 5] = "SharpQuarterNoteUp";
-    /**
-     * Flat for smear bends
-     */
-    AccidentalType[AccidentalType["FlatQuarterNoteUp"] = 6] = "FlatQuarterNoteUp";
-    /**
-     * Double Sharp, indicated by an 'x'
-     */
-    AccidentalType[AccidentalType["DoubleSharp"] = 7] = "DoubleSharp";
-    /**
-     * Double Flat, indicated by 'bb'
-     */
-    AccidentalType[AccidentalType["DoubleFlat"] = 8] = "DoubleFlat";
-})(AccidentalType || (AccidentalType = {}));
-
 class BeatLines {
     constructor() {
         this.maxLine = -1e3;
@@ -19962,90 +20371,6 @@ class AccidentalHelper {
         }
         return line;
     }
-    static computeAccidental(keySignature, accidentalMode, noteValue, quarterBend, currentAccidental = null) {
-        const ks = keySignature;
-        const ksi = ks + 7;
-        const index = noteValue % 12;
-        const accidentalForKeySignature = ksi < 7 ? AccidentalType.Flat : AccidentalType.Sharp;
-        const hasKeySignatureAccidentalSetForNote = AccidentalHelper.KeySignatureLookup[ksi][index];
-        const hasNoteAccidentalWithinOctave = AccidentalHelper.AccidentalNotes[index];
-        // the general logic is like this:
-        // - we check if the key signature has an accidental defined
-        // - we calculate which accidental a note needs according to its index in the octave
-        // - if the accidental is already placed at this line, nothing needs to be done, otherwise we place it
-        // - if there should not be an accidental, but there is one in the key signature, we clear it.
-        // the exceptions are:
-        // - for quarter bends we just place the corresponding accidental
-        // - the accidental mode can enforce the accidentals for the note
-        let accidentalToSet = AccidentalType.None;
-        if (quarterBend) {
-            accidentalToSet = hasNoteAccidentalWithinOctave ? accidentalForKeySignature : AccidentalType.Natural;
-            switch (accidentalToSet) {
-                case AccidentalType.Natural:
-                    accidentalToSet = AccidentalType.NaturalQuarterNoteUp;
-                    break;
-                case AccidentalType.Sharp:
-                    accidentalToSet = AccidentalType.SharpQuarterNoteUp;
-                    break;
-                case AccidentalType.Flat:
-                    accidentalToSet = AccidentalType.FlatQuarterNoteUp;
-                    break;
-            }
-        }
-        else {
-            // define which accidental should be shown ignoring what might be set on the KS already
-            switch (accidentalMode) {
-                case NoteAccidentalMode.ForceSharp:
-                    accidentalToSet = AccidentalType.Sharp;
-                    break;
-                case NoteAccidentalMode.ForceDoubleSharp:
-                    accidentalToSet = AccidentalType.DoubleSharp;
-                    break;
-                case NoteAccidentalMode.ForceFlat:
-                    accidentalToSet = AccidentalType.Flat;
-                    break;
-                case NoteAccidentalMode.ForceDoubleFlat:
-                    accidentalToSet = AccidentalType.DoubleFlat;
-                    break;
-                default:
-                    // if note has an accidental in the octave, we place a symbol
-                    // according to the Key Signature
-                    if (hasNoteAccidentalWithinOctave) {
-                        accidentalToSet = accidentalForKeySignature;
-                    }
-                    else if (hasKeySignatureAccidentalSetForNote) {
-                        // note does not get an accidental, but KS defines one -> Naturalize
-                        accidentalToSet = AccidentalType.Natural;
-                    }
-                    break;
-            }
-            // do we need an accidental on the note?
-            if (accidentalToSet !== AccidentalType.None) {
-                // if there is no accidental on the line, and the key signature has it set already, we clear it on the note
-                if (currentAccidental != null) {
-                    if (currentAccidental === accidentalToSet) {
-                        accidentalToSet = AccidentalType.None;
-                    }
-                }
-                else if (hasKeySignatureAccidentalSetForNote && accidentalToSet === accidentalForKeySignature) {
-                    accidentalToSet = AccidentalType.None;
-                }
-            }
-            else {
-                // if we don't want an accidental, but there is already one applied, we place a naturalize accidental
-                // and clear the registration
-                if (currentAccidental !== null) {
-                    if (currentAccidental === AccidentalType.Natural) {
-                        accidentalToSet = AccidentalType.None;
-                    }
-                    else {
-                        accidentalToSet = AccidentalType.Natural;
-                    }
-                }
-            }
-        }
-        return accidentalToSet;
-    }
     getAccidental(noteValue, quarterBend, relatedBeat, isHelperNote, note = null) {
         let steps = 0;
         let accidentalToSet = AccidentalType.None;
@@ -20059,7 +20384,7 @@ class AccidentalHelper {
             const currentAccidental = this._registeredAccidentals.has(steps)
                 ? this._registeredAccidentals.get(steps)
                 : null;
-            accidentalToSet = AccidentalHelper.computeAccidental(this._bar.keySignature, accidentalMode, noteValue, quarterBend, currentAccidental);
+            accidentalToSet = ModelUtils.computeAccidental(this._bar.keySignature, accidentalMode, noteValue, quarterBend, currentAccidental);
             let skipAccidental = false;
             switch (accidentalToSet) {
                 case AccidentalType.NaturalQuarterNoteUp:
@@ -20173,48 +20498,6 @@ class AccidentalHelper {
         return 0;
     }
 }
-/**
- * a lookup list containing an info whether the notes within an octave
- * need an accidental rendered. the accidental symbol is determined based on the type of key signature.
- */
-AccidentalHelper.KeySignatureLookup = [
-    // Flats (where the value is true, a flat accidental is required for the notes)
-    [true, true, true, true, true, true, true, true, true, true, true, true],
-    [true, true, true, true, true, false, true, true, true, true, true, true],
-    [false, true, true, true, true, false, true, true, true, true, true, true],
-    [false, true, true, true, true, false, false, false, true, true, true, true],
-    [false, false, false, true, true, false, false, false, true, true, true, true],
-    [false, false, false, true, true, false, false, false, false, false, true, true],
-    [false, false, false, false, false, false, false, false, false, false, true, true],
-    // natural
-    [false, false, false, false, false, false, false, false, false, false, false, false],
-    // sharps  (where the value is true, a flat accidental is required for the notes)
-    [false, false, false, false, false, true, true, false, false, false, false, false],
-    [true, true, false, false, false, true, true, false, false, false, false, false],
-    [true, true, false, false, false, true, true, true, true, false, false, false],
-    [true, true, true, true, false, true, true, true, true, false, false, false],
-    [true, true, true, true, false, true, true, true, true, true, true, false],
-    [true, true, true, true, true, true, true, true, true, true, true, false],
-    [true, true, true, true, true, true, true, true, true, true, true, true]
-];
-/**
- * Contains the list of notes within an octave have accidentals set.
- */
-// prettier-ignore
-AccidentalHelper.AccidentalNotes = [
-    false,
-    true,
-    false,
-    true,
-    false,
-    false,
-    true,
-    false,
-    true,
-    false,
-    true,
-    false
-];
 /**
  * We always have 7 steps per octave.
  * (by a step the offsets inbetween score lines is meant,
@@ -20259,6 +20542,10 @@ class InstrumentArticulationWithPlaybackInfo extends InstrumentArticulation {
          * The midi channel program to use when playing the note (-1 if using the default track program).
          */
         this.outputMidiProgram = -1;
+        /**
+         * The midi bank to use when playing the note (-1 if using the default track bank).
+         */
+        this.outputMidiBank = -1;
         /**
          * The volume to use when playing the note (-1 if using the default track volume).
          */
@@ -20757,6 +21044,9 @@ class MusicXmlImporter extends ScoreImporter {
             if (trackInfo.firstArticulation.outputMidiProgram >= 0) {
                 track.playbackInfo.program = trackInfo.firstArticulation.outputMidiProgram;
             }
+            if (trackInfo.firstArticulation.outputMidiBank >= 0) {
+                track.playbackInfo.bank = trackInfo.firstArticulation.outputMidiBank;
+            }
             if (trackInfo.firstArticulation.outputBalance >= 0) {
                 track.playbackInfo.balance = trackInfo.firstArticulation.outputBalance;
             }
@@ -20788,7 +21078,9 @@ class MusicXmlImporter extends ScoreImporter {
                     articulation.outputMidiChannel = Number.parseInt(c.innerText) - 1;
                     break;
                 // case 'midi-name': Ignored
-                // case 'midi-bank': Not supported (https://github.com/CoderLine/alphaTab/issues/1986)
+                case 'midi-bank':
+                    articulation.outputMidiBank = Number.parseInt(c.innerText) - 1;
+                    break;
                 case 'midi-program':
                     articulation.outputMidiProgram = Number.parseInt(c.innerText) - 1;
                     break;
@@ -21318,7 +21610,15 @@ class MusicXmlImporter extends ScoreImporter {
             switch (c.localName) {
                 // case 'midi-channel': Ignored
                 // case 'midi-name': Ignored
-                // case 'midi-bank': Ignored
+                case 'midi-bank':
+                    if (!this._nextBeatAutomations) {
+                        this._nextBeatAutomations = [];
+                    }
+                    automation = new Automation();
+                    automation.type = AutomationType.Bank;
+                    automation.value = Number.parseInt(c.innerText) - 1;
+                    this._nextBeatAutomations.push(automation);
+                    break;
                 case 'midi-program':
                     if (!this._nextBeatAutomations) {
                         this._nextBeatAutomations = [];
@@ -23589,11 +23889,15 @@ class CircularSampleBuffer {
 }
 
 class EventEmitter {
-    constructor() {
+    constructor(fireOnRegister = undefined) {
         this._listeners = [];
+        this._fireOnRegister = fireOnRegister;
     }
     on(value) {
         this._listeners.push(value);
+        if (this._fireOnRegister?.()) {
+            value();
+        }
         return () => {
             this.off(value);
         };
@@ -23611,11 +23915,18 @@ class EventEmitter {
  * @partial
  */
 class EventEmitterOfT {
-    constructor() {
+    constructor(fireOnRegister = undefined) {
         this._listeners = [];
+        this._fireOnRegister = fireOnRegister;
     }
     on(value) {
         this._listeners.push(value);
+        if (this._fireOnRegister) {
+            const arg = this._fireOnRegister();
+            if (arg !== null) {
+                value(arg);
+            }
+        }
         return () => {
             this.off(value);
         };
@@ -30656,6 +30967,12 @@ class AlphaSynthBase {
         this.sequencer.playbackSpeed = value;
         this.timePosition = this.timePosition * (oldSpeed / value);
     }
+    get loadedMidiInfo() {
+        return this._loadedMidiInfo;
+    }
+    get currentPosition() {
+        return this._currentPosition;
+    }
     get tickPosition() {
         return this._tickPosition;
     }
@@ -30713,22 +31030,38 @@ class AlphaSynthBase {
         this._midiEventsPlayedFilter = new Set();
         this._notPlayedSamples = 0;
         this._synthStopping = false;
+        this._currentPosition = new PositionChangedEventArgs(0, 0, 0, 0, false, 120, 120);
         this.isReady = false;
         this.state = PlayerState.Paused;
         this._loadedSoundFonts = [];
-        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();
         Logger.debug('AlphaSynth', 'Initializing player');
         this.state = PlayerState.Paused;
+        this.ready = new EventEmitter(() => this.isReady);
+        this.readyForPlayback = new EventEmitter(() => this.isReadyForPlayback);
+        this.midiLoaded = new EventEmitterOfT(() => {
+            if (this._loadedMidiInfo) {
+                return this._loadedMidiInfo;
+            }
+            return null;
+        });
+        this.stateChanged = new EventEmitterOfT(() => {
+            return new PlayerStateChangedEventArgs(this.state, false);
+        });
+        this.positionChanged = new EventEmitterOfT(() => {
+            return this._currentPosition;
+        });
+        this.playbackRangeChanged = new EventEmitterOfT(() => {
+            if (this.playbackRange) {
+                return new PlaybackRangeChangedEventArgs(this.playbackRange);
+            }
+            return null;
+        });
         Logger.debug('AlphaSynth', 'Creating output');
         this._output = output;
         Logger.debug('AlphaSynth', 'Creating synthesizer');
@@ -30906,7 +31239,8 @@ class AlphaSynthBase {
             Logger.debug('AlphaSynth', 'Loading midi from model');
             this.sequencer.loadMidi(midi);
             this._isMidiLoaded = true;
-            this.midiLoaded.trigger(new PositionChangedEventArgs(0, this.sequencer.currentEndTime, 0, this.sequencer.currentEndTick, false, this.sequencer.currentTempo, this.sequencer.modifiedTempo));
+            this._loadedMidiInfo = new PositionChangedEventArgs(0, this.sequencer.currentEndTime, 0, this.sequencer.currentEndTick, false, this.sequencer.currentTempo, this.sequencer.modifiedTempo);
+            this.midiLoaded.trigger(this._loadedMidiInfo);
             Logger.debug('AlphaSynth', 'Midi successfully loaded');
             this.checkReadyForPlayback();
             this.tickPosition = 0;
@@ -31009,23 +31343,28 @@ class AlphaSynthBase {
         this.sequencer.resetOneTimeMidi();
         this.timePosition = this.sequencer.currentTime;
     }
-    updateTimePosition(timePosition, isSeek) {
-        // update the real positions
-        let currentTime = timePosition;
-        this._timePosition = currentTime;
+    createPositionChangedEventArgs(isSeek) {
+        // on fade outs we can have some milliseconds longer, ensure we don't report this
+        let currentTime = this._timePosition;
         let currentTick = this.sequencer.currentTimePositionToTickPosition(currentTime);
-        this._tickPosition = currentTick;
         const endTime = this.sequencer.currentEndTime;
         const endTick = this.sequencer.currentEndTick;
-        // on fade outs we can have some milliseconds longer, ensure we don't report this
         if (currentTime > endTime) {
             currentTime = endTime;
             currentTick = endTick;
         }
+        return new PositionChangedEventArgs(currentTime, endTime, currentTick, endTick, isSeek, this.sequencer.currentTempo, this.sequencer.modifiedTempo);
+    }
+    updateTimePosition(timePosition, isSeek) {
+        // update the real positions
+        this._timePosition = timePosition;
+        const args = this.createPositionChangedEventArgs(isSeek);
+        this._tickPosition = args.currentTick;
         const mode = this.sequencer.isPlayingMain ? 'main' : this.sequencer.isPlayingCountIn ? 'count-in' : 'one-time';
-        Logger.debug('AlphaSynth', `Position changed: (time: ${currentTime}/${endTime}, tick: ${currentTick}/${endTick}, Active Voices: ${this.synthesizer.activeVoiceCount} (${mode}), Tempo original: ${this.sequencer.currentTempo}, Tempo modified: ${this.sequencer.modifiedTempo})`);
+        Logger.debug('AlphaSynth', `Position changed: (time: ${args.currentTime}/${args.endTime}, tick: ${args.currentTick}/${args.endTick}, Active Voices: ${this.synthesizer.activeVoiceCount} (${mode}), Tempo original: ${this.sequencer.currentTempo}, Tempo modified: ${this.sequencer.modifiedTempo})`);
         if (this.sequencer.isPlayingMain) {
-            this.positionChanged.trigger(new PositionChangedEventArgs(currentTime, endTime, currentTick, endTick, isSeek, this.sequencer.currentTempo, this.sequencer.modifiedTempo));
+            this._currentPosition = args;
+            this.positionChanged.trigger(args);
         }
         // build events which were actually played
         if (isSeek) {
@@ -31033,7 +31372,7 @@ class AlphaSynthBase {
         }
         else {
             const playedEvents = [];
-            while (!this._playedEventsQueue.isEmpty && this._playedEventsQueue.peek().time < currentTime) {
+            while (!this._playedEventsQueue.isEmpty && this._playedEventsQueue.peek().time < args.currentTime) {
                 const synthEvent = this._playedEventsQueue.dequeue();
                 playedEvents.push(synthEvent.event);
             }
@@ -36484,6 +36823,15 @@ class Settings {
     fillFromJson(json) {
         SettingsSerializer.fromJson(this, json);
     }
+    /**
+     * handles backwards compatibility aspects on the settings, removed in 2.0
+     * @internal
+     */
+    handleBackwardsCompatibility() {
+        if (this.player.playerMode === PlayerMode.Disabled && this.player.enablePlayer) {
+            this.player.playerMode = PlayerMode.EnabledAutomatic;
+        }
+    }
 }
 
 class SectionSerializer {
@@ -37701,6 +38049,7 @@ class PlaybackInformationSerializer {
         o.set("balance", obj.balance);
         o.set("port", obj.port);
         o.set("program", obj.program);
+        o.set("bank", obj.bank);
         o.set("primarychannel", obj.primaryChannel);
         o.set("secondarychannel", obj.secondaryChannel);
         o.set("ismute", obj.isMute);
@@ -37721,6 +38070,9 @@ class PlaybackInformationSerializer {
             case "program":
                 obj.program = v;
                 return true;
+            case "bank":
+                obj.bank = v;
+                return true;
             case "primarychannel":
                 obj.primaryChannel = v;
                 return true;
@@ -41379,6 +41731,11 @@ class MidiFileGenerator {
             this._programsPerChannel.set(channel, program);
         }
     }
+    addBankChange(track, tick, channel, bank) {
+        const lsbMsb = GeneralMidi.bankToLsbMsb(bank);
+        this._handler.addControlChange(track.index, tick, channel, ControllerType.BankSelectCoarse, lsbMsb[1]);
+        this._handler.addControlChange(track.index, tick, channel, ControllerType.BankSelectFine, lsbMsb[0]);
+    }
     static buildTranspositionPitches(score, settings) {
         const transpositionPitches = new Map();
         for (const track of score.tracks) {
@@ -41406,6 +41763,7 @@ class MidiFileGenerator {
         // Set PitchBendRangeCoarse to 12
         this._handler.addControlChange(track.index, 0, channel, ControllerType.DataEntryFine, 0);
         this._handler.addControlChange(track.index, 0, channel, ControllerType.DataEntryCoarse, MidiFileGenerator.PitchBendRangeInSemitones);
+        this.addBankChange(track, 0, channel, playbackInfo.bank);
         this.addProgramChange(track, 0, channel, playbackInfo.program);
     }
     /**
@@ -42701,6 +43059,10 @@ class MidiFileGenerator {
                 this.addProgramChange(beat.voice.bar.staff.track, beat.playbackStart + startMove, beat.voice.bar.staff.track.playbackInfo.primaryChannel, (automation.value | 0) & 0xff);
                 this.addProgramChange(beat.voice.bar.staff.track, beat.playbackStart + startMove, beat.voice.bar.staff.track.playbackInfo.secondaryChannel, (automation.value | 0) & 0xff);
                 break;
+            case AutomationType.Bank:
+                this.addBankChange(beat.voice.bar.staff.track, beat.playbackStart + startMove, beat.voice.bar.staff.track.playbackInfo.primaryChannel, automation.value);
+                this.addBankChange(beat.voice.bar.staff.track, beat.playbackStart + startMove, beat.voice.bar.staff.track.playbackInfo.secondaryChannel, automation.value);
+                break;
             case AutomationType.Balance:
                 const balance = MidiFileGenerator.toChannelShort(automation.value);
                 this._handler.addControlChange(beat.voice.bar.staff.track.index, beat.playbackStart + startMove, beat.voice.bar.staff.track.playbackInfo.primaryChannel, ControllerType.PanCoarse, balance);
@@ -43650,17 +44012,29 @@ class AlphaSynthWrapper {
         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();
+        this.ready = new EventEmitter(() => this.isReady);
+        this.readyForPlayback = new EventEmitter(() => this.isReadyForPlayback);
+        this.midiLoaded = new EventEmitterOfT(() => {
+            return this._instance?.loadedMidiInfo ?? null;
+        });
+        this.stateChanged = new EventEmitterOfT(() => {
+            return new PlayerStateChangedEventArgs(this.state, false);
+        });
+        this.positionChanged = new EventEmitterOfT(() => {
+            return this.currentPosition;
+        });
+        this.playbackRangeChanged = new EventEmitterOfT(() => {
+            const range = this.playbackRange;
+            if (range) {
+                return new PlaybackRangeChangedEventArgs(range);
+            }
+            return null;
+        });
     }
     get instance() {
         return this._instance;
@@ -43682,10 +44056,14 @@ class AlphaSynthWrapper {
             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.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.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;
@@ -43764,6 +44142,14 @@ class AlphaSynthWrapper {
             this._instance.playbackSpeed = value;
         }
     }
+    get loadedMidiInfo() {
+        return this._instance ? this._instance.loadedMidiInfo : undefined;
+    }
+    get currentPosition() {
+        return this._instance
+            ? this._instance.currentPosition
+            : new PositionChangedEventArgs(0, 0, 0, 0, false, 120, 120);
+    }
     get tickPosition() {
         return this._instance ? this._instance.tickPosition : 0;
     }
@@ -44105,83 +44491,6 @@ class AlphaTabApiBase {
         this._previousStateForCursor = PlayerState.Paused;
         this._previousCursorCache = null;
         this._lastScroll = 0;
-        /**
-         * This event is fired when the played beat changed.
-         *
-         * @eventProperty
-         * @category Events - Player
-         * @since 0.9.4
-         *
-         * @example
-         * JavaScript
-         * ```js
-         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-         * api.playedBeatChanged.on((beat) => {
-         *     updateFretboard(beat);
-         * });
-         * ```
-         *
-         * @example
-         * C#
-         * ```cs
-         * var api = new AlphaTabApi<MyControl>(...);
-         * api.PlayedBeatChanged.On(beat =>
-         * {
-         *     UpdateFretboard(beat);
-         * });
-         * ```
-         *
-         * @example
-         * Android
-         * ```kotlin
-         * val api = AlphaTabApi<MyControl>(...)
-         * api.playedBeatChanged.on { beat ->
-         *     updateFretboard(beat)
-         * }
-         * ```
-         *
-         */
-        this.playedBeatChanged = new EventEmitterOfT();
-        /**
-         * This event is fired when the currently active beats across all tracks change.
-         *
-         * @remarks
-         * Unlike the {@link playedBeatChanged} event this event contains the beats of all tracks and voices independent of them being rendered.
-         *
-         * @eventProperty
-         * @category Events - Player
-         * @since 1.2.3
-         *
-         * @example
-         * JavaScript
-         * ```js
-         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-         * api.activeBeatsChanged.on(args => {
-         *    updateHighlights(args.activeBeats);
-         * });
-         * ```
-         *
-         * @example
-         * C#
-         * ```cs
-         * var api = new AlphaTabApi<MyControl>(...);
-         * api.ActiveBeatsChanged.On(args =>
-         * {
-         *     UpdateHighlights(args.ActiveBeats);
-         * });
-         * ```
-         *
-         * @example
-         * Android
-         * ```kotlin
-         * val api = AlphaTabApi<MyControl>(...)
-         * api.activeBeatsChanged.on { args ->
-         *     updateHighlights(args.activeBeats)
-         * }
-         * ```
-         *
-         */
-        this.activeBeatsChanged = new EventEmitterOfT();
         this._beatMouseDown = false;
         this._noteMouseDown = false;
         this._selectionStart = null;
@@ -44420,47 +44729,6 @@ class AlphaTabApiBase {
          *
          */
         this.noteMouseUp = new EventEmitterOfT();
-        /**
-         * This event is fired whenever a new song is loaded.
-         * @remarks
-         * This event is fired whenever a new song is loaded or changing due to {@link renderScore} or {@link renderTracks} calls.
-         * It is fired after the transposition midi pitches from the settings were applied, but before any midi is generated or rendering is started.
-         * This allows any modification of the score before further processing.
-         *
-         * @eventProperty
-         * @category Events - Core
-         * @since 0.9.4
-         *
-         * @example
-         * JavaScript
-         * ```js
-         * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'));
-         * api.scoreLoaded.on((score) => {
-         *     updateSongInformationInUi(score);
-         * });
-         * ```
-         *
-         * @example
-         * C#
-         * ```cs
-         * var api = new AlphaTabApi<MyControl>(...);
-         * api.ScoreLoaded.On(score =>
-         * {
-         *     UpdateSongInformationInUi(score);
-         * });
-         * ```
-         *
-         * @example
-         * Android
-         * ```kotlin
-         * val api = AlphaTabApi<MyControl>(...)
-         * api.scoreLoaded.on { score ->
-         *     updateSongInformationInUi(score)
-         * }
-         * ```
-         *
-         */
-        this.scoreLoaded = new EventEmitterOfT();
         /**
          * This event is fired when alphaTab was resized and is about to rerender the music notation.
          * @remarks
@@ -44719,46 +44987,6 @@ class AlphaTabApiBase {
          *
          */
         this.midiLoad = new EventEmitterOfT();
-        /**
-         * This event is fired when the Midi file 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.midiLoaded.on(e => {
-         *     hideGeneratingAudioIndicator();
-         *     updateSongDuration(e.endTime);
-         * });
-         * ```
-         *
-         * @example
-         * C#
-         * ```cs
-         * var api = new AlphaTabApi<MyControl>(...);
-         * api.MidiLoaded.On(e =>
-         * {
-         *     HideGeneratingAudioIndicator();
-         *     UpdateSongDuration(e.EndTime);
-         * });
-         * ```
-         *
-         * @example
-         * Android
-         * ```kotlin
-         * val api = AlphaTabApi<MyControl>(...)
-         * api.midiLoaded.on { e ->
-         *     hideGeneratingAudioIndicator()
-         *     updateSongDuration(e.endTime)
-         * }
-         * ```
-         *
-         */
-        this.midiLoaded = new EventEmitterOfT();
         /**
          * This event is fired when a settings update was requested.
          *
@@ -44798,12 +45026,30 @@ class AlphaTabApiBase {
         this.settingsUpdated = new EventEmitter();
         this.uiFacade = uiFacade;
         this.container = uiFacade.rootContainer;
+        this.activeBeatsChanged = new EventEmitterOfT(() => {
+            if (this._player.state === PlayerState.Playing && this._currentBeat) {
+                return new ActiveBeatsChangedEventArgs(this._currentBeat.beatLookup.highlightedBeats.map(h => h.beat));
+            }
+            return null;
+        });
+        this.playedBeatChanged = new EventEmitterOfT(() => {
+            if (this._player.state === PlayerState.Playing && this._currentBeat) {
+                return this._currentBeat.beat;
+            }
+            return null;
+        });
+        this.scoreLoaded = new EventEmitterOfT(() => {
+            if (this._score) {
+                return this._score;
+            }
+            return null;
+        });
+        this.midiLoaded = new EventEmitterOfT(() => {
+            return this._player.loadedMidiInfo ?? null;
+        });
         uiFacade.initialize(this, settings);
         Logger.logLevel = this.settings.core.logLevel;
-        // backwards compatibility: remove in 2.0
-        if (this.settings.player.playerMode === PlayerMode.Disabled && this.settings.player.enablePlayer) {
-            this.settings.player.playerMode = PlayerMode.EnabledAutomatic;
-        }
+        this.settings.handleBackwardsCompatibility();
         Environment.printEnvironmentInfo(false);
         this.canvasElement = uiFacade.createCanvasElement();
         this.container.appendChild(this.canvasElement);
@@ -44962,6 +45208,7 @@ class AlphaTabApiBase {
      * ```
      */
     updateSettings() {
+        this.settings.handleBackwardsCompatibility();
         const score = this.score;
         if (score) {
             ModelUtils.applyPitchOffsets(this.settings, score);
@@ -45769,6 +46016,22 @@ class AlphaTabApiBase {
     set timePosition(value) {
         this._player.timePosition = value;
     }
+    /**
+     * The total length of the song in midi ticks.
+     * @category Properties - Player
+     * @since 1.6.2
+     */
+    get endTick() {
+        return this._player.currentPosition.endTick;
+    }
+    /**
+     * The total length of the song in milliseconds.
+     * @category Properties - Player
+     * @since 1.6.2
+     */
+    get endTime() {
+        return this._player.currentPosition.endTime;
+    }
     /**
      * The range of the song that should be played.
      * @remarks
@@ -48093,27 +48356,33 @@ class AlphaSynthWebWorkerApi {
             value: value
         });
     }
+    get loadedMidiInfo() {
+        return this.loadedMidiInfo;
+    }
+    get currentPosition() {
+        return this._currentPosition;
+    }
     get tickPosition() {
-        return this._tickPosition;
+        return this._currentPosition.currentTick;
     }
     set tickPosition(value) {
         if (value < 0) {
             value = 0;
         }
-        this._tickPosition = value;
+        this._currentPosition = new PositionChangedEventArgs(this._currentPosition.currentTime, this._currentPosition.endTime, value, this._currentPosition.endTick, true, this._currentPosition.originalTempo, this._currentPosition.modifiedTempo);
         this._synth.postMessage({
             cmd: 'alphaSynth.setTickPosition',
             value: value
         });
     }
     get timePosition() {
-        return this._timePosition;
+        return this._currentPosition.currentTime;
     }
     set timePosition(value) {
         if (value < 0) {
             value = 0;
         }
-        this._timePosition = value;
+        this._currentPosition = new PositionChangedEventArgs(value, this._currentPosition.endTime, this._currentPosition.currentTick, this._currentPosition.endTick, true, this._currentPosition.originalTempo, this._currentPosition.modifiedTempo);
         this._synth.postMessage({
             cmd: 'alphaSynth.setTimePosition',
             value: value
@@ -48156,11 +48425,10 @@ class AlphaSynthWebWorkerApi {
         this._metronomeVolume = 0;
         this._countInVolume = 0;
         this._playbackSpeed = 0;
-        this._tickPosition = 0;
-        this._timePosition = 0;
         this._isLooping = false;
         this._playbackRange = null;
         this._midiEventsPlayedFilter = [];
+        this._currentPosition = new PositionChangedEventArgs(0, 0, 0, 0, false, 120, 120);
         this.ready = new EventEmitter();
         this.readyForPlayback = new EventEmitter();
         this.finished = new EventEmitter();
@@ -48179,8 +48447,6 @@ class AlphaSynthWebWorkerApi {
         this._masterVolume = 0.0;
         this._metronomeVolume = 0.0;
         this._playbackSpeed = 0.0;
-        this._tickPosition = 0;
-        this._timePosition = 0.0;
         this._isLooping = false;
         this._playbackRange = null;
         this._output = player;
@@ -48315,9 +48581,8 @@ class AlphaSynthWebWorkerApi {
                 this.checkReadyForPlayback();
                 break;
             case 'alphaSynth.positionChanged':
-                this._timePosition = data.currentTime;
-                this._tickPosition = data.currentTick;
-                this.positionChanged.trigger(new PositionChangedEventArgs(data.currentTime, data.endTime, data.currentTick, data.endTick, data.isSeek, data.originalTempo, data.modifiedTempo));
+                this._currentPosition = new PositionChangedEventArgs(data.currentTime, data.endTime, data.currentTick, data.endTick, data.isSeek, data.originalTempo, data.modifiedTempo);
+                this.positionChanged.trigger(this._currentPosition);
                 break;
             case 'alphaSynth.midiEventsPlayed':
                 this.midiEventsPlayed.trigger(new MidiEventsPlayedEventArgs(data.events.map(JsonConverter.jsObjectToMidiEvent)));
@@ -48341,7 +48606,8 @@ class AlphaSynthWebWorkerApi {
                 break;
             case 'alphaSynth.midiLoaded':
                 this.checkReadyForPlayback();
-                this.midiLoaded.trigger(new PositionChangedEventArgs(data.currentTime, data.endTime, data.currentTick, data.endTick, data.isSeek, data.originalTempo, data.modifiedTempo));
+                this._loadedMidiInfo = new PositionChangedEventArgs(data.currentTime, data.endTime, data.currentTick, data.endTick, data.isSeek, data.originalTempo, data.modifiedTempo);
+                this.midiLoaded.trigger(this._loadedMidiInfo);
                 break;
             case 'alphaSynth.midiLoadFailed':
                 this.checkReadyForPlayback();
@@ -59053,7 +59319,7 @@ class NumberedBeatPreNotesGlyph extends BeatGlyphBase {
                 //  - when the standard notation naturalizes the accidental from the key signature, the numbered notation has the reversed accidental
                 const accidentalMode = note ? note.accidentalMode : NoteAccidentalMode.Default;
                 const noteValue = AccidentalHelper.getNoteValue(note);
-                let accidentalToSet = AccidentalHelper.computeAccidental(this.renderer.bar.keySignature, accidentalMode, noteValue, note.hasQuarterToneOffset);
+                let accidentalToSet = ModelUtils.computeAccidental(this.renderer.bar.keySignature, accidentalMode, noteValue, note.hasQuarterToneOffset);
                 if (accidentalToSet === AccidentalType.Natural) {
                     const ks = this.renderer.bar.keySignature;
                     const ksi = ks + 7;
@@ -59212,7 +59478,7 @@ class NumberedBeatGlyph extends BeatOnNoteGlyphBase {
                         ? AccidentalHelper.FlatNoteSteps
                         : AccidentalHelper.SharpNoteSteps;
                     let steps = stepList[index] + 1;
-                    const hasAccidental = AccidentalHelper.AccidentalNotes[index];
+                    const hasAccidental = ModelUtils.AccidentalNotes[index];
                     if (hasAccidental &&
                         !this.container.preNotes.isNaturalizeAccidental) {
                         if (ksi < 7) {
@@ -66425,6 +66691,30 @@ class AlphaTexExporter extends ScoreExporter {
         if (stylesheet.useSystemSignSeparator) {
             writer.writeMeta('useSystemSignSeparator');
         }
+        if (stylesheet.multiTrackMultiBarRest) {
+            writer.writeMeta('multiBarRest');
+        }
+        if (stylesheet.singleTrackTrackNamePolicy !==
+            AlphaTexExporter.DefaultScore.stylesheet.singleTrackTrackNamePolicy) {
+            writer.writeMeta('singleTrackTrackNamePolicy', TrackNamePolicy[stylesheet.singleTrackTrackNamePolicy]);
+        }
+        if (stylesheet.multiTrackTrackNamePolicy !== AlphaTexExporter.DefaultScore.stylesheet.multiTrackTrackNamePolicy) {
+            writer.writeMeta('multiTrackTrackNamePolicy', TrackNamePolicy[stylesheet.multiTrackTrackNamePolicy]);
+        }
+        if (stylesheet.firstSystemTrackNameMode !== AlphaTexExporter.DefaultScore.stylesheet.firstSystemTrackNameMode) {
+            writer.writeMeta('firstSystemTrackNameMode', TrackNameMode[stylesheet.firstSystemTrackNameMode]);
+        }
+        if (stylesheet.otherSystemsTrackNameMode !== AlphaTexExporter.DefaultScore.stylesheet.otherSystemsTrackNameMode) {
+            writer.writeMeta('otherSystemsTrackNameMode', TrackNameMode[stylesheet.otherSystemsTrackNameMode]);
+        }
+        if (stylesheet.firstSystemTrackNameOrientation !==
+            AlphaTexExporter.DefaultScore.stylesheet.firstSystemTrackNameOrientation) {
+            writer.writeMeta('firstSystemTrackNameOrientation', TrackNameOrientation[stylesheet.firstSystemTrackNameOrientation]);
+        }
+        if (stylesheet.otherSystemsTrackNameOrientation !==
+            AlphaTexExporter.DefaultScore.stylesheet.otherSystemsTrackNameOrientation) {
+            writer.writeMeta('otherSystemsTrackNameOrientation', TrackNameOrientation[stylesheet.otherSystemsTrackNameOrientation]);
+        }
     }
     writeTrackTo(writer, track) {
         writer.write('\\track ');
@@ -66460,6 +66750,10 @@ class AlphaTexExporter extends ScoreExporter {
             track.score.stylesheet.perTrackMultiBarRest.has(track.index)) {
             writer.writeLine(` multibarrest`);
         }
+        writer.writeLine(` instrument ${track.isPercussion ? 'percussion' : GeneralMidi.getName(track.playbackInfo.program)}`);
+        if (track.playbackInfo.bank > 0) {
+            writer.writeLine(` bank ${track.playbackInfo.bank}`);
+        }
         writer.outdent();
         writer.writeLine('}');
         writer.indent();
@@ -66518,13 +66812,7 @@ class AlphaTexExporter extends ScoreExporter {
             writer.writeLine('|');
         }
         if (voiceIndex === 0) {
-            // Track meta on first bar
             let anyWritten = false;
-            if (bar.index === 0 && bar.staff.index === 0) {
-                const l = writer.tex.length;
-                this.writeTrackMetaTo(writer, bar.staff.track);
-                anyWritten = writer.tex.length > l;
-            }
             // Staff meta on first bar
             if (bar.index === 0) {
                 const l = writer.tex.length;
@@ -66554,14 +66842,6 @@ class AlphaTexExporter extends ScoreExporter {
         }
         writer.outdent();
     }
-    writeTrackMetaTo(writer, track) {
-        writer.writeSingleLineComment(`Track ${track.index + 1} Metadata`);
-        this.writePlaybackInfoTo(writer, track);
-    }
-    writePlaybackInfoTo(writer, track) {
-        const isPercussion = track.staves.some(s => s.isPercussion);
-        writer.writeMeta('instrument', isPercussion ? 'percussion' : GeneralMidi.getName(track.playbackInfo.program));
-    }
     writeStaffMetaTo(writer, staff) {
         writer.writeSingleLineComment(`Staff ${staff.index + 1} Metadata`);
         if (staff.capo !== 0) {
@@ -66594,6 +66874,7 @@ class AlphaTexExporter extends ScoreExporter {
         if (staff.displayTranspositionPitch !== defaultTransposition) {
             writer.writeMeta('displaytranspose', `${-staff.displayTranspositionPitch}`);
         }
+        writer.writeMeta('accidentals', 'auto');
         if (staff.chords != null) {
             for (const [_, chord] of staff.chords) {
                 this.writeChordTo(writer, chord);
@@ -66961,6 +67242,18 @@ class AlphaTexExporter extends ScoreExporter {
             writer.writeGroupItem('txt ');
             writer.writeString(beat.text);
         }
+        if (beat.lyrics != null && beat.lyrics.length > 0) {
+            if (beat.lyrics.length > 1) {
+                for (let i = 0; i < beat.lyrics.length; i++) {
+                    writer.writeGroupItem(`lyrics ${i} `);
+                    writer.writeString(beat.lyrics[i]);
+                }
+            }
+            else {
+                writer.writeGroupItem('lyrics ');
+                writer.writeString(beat.lyrics[0]);
+            }
+        }
         switch (beat.graceType) {
             case GraceType.OnBeat:
                 writer.writeGroupItem('gr ob');
@@ -67595,7 +67888,7 @@ class GpifWriter {
             this.writePitch(properties, 'ConcertPitch', 'C', '-1', '');
         }
         else {
-            this.writePitchForValue(properties, 'TransposedPitch', note.displayValueWithoutBend, note.accidentalMode);
+            this.writePitchForValue(properties, 'TransposedPitch', note.displayValueWithoutBend, note.accidentalMode, note.beat.voice.bar.keySignature);
         }
     }
     writeConcertPitch(properties, note) {
@@ -67603,10 +67896,10 @@ class GpifWriter {
             this.writePitch(properties, 'ConcertPitch', 'C', '-1', '');
         }
         else {
-            this.writePitchForValue(properties, 'ConcertPitch', note.realValueWithoutHarmonic, note.accidentalMode);
+            this.writePitchForValue(properties, 'ConcertPitch', note.realValueWithoutHarmonic, note.accidentalMode, note.beat.voice.bar.keySignature);
         }
     }
-    writePitchForValue(properties, propertyName, value, accidentalMode) {
+    writePitchForValue(properties, propertyName, value, accidentalMode, keySignature) {
         let index = 0;
         let octave = 0;
         let step = '';
@@ -67614,8 +67907,25 @@ class GpifWriter {
         const updateParts = () => {
             index = value % 12;
             octave = (value / 12) | 0;
-            step = Tuning.defaultSteps[index];
-            accidental = Tuning.defaultAccidentals[index];
+            step = GpifWriter.defaultSteps[index];
+            switch (ModelUtils.computeAccidental(keySignature, NoteAccidentalMode.Default, value, false)) {
+                case AccidentalType.None:
+                case AccidentalType.Natural:
+                    accidental = '';
+                    break;
+                case AccidentalType.Sharp:
+                    accidental = '#';
+                    break;
+                case AccidentalType.Flat:
+                    accidental = 'b';
+                    break;
+                case AccidentalType.DoubleSharp:
+                    accidental = 'x';
+                    break;
+                case AccidentalType.DoubleFlat:
+                    accidental = 'bb';
+                    break;
+            }
         };
         updateParts();
         switch (accidentalMode) {
@@ -68090,10 +68400,12 @@ class GpifWriter {
                     const value = syncPointAutomation.addElement('Value');
                     value.addElement('BarIndex').innerText = mb.index.toString();
                     value.addElement('BarOccurrence').innerText = syncPoint.syncPointValue.barOccurence.toString();
-                    value.addElement('ModifiedTempo').innerText = modifiedTempoLookup.value.get(syncPoint).syncBpm.toString();
+                    value.addElement('ModifiedTempo').innerText = modifiedTempoLookup.value
+                        .get(syncPoint)
+                        .syncBpm.toString();
                     value.addElement('OriginalTempo').innerText = score.tempo.toString();
-                    let frameOffset = (((syncPoint.syncPointValue.millisecondOffset - millisecondPadding) / 1000) *
-                        GpifWriter.SampleRate);
+                    let frameOffset = ((syncPoint.syncPointValue.millisecondOffset - millisecondPadding) / 1000) *
+                        GpifWriter.SampleRate;
                     frameOffset = Math.floor(frameOffset + 0.5);
                     value.addElement('FrameOffset').innerText = frameOffset.toString();
                 }
@@ -68152,15 +68464,16 @@ class GpifWriter {
         }
         return GpifIconIds.SteelGuitar;
     }
-    writeSoundAndAutomation(soundsNode, automationsNode, name, path, role, barIndex, program, ratioPosition = 0) {
+    writeSoundAndAutomation(soundsNode, automationsNode, name, path, role, barIndex, program, bank, ratioPosition = 0) {
         const soundNode = soundsNode.addElement('Sound');
         soundNode.addElement('Name').setCData(name);
         soundNode.addElement('Label').setCData(name);
         soundNode.addElement('Path').setCData(path);
         soundNode.addElement('Role').setCData(role);
         const midi = soundNode.addElement('MIDI');
-        midi.addElement('LSB').innerText = '0';
-        midi.addElement('MSB').innerText = '0';
+        const lsbMsb = GeneralMidi.bankToLsbMsb(bank);
+        midi.addElement('LSB').innerText = lsbMsb[0].toString();
+        midi.addElement('MSB').innerText = lsbMsb[1].toString();
         midi.addElement('Program').innerText = program.toString();
         const automationNode = automationsNode.addElement('Automation');
         automationNode.addElement('Type').innerText = 'Sound';
@@ -68178,21 +68491,26 @@ class GpifWriter {
             const trackSoundPath = `Midi/${track.playbackInfo.program}`;
             const trackSoundRole = 'Factory';
             let trackSoundWritten = false;
+            let bank = track.playbackInfo.bank;
             for (const staff of track.staves) {
                 for (const bar of staff.bars) {
                     for (const voice of bar.voices) {
                         for (const beat of voice.beats) {
                             const soundAutomation = beat.getAutomation(AutomationType.Instrument);
                             const isTrackSound = bar.index === 0 && beat.index === 0;
+                            const bankAutomation = beat.getAutomation(AutomationType.Bank);
+                            if (bankAutomation) {
+                                bank = bankAutomation.value;
+                            }
                             if (soundAutomation) {
                                 const name = isTrackSound ? trackSoundName : `ProgramChange_${beat.id}`;
                                 const path = isTrackSound ? trackSoundPath : `Midi/${soundAutomation.value}`;
                                 const role = isTrackSound ? trackSoundRole : 'User';
                                 if (!isTrackSound && !trackSoundWritten) {
-                                    this.writeSoundAndAutomation(soundsNode, automationsNode, trackSoundName, trackSoundPath, trackSoundRole, track.staves[0].bars[0].index, track.playbackInfo.program);
+                                    this.writeSoundAndAutomation(soundsNode, automationsNode, trackSoundName, trackSoundPath, trackSoundRole, track.staves[0].bars[0].index, track.playbackInfo.program, track.playbackInfo.bank);
                                     trackSoundWritten = true;
                                 }
-                                this.writeSoundAndAutomation(soundsNode, automationsNode, name, path, role, bar.index, soundAutomation.value, soundAutomation.ratioPosition);
+                                this.writeSoundAndAutomation(soundsNode, automationsNode, name, path, role, bar.index, soundAutomation.value, bank, soundAutomation.ratioPosition);
                                 if (isTrackSound) {
                                     trackSoundWritten = true;
                                 }
@@ -68575,8 +68893,13 @@ class GpifWriter {
     writeMasterBarNode(parent, masterBar) {
         const masterBarNode = parent.addElement('MasterBar');
         const key = masterBarNode.addElement('Key');
-        key.addElement('AccidentalCount').innerText = masterBar.keySignature.toString();
-        key.addElement('Mode').innerText = KeySignatureType[masterBar.keySignatureType];
+        let keySignature = masterBar.score.tracks[0].staves[0].bars[masterBar.index].keySignature;
+        const keySignatureType = masterBar.score.tracks[0].staves[0].bars[masterBar.index].keySignatureType;
+        // reverse transpose
+        const transposeIndex = ModelUtils.flooredDivision(masterBar.score.tracks[0].staves[0].displayTranspositionPitch, 12);
+        keySignature = ModelUtils.transposeKey(keySignature, -transposeIndex);
+        key.addElement('AccidentalCount').innerText = keySignature.toString();
+        key.addElement('Mode').innerText = KeySignatureType[keySignatureType];
         key.addElement('Sharps').innerText = 'Sharps';
         masterBarNode.addElement('Time').innerText =
             `${masterBar.timeSignatureNumerator}/${masterBar.timeSignatureDenominator}`;
@@ -68886,6 +69209,7 @@ GpifWriter.MidiProgramInfoLookup = new Map([
     [127, new GpifMidiProgramInfo(GpifIconIds.Fx, 'Timpani')]
 ]);
 GpifWriter.DrumKitProgramInfo = new GpifMidiProgramInfo(GpifIconIds.PercussionKit, 'Drums', 'drumKit');
+GpifWriter.defaultSteps = ['C', 'C', 'D', 'D', 'E', 'F', 'F', 'G', 'G', 'A', 'A', 'B'];
 
 /**
  * CRC-32 with reversed data and unreversed output
@@ -70764,6 +71088,7 @@ const _barrel$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty(
     SustainPedalMarker,
     get SustainPedalMarkerType () { return SustainPedalMarkerType; },
     SyncPointData,
+    get TechniqueSymbolPlacement () { return TechniqueSymbolPlacement; },
     Track,
     get TrackNameMode () { return TrackNameMode; },
     get TrackNameOrientation () { return TrackNameOrientation; },