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

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.7.0-alpha.1515 (develop, build 1515)
+ * alphaTab v1.7.0-alpha.1517 (develop, build 1517)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -203,9 +203,9 @@
             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.1517';
+    VersionInfo.date = '2025-08-19T02:07:05.813Z';
+    VersionInfo.commit = 'a8c49344e3fef6f72a38d5493a2e58223e2c777b';
 
     /**
      * This public class provides names for all general midi instruments.
@@ -3393,6 +3393,49 @@
         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;
@@ -3898,6 +3941,150 @@
             }
             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 */,
@@ -3950,6 +4137,66 @@
         // 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.
@@ -7952,7 +8199,7 @@
         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()];
         }
         /**
@@ -8091,8 +8338,7 @@
     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();
 
     /**
@@ -9018,8 +9264,7 @@
                         }
                         // 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);
                         }
@@ -9454,10 +9699,10 @@
                 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':
@@ -9474,6 +9719,8 @@
          */
         parseClefFromInt(i) {
             switch (i) {
+                case 0:
+                    return Clef.Neutral;
                 case 43:
                     return Clef.G2;
                 case 65:
@@ -10731,6 +10978,25 @@
                 }
                 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;
             }
@@ -15763,11 +16029,11 @@
                 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;
                 }
             }
@@ -16667,6 +16933,7 @@
             this._backingTrackPadding = 0;
             this._doubleBars = new Set();
             this._keySignatures = new Map();
+            this._transposeKeySignaturePerTrack = new Map();
         }
         parseXml(xml, settings) {
             this._masterTrackAutomations = new Map();
@@ -16897,7 +17164,8 @@
                         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;
                 }
             }
@@ -17133,13 +17401,13 @@
                         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);
@@ -17663,7 +17931,7 @@
                 }
             }
         }
-        parsePartSounding(track, node) {
+        parsePartSounding(trackId, track, node) {
             for (const c of node.childElements()) {
                 switch (c.localName) {
                     case 'TranspositionPitch':
@@ -17671,10 +17939,14 @@
                             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()) {
@@ -17687,9 +17959,14 @@
                         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()) {
@@ -18653,6 +18930,7 @@
             // 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':
@@ -18733,7 +19011,15 @@
                                 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;
@@ -18947,20 +19233,29 @@
                 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);
@@ -18970,6 +19265,12 @@
                         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];
@@ -19036,11 +19337,17 @@
                         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 {
@@ -19128,7 +19435,7 @@
      */
     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;
 
@@ -19823,49 +20130,6 @@
         }
     }
 
-    /**
-     * 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;
@@ -19968,90 +20232,6 @@
             }
             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;
@@ -20065,7 +20245,7 @@
                 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:
@@ -20179,48 +20359,6 @@
             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,
@@ -59059,7 +59197,7 @@
                     //  - 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;
@@ -59218,7 +59356,7 @@
                             ? 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) {
@@ -66431,6 +66569,30 @@
             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 ');
@@ -66600,6 +66762,7 @@
             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);
@@ -66967,6 +67130,18 @@
                 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');
@@ -67601,7 +67776,7 @@
                 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) {
@@ -67609,10 +67784,10 @@
                 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 = '';
@@ -67620,8 +67795,25 @@
             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) {
@@ -68096,10 +68288,12 @@
                         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();
                     }
@@ -68581,8 +68775,13 @@
         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}`;
@@ -68892,6 +69091,7 @@
         [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
@@ -70770,6 +70970,7 @@
         SustainPedalMarker,
         get SustainPedalMarkerType () { return SustainPedalMarkerType; },
         SyncPointData,
+        get TechniqueSymbolPlacement () { return TechniqueSymbolPlacement; },
         Track,
         get TrackNameMode () { return TrackNameMode; },
         get TrackNameOrientation () { return TrackNameOrientation; },