@coderline/alphatab 1.8.0-alpha.1669 → 1.8.0-alpha.1671

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.8.0-alpha.1669 (develop, build 1669)
+ * alphaTab v1.8.0-alpha.1671 (develop, build 1671)
  *
  * Copyright © 2026, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -209,9 +209,9 @@
      * @internal
      */
     class VersionInfo {
-        static version = '1.8.0-alpha.1669';
-        static date = '2026-01-08T02:24:31.439Z';
-        static commit = 'f7c00b0b8db32011293f475bf5e930d21c1903ac';
+        static version = '1.8.0-alpha.1671';
+        static date = '2026-01-10T02:20:48.787Z';
+        static commit = '1edf83d58fe31a924adb1980bc4a529aed07dad4';
         static print(print) {
             print(`alphaTab ${VersionInfo.version}`);
             print(`commit: ${VersionInfo.commit}`);
@@ -1321,6 +1321,23 @@
          * The key signature for numbered notation staff.
          */
         NotationElement[NotationElement["EffectNumberedNotationKeySignature"] = 51] = "EffectNumberedNotationKeySignature";
+        /**
+         * The fretboard numbers shown in chord diagrams.
+         */
+        NotationElement[NotationElement["ChordDiagramFretboardNumbers"] = 52] = "ChordDiagramFretboardNumbers";
+        /**
+         * The bar numbers.
+         */
+        NotationElement[NotationElement["BarNumber"] = 53] = "BarNumber";
+        /**
+         * The repeat count indicator shown above the thick bar line to describe
+         * how many repeats should be played.
+         */
+        NotationElement[NotationElement["RepeatCount"] = 54] = "RepeatCount";
+        /**
+         * The slurs shown on bend effects within the score staff.
+         */
+        NotationElement[NotationElement["ScoreBendSlur"] = 55] = "ScoreBendSlur";
     })(exports.NotationElement || (exports.NotationElement = {}));
     /**
      * The notation settings control how various music notation elements are shown and behaving
@@ -2180,6 +2197,17 @@
          * Gets or sets the type of key signature (major/minor)
          */
         keySignatureType = KeySignatureType.Major;
+        /**
+         * How bar numbers should be displayed.
+         * If specified, overrides the value from the stylesheet on score level.
+         */
+        barNumberDisplay;
+        /**
+         * The shortest duration contained across beats in this bar.
+         * @internal
+         * @json_ignore
+         */
+        shortestDuration = Duration.DoubleWhole;
         /**
          * The bar line to draw on the left side of the bar with an "automatic" type resolved to the actual one.
          * @param isFirstOfSystem  Whether the bar is the first one in the system.
@@ -2251,12 +2279,16 @@
             this._filledVoices.add(0);
             this._isEmpty = true;
             this._isRestOnly = true;
+            this.shortestDuration = Duration.DoubleWhole;
             for (let i = 0, j = this.voices.length; i < j; i++) {
                 const voice = this.voices[i];
                 voice.finish(settings, sharedDataBag);
                 if (!voice.isEmpty) {
                     this._isEmpty = false;
                     this._filledVoices.add(i);
+                    if (voice.shortestDuration > this.shortestDuration) {
+                        this.shortestDuration = voice.shortestDuration;
+                    }
                 }
                 if (!voice.isRestOnly) {
                     this._isRestOnly = false;
@@ -2353,6 +2385,116 @@
         TripletFeel[TripletFeel["Scottish8th"] = 6] = "Scottish8th";
     })(TripletFeel || (TripletFeel = {}));
 
+    /**
+     * Defines the custom beaming rules which define how beats are beamed together or split apart
+     * during the automatic beaming when displayed.
+     * @json
+     * @json_strict
+     * @public
+     *
+     * @remarks
+     * The beaming logic works like this:
+     *
+     * The time axis of the bar is sliced into even chunks. The chunk-size is defined by the respective group definition.
+     * Within these chunks groups can then be placed spanning 1 or more chunks.
+     *
+     * If beats start within the same "group" they are beamed together.
+     */
+    class BeamingRules {
+        _singleGroupKey;
+        /**
+         * The the group for a given "longest duration" within the bar.
+         * @remarks
+         * The map key is the duration to which the bar will be sliced into.
+         * The map value defines the "groups" placed within the sliced.
+         */
+        groups = new Map();
+        /**
+         * @internal
+         * @json_ignore
+         */
+        uniqueId = '';
+        /**
+         * @internal
+         * @json_ignore
+         */
+        timeSignatureNumerator = 0;
+        /**
+         * @internal
+         * @json_ignore
+         */
+        timeSignatureDenominator = 0;
+        /**
+         * @internal
+         */
+        static createSimple(timeSignatureNumerator, timeSignatureDenominator, duration, groups) {
+            const r = new BeamingRules();
+            r.timeSignatureNumerator = timeSignatureNumerator;
+            r.timeSignatureDenominator = timeSignatureDenominator;
+            r.groups.set(duration, groups);
+            r.finish();
+            return r;
+        }
+        /**
+         * @internal
+         */
+        findRule(shortestDuration) {
+            // fast path: one rule -> take it
+            const singleGroupKey = this._singleGroupKey;
+            if (singleGroupKey) {
+                return [singleGroupKey, this.groups.get(singleGroupKey)];
+            }
+            if (shortestDuration < Duration.Quarter) {
+                return [shortestDuration, []];
+            }
+            // first search shorter
+            let durationValue = shortestDuration;
+            do {
+                const duration = durationValue;
+                if (this.groups.has(duration)) {
+                    return [duration, this.groups.get(duration)];
+                }
+                durationValue = durationValue * 2;
+            } while (durationValue <= Duration.TwoHundredFiftySixth);
+            // then longer
+            durationValue = shortestDuration / 2;
+            do {
+                const duration = durationValue;
+                if (this.groups.has(duration)) {
+                    return [duration, this.groups.get(duration)];
+                }
+                durationValue = durationValue / 2;
+            } while (durationValue > Duration.Half);
+            return [shortestDuration, []];
+        }
+        /**
+         * @internal
+         */
+        finish() {
+            let uniqueId = `${this.timeSignatureNumerator}_${this.timeSignatureDenominator}`;
+            for (const [k, v] of this.groups) {
+                uniqueId += `__${k}`;
+                // trim of 0s at the end of the group
+                let lastZero = v.length;
+                for (let i = v.length - 1; i >= 0; i--) {
+                    if (v[i] === 0) {
+                        lastZero = i;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (lastZero < v.length) {
+                    v.splice(lastZero, v.length - lastZero);
+                }
+                uniqueId += `_${v.join('_')}`;
+                if (this.groups.size === 1) {
+                    this._singleGroupKey = k;
+                }
+            }
+            this.uniqueId = uniqueId;
+        }
+    }
     /**
      * The MasterBar stores information about a bar which affects
      * all tracks.
@@ -2470,6 +2612,16 @@
          * Gets or sets whether this is bar has a common time signature.
          */
         timeSignatureCommon = false;
+        /**
+         * Defines the custom beaming rules which should be applied to this bar and all bars following.
+         */
+        beamingRules;
+        /**
+         * The actual (custom) beaming rules to use for this bar if any were specified.
+         * @json_ignore
+         * @internal
+         */
+        actualBeamingRules;
         /**
          * Gets or sets whether the bar indicates a free time playing.
          */
@@ -2602,6 +2754,32 @@
             }
             this.syncPoints.push(syncPoint);
         }
+        finish(sharedDataBag) {
+            let beamingRules = this.beamingRules;
+            if (beamingRules) {
+                beamingRules.timeSignatureNumerator = this.timeSignatureNumerator;
+                beamingRules.timeSignatureDenominator = this.timeSignatureDenominator;
+                beamingRules.finish();
+            }
+            if (this.index > 0) {
+                this.start = this.previousMasterBar.start + this.previousMasterBar.calculateDuration();
+                // clear out equal rules to reduce memory consumption.
+                const previousRules = sharedDataBag.has('beamingRules')
+                    ? sharedDataBag.get('beamingRules')
+                    : undefined;
+                if (previousRules && previousRules.uniqueId === beamingRules?.uniqueId) {
+                    this.beamingRules = undefined;
+                    beamingRules = previousRules;
+                }
+                else if (!beamingRules) {
+                    beamingRules = previousRules;
+                }
+            }
+            this.actualBeamingRules = beamingRules;
+            if (this.beamingRules) {
+                sharedDataBag.set('beamingRules', beamingRules);
+            }
+        }
     }
 
     /**
@@ -2674,6 +2852,25 @@
          */
         TrackNameOrientation[TrackNameOrientation["Vertical"] = 1] = "Vertical";
     })(TrackNameOrientation || (TrackNameOrientation = {}));
+    /**
+     * How bar numbers are displayed
+     * @public
+     */
+    var BarNumberDisplay;
+    (function (BarNumberDisplay) {
+        /**
+         * Show bar numbers on all bars.
+         */
+        BarNumberDisplay[BarNumberDisplay["AllBars"] = 0] = "AllBars";
+        /**
+         * Show bar numbers on the first bar of every system.
+         */
+        BarNumberDisplay[BarNumberDisplay["FirstOfSystem"] = 1] = "FirstOfSystem";
+        /**
+         * Hide all bar numbers
+         */
+        BarNumberDisplay[BarNumberDisplay["Hide"] = 2] = "Hide";
+    })(BarNumberDisplay || (BarNumberDisplay = {}));
     /**
      * This class represents the rendering stylesheet.
      * It contains settings which control the display of the score when rendered.
@@ -2767,6 +2964,10 @@
          * {@link hideEmptyStaves}
          */
         showSingleStaffBrackets = false;
+        /**
+         * How bar numbers should be displayed.
+         */
+        barNumberDisplay = BarNumberDisplay.AllBars;
     }
 
     /**
@@ -2929,6 +3130,12 @@
         get isRestOnly() {
             return this._isRestOnly;
         }
+        /**
+         * The shortest duration contained across beats in this bar.
+         * @internal
+         * @json_ignore
+         */
+        shortestDuration = Duration.DoubleWhole;
         insertBeat(after, newBeat) {
             newBeat.nextBeat = after.nextBeat;
             if (newBeat.nextBeat) {
@@ -3022,6 +3229,7 @@
             }
             let currentDisplayTick = 0;
             let currentPlaybackTick = 0;
+            this.shortestDuration = Duration.DoubleWhole;
             for (let i = 0; i < this.beats.length; i++) {
                 const beat = this.beats[i];
                 beat.index = i;
@@ -3030,6 +3238,9 @@
                 // we need to first steal the duration from the right beat
                 // and place the grace beats correctly
                 if (beat.graceType === GraceType.None) {
+                    if (beat.duration > this.shortestDuration) {
+                        this.shortestDuration = beat.duration;
+                    }
                     if (beat.graceGroup) {
                         const firstGraceBeat = beat.graceGroup.beats[0];
                         const lastGraceBeat = beat.graceGroup.beats[beat.graceGroup.beats.length - 1];
@@ -3490,7 +3701,7 @@
                 bar.previousMasterBar.nextMasterBar = bar;
                 // NOTE: this will not work on anacrusis. Correct anacrusis durations are only working
                 // when there are beats with playback positions already computed which requires full finish
-                // chicken-egg problem here. temporarily forcing anacrusis length here to 0, 
+                // chicken-egg problem here. temporarily forcing anacrusis length here to 0,
                 // .finish() will correct these times
                 bar.start =
                     bar.previousMasterBar.start +
@@ -3554,9 +3765,7 @@
             }
             // fixup masterbar starts to handle anacrusis lengths
             for (const mb of this.masterBars) {
-                if (mb.index > 0) {
-                    mb.start = mb.previousMasterBar.start + mb.previousMasterBar.calculateDuration();
-                }
+                mb.finish(sharedDataBag);
             }
         }
         /**
@@ -8438,6 +8647,12 @@
             ['buzzroll', 1]
         ]);
         static tremoloPickingStyleReversed = AlphaTex1EnumMappings._reverse(AlphaTex1EnumMappings.tremoloPickingStyle);
+        static barNumberDisplay = new Map([
+            ['allbars', 0],
+            ['firstofsystem', 1],
+            ['hide', 2]
+        ]);
+        static barNumberDisplayReversed = AlphaTex1EnumMappings._reverse(AlphaTex1EnumMappings.barNumberDisplay);
         static keySignaturesMinorReversed = new Map([
             [-7, 'abminor'],
             [-6, 'ebminor'],
@@ -8632,7 +8847,8 @@
             ['chorddiagramsinscore', [[[[10], 1, ['true', 'false']]]]],
             ['hideemptystaves', null],
             ['hideemptystavesinfirstsystem', null],
-            ['showsinglestaffbrackets', null]
+            ['showsinglestaffbrackets', null],
+            ['defaultbarnumberdisplay', [[[[10, 17], 0, ['allbars', 'firstofsystem', 'hide']]]]]
         ]);
         static staffMetaDataSignatures = AlphaTex1LanguageDefinitions._signatures([
             ['tuning', [[[[10, 17], 0, ['piano', 'none', 'voice']]], [[[10, 17], 5]]]],
@@ -8917,7 +9133,17 @@
             ['sph', [[[[16], 2]]]],
             ['spu', [[[[16], 2]]]],
             ['db', null],
-            ['voicemode', [[[[10, 17], 0, ['staffwise', 'barwise']]]]]
+            ['voicemode', [[[[10, 17], 0, ['staffwise', 'barwise']]]]],
+            ['barnumberdisplay', [[[[10, 17], 0, ['allbars', 'firstofsystem', 'hide']]]]],
+            [
+                'beaming',
+                [
+                    [
+                        [[16], 0],
+                        [[16], 5]
+                    ]
+                ]
+            ]
         ]);
         static metaDataProperties = AlphaTex1LanguageDefinitions._metaProps([
             [
@@ -8975,6 +9201,7 @@
             ['hideemptystaves', null],
             ['hideemptystavesinfirstsystem', null],
             ['showsinglestaffbrackets', null],
+            ['defaultbarnumberdisplay', null],
             [
                 'tuning',
                 [
@@ -9031,7 +9258,9 @@
             ['sph', null],
             ['spu', null],
             ['db', null],
-            ['voicemode', null]
+            ['voicemode', null],
+            ['barnumberdisplay', null],
+            ['beaming', null]
         ]);
         static metaDataSignatures = [
             AlphaTex1LanguageDefinitions.scoreMetaDataSignatures,
@@ -12746,6 +12975,7 @@
      */
     class AlphaTex1LanguageHandler {
         static instance = new AlphaTex1LanguageHandler();
+        static _timeSignatureDenominators = new Set([1, 2, 4, 8, 16, 32, 64, 128]);
         applyScoreMetaData(importer, score, metaData) {
             const result = this._checkArgumentTypes(importer, [AlphaTex1LanguageDefinitions.scoreMetaDataSignatures], metaData, metaData.tag.tag.text.toLowerCase(), metaData.arguments);
             if (result !== undefined) {
@@ -12882,6 +13112,13 @@
                 case 'showsinglestaffbrackets':
                     score.stylesheet.showSingleStaffBrackets = true;
                     return ApplyNodeResult.Applied;
+                case 'defaultbarnumberdisplay':
+                    const barNumberDisplay = AlphaTex1LanguageHandler._parseEnumValue(importer, metaData.arguments, 'bar number display', AlphaTex1EnumMappings.barNumberDisplay);
+                    if (barNumberDisplay === undefined) {
+                        return ApplyNodeResult.NotAppliedSemanticError;
+                    }
+                    score.stylesheet.barNumberDisplay = barNumberDisplay;
+                    return ApplyNodeResult.Applied;
                 default:
                     return ApplyNodeResult.NotAppliedUnrecognizedMarker;
             }
@@ -13160,8 +13397,29 @@
                 case 'ts':
                     switch (metaData.arguments.arguments[0].nodeType) {
                         case AlphaTexNodeType.Number:
-                            bar.masterBar.timeSignatureNumerator = metaData.arguments.arguments[0].value;
-                            bar.masterBar.timeSignatureDenominator = metaData.arguments.arguments[1].value;
+                            bar.masterBar.timeSignatureNumerator =
+                                metaData.arguments.arguments[0].value | 0;
+                            if (bar.masterBar.timeSignatureNumerator < 1 || bar.masterBar.timeSignatureNumerator > 32) {
+                                importer.addSemanticDiagnostic({
+                                    code: AlphaTexDiagnosticCode.AT211,
+                                    message: `Value is out of valid range. Allowed range: 1-32, Actual Value: ${bar.masterBar.timeSignatureNumerator}`,
+                                    start: metaData.arguments.arguments[0].start,
+                                    end: metaData.arguments.arguments[0].end,
+                                    severity: AlphaTexDiagnosticsSeverity.Error
+                                });
+                            }
+                            bar.masterBar.timeSignatureDenominator =
+                                metaData.arguments.arguments[1].value | 0;
+                            if (!AlphaTex1LanguageHandler._timeSignatureDenominators.has(bar.masterBar.timeSignatureDenominator)) {
+                                const valueList = Array.from(AlphaTex1LanguageHandler._timeSignatureDenominators).join(', ');
+                                importer.addSemanticDiagnostic({
+                                    code: AlphaTexDiagnosticCode.AT211,
+                                    message: `Value is out of valid range. Allowed range: ${valueList}, Actual Value: ${bar.masterBar.timeSignatureDenominator}`,
+                                    start: metaData.arguments.arguments[0].start,
+                                    end: metaData.arguments.arguments[0].end,
+                                    severity: AlphaTexDiagnosticsSeverity.Error
+                                });
+                            }
                             break;
                         case AlphaTexNodeType.Ident:
                         case AlphaTexNodeType.String:
@@ -13184,6 +13442,8 @@
                             break;
                     }
                     return ApplyNodeResult.Applied;
+                case 'beaming':
+                    return this._parseBeamingRule(importer, metaData, bar.masterBar);
                 case 'ks':
                     const keySignature = AlphaTex1LanguageHandler._parseEnumValue(importer, metaData.arguments, 'key signature', AlphaTex1EnumMappings.keySignature);
                     if (keySignature === undefined) {
@@ -13373,10 +13633,64 @@
                     bar.masterBar.isDoubleBar = true;
                     bar.barLineRight = BarLineStyle.LightLight;
                     return ApplyNodeResult.Applied;
+                case 'barnumberdisplay':
+                    const barNumberDisplay = AlphaTex1LanguageHandler._parseEnumValue(importer, metaData.arguments, 'bar number display', AlphaTex1EnumMappings.barNumberDisplay);
+                    if (barNumberDisplay === undefined) {
+                        return ApplyNodeResult.NotAppliedSemanticError;
+                    }
+                    bar.barNumberDisplay = barNumberDisplay;
+                    return ApplyNodeResult.Applied;
                 default:
                     return ApplyNodeResult.NotAppliedUnrecognizedMarker;
             }
         }
+        _parseBeamingRule(importer, metaData, masterBar) {
+            let duration = Duration.Eighth;
+            const groupSizes = [];
+            const durationValue = metaData.arguments.arguments[0].value;
+            switch (durationValue) {
+                case 4:
+                    duration = Duration.QuadrupleWhole;
+                    break;
+                case 8:
+                    duration = Duration.Eighth;
+                    break;
+                case 16:
+                    duration = Duration.Sixteenth;
+                    break;
+                case 32:
+                    duration = Duration.ThirtySecond;
+                    break;
+                default:
+                    importer.addSemanticDiagnostic({
+                        code: AlphaTexDiagnosticCode.AT209,
+                        message: `Value is out of valid range. Allowed range: 4,8,16 or 32, Actual Value: ${durationValue}`,
+                        severity: AlphaTexDiagnosticsSeverity.Error,
+                        start: metaData.arguments.arguments[0].start,
+                        end: metaData.arguments.arguments[0].end
+                    });
+                    return ApplyNodeResult.NotAppliedSemanticError;
+            }
+            for (let i = 1; i < metaData.arguments.arguments.length; i++) {
+                const groupSize = metaData.arguments.arguments[i].value;
+                if (groupSize < 1) {
+                    importer.addSemanticDiagnostic({
+                        code: AlphaTexDiagnosticCode.AT209,
+                        message: `Value is out of valid range. Allowed range: >0, Actual Value: ${durationValue}`,
+                        severity: AlphaTexDiagnosticsSeverity.Error,
+                        start: metaData.arguments.arguments[i].start,
+                        end: metaData.arguments.arguments[i].end
+                    });
+                    return ApplyNodeResult.NotAppliedSemanticError;
+                }
+                groupSizes.push(metaData.arguments.arguments[i].value);
+            }
+            if (!masterBar.beamingRules) {
+                masterBar.beamingRules = new BeamingRules();
+            }
+            masterBar.beamingRules.groups.set(duration, groupSizes);
+            return ApplyNodeResult.Applied;
+        }
         static _handleAccidentalMode(importer, args) {
             const accidentalMode = AlphaTex1LanguageHandler._parseEnumValue(importer, args, 'accidental mode', AlphaTex1EnumMappings.alphaTexAccidentalMode);
             if (accidentalMode === undefined) {
@@ -14740,6 +15054,9 @@
             if (stylesheet.showSingleStaffBrackets) {
                 nodes.push(Atnf.meta('showSingleStaffBrackets'));
             }
+            if (stylesheet.barNumberDisplay !== BarNumberDisplay.AllBars) {
+                nodes.push(Atnf.identMeta('defaultBarNumberDisplay', BarNumberDisplay[stylesheet.barNumberDisplay]));
+            }
             // Unsupported:
             // 'globaldisplaychorddiagramsontop',
             // 'pertrackchorddiagramsontop',
@@ -14873,6 +15190,9 @@
                     }
                 ];
             }
+            if (bar.barNumberDisplay !== undefined) {
+                nodes.push(Atnf.identMeta('barNumberDisplay', BarNumberDisplay[bar.barNumberDisplay]));
+            }
             return nodes;
         }
         static _buildStaffMetaDataNodes(nodes, staff) {
@@ -14963,6 +15283,15 @@
                     ])));
                 }
             }
+            if (masterBar.beamingRules) {
+                for (const [k, v] of masterBar.beamingRules.groups) {
+                    const args = Atnf.args([Atnf.number(k)], true);
+                    for (const i of v) {
+                        args.arguments.push(Atnf.number(i));
+                    }
+                    nodes.push(Atnf.meta('beaming', args));
+                }
+            }
             if ((masterBar.index > 0 && masterBar.tripletFeel !== masterBar.previousMasterBar?.tripletFeel) ||
                 (masterBar.index === 0 && masterBar.tripletFeel !== TripletFeel.NoTripletFeel)) {
                 nodes.push(Atnf.identMeta('tf', AlphaTex1EnumMappings.tripletFeelReversed.get(masterBar.tripletFeel)));
@@ -19541,6 +19870,10 @@
                 this.readTrack();
             }
         }
+        /**
+         * Guitar Pro 3-6 changes to a bass clef if any string tuning is below B2;
+         */
+        static _bassClefTuningThreshold = ModelUtils.parseTuning('B2').realValue;
         readTrack() {
             const newTrack = new Track();
             newTrack.ensureStaveCount(1);
@@ -19621,11 +19954,11 @@
                 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);
+                if (clefMode === 12 || tuning[tuning.length - 1] < Gp3To5Importer._bassClefTuningThreshold) {
+                    this._clefsPerTrack.set(newTrack.index, Clef.F4);
                 }
                 else {
-                    this._clefsPerTrack.set(index, Clef.G2);
+                    this._clefsPerTrack.set(newTrack.index, Clef.G2);
                 }
                 // Unknown, no UI setting seem to affect this
                 IOHelper.readInt32LE(this.data);
@@ -19657,11 +19990,11 @@
                 }
             }
             else {
-                if (GeneralMidi.isBass(newTrack.playbackInfo.program)) {
-                    this._clefsPerTrack.set(index, Clef.F4);
+                if (tuning[tuning.length - 1] < Gp3To5Importer._bassClefTuningThreshold) {
+                    this._clefsPerTrack.set(newTrack.index, Clef.F4);
                 }
                 else {
-                    this._clefsPerTrack.set(index, Clef.G2);
+                    this._clefsPerTrack.set(newTrack.index, Clef.G2);
                 }
             }
         }
@@ -20935,6 +21268,19 @@
                         ModelUtils.getOrCreateHeaderFooterStyle(score, ScoreSubElement.CopyrightSecondLine).isVisible =
                             value;
                         break;
+                    case 'System/barIndexDrawType':
+                        switch (value) {
+                            case 0:
+                                score.stylesheet.barNumberDisplay = BarNumberDisplay.AllBars;
+                                break;
+                            case 1:
+                                score.stylesheet.barNumberDisplay = BarNumberDisplay.FirstOfSystem;
+                                break;
+                            case 2:
+                                score.stylesheet.barNumberDisplay = BarNumberDisplay.Hide;
+                                break;
+                        }
+                        break;
                 }
             }
         }
@@ -21124,6 +21470,17 @@
                     }
                 }
             }
+            switch (score.stylesheet.barNumberDisplay) {
+                case BarNumberDisplay.AllBars:
+                    binaryStylesheet.addValue('System/barIndexDrawType', 0, DataType.Integer);
+                    break;
+                case BarNumberDisplay.FirstOfSystem:
+                    binaryStylesheet.addValue('System/barIndexDrawType', 1, DataType.Integer);
+                    break;
+                case BarNumberDisplay.Hide:
+                    binaryStylesheet.addValue('System/barIndexDrawType', 2, DataType.Integer);
+                    break;
+            }
             const writer = ByteBuffer.withCapacity(128);
             binaryStylesheet.writeTo(writer);
             return writer.toArray();
@@ -22935,6 +23292,8 @@
             }
         }
         _parseMasterBarXProperties(masterBar, node) {
+            let beamingRuleDuration = Number.NaN;
+            let beamingRuleGroups = undefined;
             for (const c of node.childElements()) {
                 switch (c.localName) {
                     case 'XProperty':
@@ -22943,10 +23302,32 @@
                             case '1124073984':
                                 masterBar.displayScale = GpifParser._parseFloatSafe(c.findChildElement('Double')?.innerText, 1);
                                 break;
+                            case '1124139010':
+                                beamingRuleDuration = GpifParser._parseIntSafe(c.findChildElement('Int')?.innerText, Number.NaN);
+                                break;
+                            default:
+                                const idNumeric = GpifParser._parseIntSafe(id, 0);
+                                if (idNumeric >= 1124139264 && idNumeric <= 1124139295) {
+                                    const groupIndex = idNumeric - 1124139264;
+                                    const groupSize = GpifParser._parseIntSafe(c.findChildElement('Int')?.innerText, Number.NaN);
+                                    if (beamingRuleGroups === undefined) {
+                                        beamingRuleGroups = [];
+                                    }
+                                    while (beamingRuleGroups.length < groupIndex + 1) {
+                                        beamingRuleGroups.push(0);
+                                    }
+                                    beamingRuleGroups[groupIndex] = groupSize;
+                                }
+                                break;
                         }
                         break;
                 }
             }
+            if (!Number.isNaN(beamingRuleDuration) && beamingRuleGroups) {
+                const rules = new BeamingRules();
+                rules.groups.set(beamingRuleDuration, beamingRuleGroups);
+                masterBar.beamingRules = rules;
+            }
         }
         _parseBeatProperties(node, beat) {
             let isWhammy = false;
@@ -24830,6 +25211,8 @@
         _idToTrackInfo = new Map();
         _indexToTrackInfo = new Map();
         _staffToContext = new Map();
+        _currentBarNumberDisplayPart;
+        _currentBarNumberDisplayBar;
         _divisionsPerQuarterNote = 1;
         _currentDynamics = DynamicValue.F;
         get name() {
@@ -25443,20 +25826,29 @@
                         break;
                 }
             }
+            this._currentBarNumberDisplayPart = undefined;
         }
         _parsePartwiseMeasure(element, track, index) {
             const masterBar = this._getOrCreateMasterBar(element, index);
-            this._parsePartMeasure(element, masterBar, track);
+            const implicit = element.attributes.get('implicit') === 'yes';
+            this._parsePartMeasure(element, masterBar, track, implicit, true);
+            this._currentBarNumberDisplayBar = undefined;
         }
         _parseTimewiseMeasure(element, index) {
             const masterBar = this._getOrCreateMasterBar(element, index);
+            const implicit = element.attributes.get('implicit') === 'yes';
             for (const c of element.childElements()) {
                 switch (c.localName) {
                     case 'part':
-                        this._parseTimewisePart(c, masterBar);
+                        this._parseTimewisePart(c, masterBar, implicit);
+                        this._currentBarNumberDisplayPart = undefined;
+                        break;
+                    case 'print':
+                        this._parsePrint(c, masterBar, undefined, true);
                         break;
                 }
             }
+            this._currentBarNumberDisplayBar = undefined;
         }
         _getOrCreateMasterBar(element, index) {
             const implicit = element.attributes.get('implicit') === 'yes';
@@ -25475,13 +25867,13 @@
             const masterBar = this._score.masterBars[index];
             return masterBar;
         }
-        _parseTimewisePart(element, masterBar) {
+        _parseTimewisePart(element, masterBar, implicit) {
             const id = element.attributes.get('id');
             if (!id || !this._idToTrackInfo.has(id)) {
                 return;
             }
             const track = this._idToTrackInfo.get(id).track;
-            this._parsePartMeasure(element, masterBar, track);
+            this._parsePartMeasure(element, masterBar, track, implicit, false);
         }
         // current measure state
         /**
@@ -25493,7 +25885,7 @@
          * to access the current voice/staff (e.g. on rests when we don't have notes)
          */
         _lastBeat = null;
-        _parsePartMeasure(element, masterBar, track) {
+        _parsePartMeasure(element, masterBar, track, implicit, isPartwise) {
             this._musicalPosition = 0;
             this._lastBeat = null;
             masterBar.alternateEndings = this._nextMasterBarRepeatEnding;
@@ -25520,7 +25912,7 @@
                         break;
                     // case 'figured-bass': Not supported
                     case 'print':
-                        this._parsePrint(c, masterBar, track);
+                        this._parsePrint(c, masterBar, track, true);
                         break;
                     case 'sound':
                         this._parseSound(c, masterBar, track);
@@ -25541,16 +25933,51 @@
             this._applySimileMarks(masterBar, track);
             // initial empty staff and voice (if no other elements created something already)
             const staff = this._getOrCreateStaff(track, 0);
-            this._getOrCreateBar(staff, masterBar);
+            const bar = this._getOrCreateBar(staff, masterBar);
+            if (implicit) {
+                bar.barNumberDisplay = BarNumberDisplay.Hide;
+            }
+            else if (isPartwise) {
+                bar.barNumberDisplay = this._currentBarNumberDisplayBar ?? this._currentBarNumberDisplayPart;
+            }
+            else {
+                bar.barNumberDisplay = this._currentBarNumberDisplayPart ?? this._currentBarNumberDisplayBar;
+            }
             // clear measure attribute
             this._keyAllStaves = null;
         }
-        _parsePrint(element, masterBar, track) {
-            if (element.getAttribute('new-system', 'no') === 'yes') {
-                track.addLineBreaks(masterBar.index);
+        _parsePrint(element, masterBar, track, isMeasurePrint) {
+            if (track !== undefined) {
+                if (element.getAttribute('new-system', 'no') === 'yes') {
+                    track.addLineBreaks(masterBar.index);
+                }
+                else if (element.getAttribute('new-page', 'no') === 'yes') {
+                    track.addLineBreaks(masterBar.index);
+                }
             }
-            else if (element.getAttribute('new-page', 'no') === 'yes') {
-                track.addLineBreaks(masterBar.index);
+            let newDisplay = undefined;
+            for (const c of element.childElements()) {
+                switch (c.localName) {
+                    case 'measure-numbering':
+                        switch (c.innerText) {
+                            case 'none':
+                                newDisplay = BarNumberDisplay.Hide;
+                                break;
+                            case 'measure':
+                                newDisplay = BarNumberDisplay.AllBars;
+                                break;
+                            case 'system':
+                                newDisplay = BarNumberDisplay.FirstOfSystem;
+                                break;
+                        }
+                        break;
+                }
+            }
+            if (isMeasurePrint) {
+                this._currentBarNumberDisplayBar = newDisplay;
+            }
+            else {
+                this._currentBarNumberDisplayPart = newDisplay;
             }
         }
         _applySimileMarks(masterBar, track) {
@@ -26660,7 +27087,7 @@
             if (unit !== null && perMinute > 0) {
                 const tempoAutomation = new Automation();
                 tempoAutomation.type = AutomationType.Tempo;
-                tempoAutomation.value = (perMinute * (unit / 4)) | 0;
+                tempoAutomation.value = perMinute * (unit / 4);
                 tempoAutomation.ratioPosition = ratioPosition;
                 if (!this._hasSameTempo(masterBar, tempoAutomation)) {
                     masterBar.tempoAutomations.push(tempoAutomation);
@@ -29589,7 +30016,7 @@
                 }
                 if (mEvent.type === MidiEventType.TempoChange) {
                     const meta = mEvent;
-                    bpm = meta.beatsPerMinute;
+                    bpm = MidiFileSequencer._sanitizeBpm(meta.beatsPerMinute);
                     state.tempoChanges.push(new MidiFileSequencerTempoChange(bpm, absTick, absTime));
                     metronomeLengthInMillis = metronomeLengthInTicks * (60000.0 / (bpm * midiFile.division));
                 }
@@ -29707,7 +30134,7 @@
                     }
                     else {
                         const previousSyncPoint = syncPoints[i - 1];
-                        previousModifiedTempo = previousSyncPoint.syncBpm;
+                        previousModifiedTempo = MidiFileSequencer._sanitizeBpm(previousSyncPoint.syncBpm);
                         previousMillisecondOffset = previousSyncPoint.syncTime;
                         previousTick = previousSyncPoint.synthTick;
                     }
@@ -29731,7 +30158,7 @@
                             syncPoint.syncTime = interpolatedMillisecondOffset;
                             syncPoint.syncBpm = previousModifiedTempo;
                         }
-                        bpm = state.tempoChanges[tempoChangeIndex].bpm;
+                        bpm = MidiFileSequencer._sanitizeBpm(state.tempoChanges[tempoChangeIndex].bpm);
                         tempoChangeIndex++;
                     }
                     deltaTick = p.synthTick - absTick;
@@ -29752,10 +30179,13 @@
             this._updateCurrentTempo(state, timePosition);
             const lastTempoChange = state.tempoChanges[state.tempoChangeIndex];
             const timeDiff = timePosition - lastTempoChange.time;
-            const ticks = (timeDiff / (60000.0 / (lastTempoChange.bpm * state.division))) | 0;
+            const ticks = (timeDiff / (60000.0 / (MidiFileSequencer._sanitizeBpm(lastTempoChange.bpm) * state.division))) | 0;
             // we add 1 for possible rounding errors.(floating point issuses)
             return lastTempoChange.ticks + ticks + 1;
         }
+        static _sanitizeBpm(bpm) {
+            return Math.max(bpm, 1); // prevent <0 bpms. Doesn't make sense and can cause endless loops
+        }
         currentUpdateCurrentTempo(timePosition) {
             this._updateCurrentTempo(this._mainState, timePosition * this.playbackSpeed);
         }
@@ -36433,6 +36863,43 @@
         }
     }
 
+    /**
+     * @internal
+     */
+    class BeamingRulesSerializer {
+        static fromJson(obj, m) {
+            if (!m) {
+                return;
+            }
+            JsonHelper.forEach(m, (v, k) => BeamingRulesSerializer.setProperty(obj, k, v));
+        }
+        static toJson(obj) {
+            if (!obj) {
+                return null;
+            }
+            const o = new Map();
+            {
+                const m = new Map();
+                o.set("groups", m);
+                for (const [k, v] of obj.groups) {
+                    m.set(k.toString(), v);
+                }
+            }
+            return o;
+        }
+        static setProperty(obj, property, v) {
+            switch (property) {
+                case "groups":
+                    obj.groups = new Map();
+                    JsonHelper.forEach(v, (v, k) => {
+                        obj.groups.set(JsonHelper.parseEnum(k, Duration), v);
+                    });
+                    return true;
+            }
+            return false;
+        }
+    }
+
     /**
      * @internal
      */
@@ -36611,6 +37078,9 @@
             o.set("timesignaturenumerator", obj.timeSignatureNumerator);
             o.set("timesignaturedenominator", obj.timeSignatureDenominator);
             o.set("timesignaturecommon", obj.timeSignatureCommon);
+            if (obj.beamingRules) {
+                o.set("beamingrules", BeamingRulesSerializer.toJson(obj.beamingRules));
+            }
             o.set("isfreetime", obj.isFreeTime);
             o.set("tripletfeel", obj.tripletFeel);
             if (obj.section) {
@@ -36663,6 +37133,15 @@
                 case "timesignaturecommon":
                     obj.timeSignatureCommon = v;
                     return true;
+                case "beamingrules":
+                    if (v) {
+                        obj.beamingRules = new BeamingRules();
+                        BeamingRulesSerializer.fromJson(obj.beamingRules, v);
+                    }
+                    else {
+                        obj.beamingRules = undefined;
+                    }
+                    return true;
                 case "isfreetime":
                     obj.isFreeTime = v;
                     return true;
@@ -37487,6 +37966,7 @@
             o.set("barlineright", obj.barLineRight);
             o.set("keysignature", obj.keySignature);
             o.set("keysignaturetype", obj.keySignatureType);
+            o.set("barnumberdisplay", obj.barNumberDisplay);
             if (obj.style) {
                 o.set("style", BarStyleSerializer.toJson(obj.style));
             }
@@ -37540,6 +38020,9 @@
                 case "keysignaturetype":
                     obj.keySignatureType = JsonHelper.parseEnum(v, KeySignatureType);
                     return true;
+                case "barnumberdisplay":
+                    obj.barNumberDisplay = JsonHelper.parseEnum(v, BarNumberDisplay);
+                    return true;
                 case "style":
                     if (v) {
                         obj.style = new BarStyle();
@@ -38034,6 +38517,7 @@
             o.set("hideemptystaves", obj.hideEmptyStaves);
             o.set("hideemptystavesinfirstsystem", obj.hideEmptyStavesInFirstSystem);
             o.set("showsinglestaffbrackets", obj.showSingleStaffBrackets);
+            o.set("barnumberdisplay", obj.barNumberDisplay);
             return o;
         }
         static setProperty(obj, property, v) {
@@ -38104,6 +38588,9 @@
                 case "showsinglestaffbrackets":
                     obj.showSingleStaffBrackets = v;
                     return true;
+                case "barnumberdisplay":
+                    obj.barNumberDisplay = JsonHelper.parseEnum(v, BarNumberDisplay);
+                    return true;
             }
             return false;
         }
@@ -41835,25 +42322,20 @@
             const o = new Map();
             o.set("smuflfontfamilyname", obj.smuflFontFamilyName);
             o.set("engravingsettings", EngravingSettingsSerializer.toJson(obj.engravingSettings));
-            o.set("copyrightfont", Font.toJson(obj.copyrightFont));
-            o.set("titlefont", Font.toJson(obj.titleFont));
-            o.set("subtitlefont", Font.toJson(obj.subTitleFont));
-            o.set("wordsfont", Font.toJson(obj.wordsFont));
-            o.set("effectfont", Font.toJson(obj.effectFont));
-            o.set("timerfont", Font.toJson(obj.timerFont));
-            o.set("directionsfont", Font.toJson(obj.directionsFont));
-            o.set("fretboardnumberfont", Font.toJson(obj.fretboardNumberFont));
+            {
+                const m = new Map();
+                o.set("elementfonts", m);
+                for (const [k, v] of obj.elementFonts) {
+                    m.set(k.toString(), Font.toJson(v));
+                }
+            }
             o.set("numberednotationfont", Font.toJson(obj.numberedNotationFont));
             o.set("numberednotationgracefont", Font.toJson(obj.numberedNotationGraceFont));
             o.set("tablaturefont", Font.toJson(obj.tablatureFont));
             o.set("gracefont", Font.toJson(obj.graceFont));
             o.set("stafflinecolor", Color.toJson(obj.staffLineColor));
             o.set("barseparatorcolor", Color.toJson(obj.barSeparatorColor));
-            o.set("barnumberfont", Font.toJson(obj.barNumberFont));
             o.set("barnumbercolor", Color.toJson(obj.barNumberColor));
-            o.set("fingeringfont", Font.toJson(obj.fingeringFont));
-            o.set("inlinefingeringfont", Font.toJson(obj.inlineFingeringFont));
-            o.set("markerfont", Font.toJson(obj.markerFont));
             o.set("mainglyphcolor", Color.toJson(obj.mainGlyphColor));
             o.set("secondaryglyphcolor", Color.toJson(obj.secondaryGlyphColor));
             o.set("scoreinfocolor", Color.toJson(obj.scoreInfoColor));
@@ -41864,29 +42346,10 @@
                 case "smuflfontfamilyname":
                     obj.smuflFontFamilyName = v;
                     return true;
-                case "copyrightfont":
-                    obj.copyrightFont = Font.fromJson(v);
-                    return true;
-                case "titlefont":
-                    obj.titleFont = Font.fromJson(v);
-                    return true;
-                case "subtitlefont":
-                    obj.subTitleFont = Font.fromJson(v);
-                    return true;
-                case "wordsfont":
-                    obj.wordsFont = Font.fromJson(v);
-                    return true;
-                case "effectfont":
-                    obj.effectFont = Font.fromJson(v);
-                    return true;
-                case "timerfont":
-                    obj.timerFont = Font.fromJson(v);
-                    return true;
-                case "directionsfont":
-                    obj.directionsFont = Font.fromJson(v);
-                    return true;
-                case "fretboardnumberfont":
-                    obj.fretboardNumberFont = Font.fromJson(v);
+                case "elementfonts":
+                    JsonHelper.forEach(v, (v, k) => {
+                        obj.elementFonts.set(JsonHelper.parseEnum(k, exports.NotationElement), Font.fromJson(v));
+                    });
                     return true;
                 case "numberednotationfont":
                     obj.numberedNotationFont = Font.fromJson(v);
@@ -41906,21 +42369,9 @@
                 case "barseparatorcolor":
                     obj.barSeparatorColor = Color.fromJson(v);
                     return true;
-                case "barnumberfont":
-                    obj.barNumberFont = Font.fromJson(v);
-                    return true;
                 case "barnumbercolor":
                     obj.barNumberColor = Color.fromJson(v);
                     return true;
-                case "fingeringfont":
-                    obj.fingeringFont = Font.fromJson(v);
-                    return true;
-                case "inlinefingeringfont":
-                    obj.inlineFingeringFont = Font.fromJson(v);
-                    return true;
-                case "markerfont":
-                    obj.markerFont = Font.fromJson(v);
-                    return true;
                 case "mainglyphcolor":
                     obj.mainGlyphColor = Color.fromJson(v);
                     return true;
@@ -41977,6 +42428,46 @@
     class RenderingResources {
         static _sansFont = 'Arial, sans-serif';
         static _serifFont = 'Georgia, serif';
+        static _effectFont = new Font(RenderingResources._serifFont, 12, FontStyle.Italic);
+        /**
+         * The default fonts for notation elements if not specified by the user.
+         */
+        static defaultFonts = new Map([
+            [exports.NotationElement.ScoreTitle, new Font(RenderingResources._serifFont, 32, FontStyle.Plain)],
+            [exports.NotationElement.ScoreSubTitle, new Font(RenderingResources._serifFont, 20, FontStyle.Plain)],
+            [exports.NotationElement.ScoreArtist, new Font(RenderingResources._serifFont, 20, FontStyle.Plain)],
+            [exports.NotationElement.ScoreAlbum, new Font(RenderingResources._serifFont, 20, FontStyle.Plain)],
+            [exports.NotationElement.ScoreWords, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+            [exports.NotationElement.ScoreMusic, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+            [exports.NotationElement.ScoreWordsAndMusic, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+            [exports.NotationElement.ScoreCopyright, new Font(RenderingResources._sansFont, 12, FontStyle.Plain, FontWeight.Bold)],
+            [exports.NotationElement.EffectBeatTimer, new Font(RenderingResources._serifFont, 12, FontStyle.Plain)],
+            [exports.NotationElement.EffectDirections, new Font(RenderingResources._serifFont, 14, FontStyle.Plain)],
+            [exports.NotationElement.ChordDiagramFretboardNumbers, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+            [exports.NotationElement.EffectFingering, new Font(RenderingResources._serifFont, 14, FontStyle.Plain)],
+            [exports.NotationElement.EffectMarker, new Font(RenderingResources._serifFont, 14, FontStyle.Plain, FontWeight.Bold)],
+            [exports.NotationElement.EffectCapo, RenderingResources._effectFont],
+            [exports.NotationElement.EffectFreeTime, RenderingResources._effectFont],
+            [exports.NotationElement.EffectLyrics, RenderingResources._effectFont],
+            [exports.NotationElement.EffectTap, RenderingResources._effectFont],
+            [exports.NotationElement.ChordDiagrams, RenderingResources._effectFont],
+            [exports.NotationElement.EffectChordNames, RenderingResources._effectFont],
+            [exports.NotationElement.EffectText, RenderingResources._effectFont],
+            [exports.NotationElement.EffectPalmMute, RenderingResources._effectFont],
+            [exports.NotationElement.EffectLetRing, RenderingResources._effectFont],
+            [exports.NotationElement.EffectBeatBarre, RenderingResources._effectFont],
+            [exports.NotationElement.EffectTripletFeel, RenderingResources._effectFont],
+            [exports.NotationElement.EffectHarmonics, RenderingResources._effectFont],
+            [exports.NotationElement.EffectPickSlide, RenderingResources._effectFont],
+            [exports.NotationElement.GuitarTuning, RenderingResources._effectFont],
+            [exports.NotationElement.EffectRasgueado, RenderingResources._effectFont],
+            [exports.NotationElement.EffectWhammyBar, RenderingResources._effectFont],
+            [exports.NotationElement.TrackNames, RenderingResources._effectFont],
+            [exports.NotationElement.RepeatCount, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+            [exports.NotationElement.BarNumber, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+            [exports.NotationElement.ScoreBendSlur, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+            [exports.NotationElement.EffectAlternateEndings, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)]
+        ]);
         /**
          * The name of the SMuFL Font to use for rendering music symbols.
          *
@@ -42003,50 +42494,168 @@
          * The font to use for displaying the songs copyright information in the header of the music sheet.
          * @defaultValue `bold 12px Arial, sans-serif`
          * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreCopyright}
+         */
+        get copyrightFont() {
+            return this.elementFonts.get(exports.NotationElement.ScoreCopyright);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreCopyright}
          */
-        copyrightFont = new Font(RenderingResources._sansFont, 12, FontStyle.Plain, FontWeight.Bold);
+        set copyrightFont(value) {
+            this.elementFonts.set(exports.NotationElement.ScoreCopyright, value);
+        }
         /**
          * The font to use for displaying the songs title in the header of the music sheet.
          * @defaultValue `32px Georgia, serif`
          * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreTitle}
+         */
+        get titleFont() {
+            return this.elementFonts.get(exports.NotationElement.ScoreTitle);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreTitle}
          */
-        titleFont = new Font(RenderingResources._serifFont, 32, FontStyle.Plain);
+        set titleFont(value) {
+            this.elementFonts.set(exports.NotationElement.ScoreTitle, value);
+        }
         /**
          * The font to use for displaying the songs subtitle in the header of the music sheet.
          * @defaultValue `20px Georgia, serif`
          * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreSubTitle}
          */
-        subTitleFont = new Font(RenderingResources._serifFont, 20, FontStyle.Plain);
+        get subTitleFont() {
+            return this.elementFonts.get(exports.NotationElement.ScoreSubTitle);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreSubTitle}
+         */
+        set subTitleFont(value) {
+            this.elementFonts.set(exports.NotationElement.ScoreSubTitle, value);
+        }
         /**
          * The font to use for displaying the lyrics information in the header of the music sheet.
          * @defaultValue `15px Arial, sans-serif`
          * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreWords}
          */
-        wordsFont = new Font(RenderingResources._serifFont, 15, FontStyle.Plain);
+        get wordsFont() {
+            return this.elementFonts.get(exports.NotationElement.ScoreWords);
+        }
         /**
-         * The font to use for displaying certain effect related elements in the music sheet.
-         * @defaultValue `italic 12px Georgia, serif`
-         * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreWords}
          */
-        effectFont = new Font(RenderingResources._serifFont, 12, FontStyle.Italic);
+        set wordsFont(value) {
+            this.elementFonts.set(exports.NotationElement.ScoreWords, value);
+        }
         /**
          * The font to use for displaying beat time information in the music sheet.
          * @defaultValue `12px Georgia, serif`
          * @since 1.4.0
+         * @deprecated use {@link elementFonts} with {@link NotationElement.EffectBeatTimer}
          */
-        timerFont = new Font(RenderingResources._serifFont, 12, FontStyle.Plain);
+        get timerFont() {
+            return this.elementFonts.get(exports.NotationElement.EffectBeatTimer);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.EffectBeatTimer}
+         */
+        set timerFont(value) {
+            this.elementFonts.set(exports.NotationElement.EffectBeatTimer, value);
+        }
         /**
          * The font to use for displaying the directions texts.
          * @defaultValue `14px Georgia, serif`
          * @since 1.4.0
+         * @deprecated use {@link elementFonts} with {@link NotationElement.EffectDirections}
          */
-        directionsFont = new Font(RenderingResources._serifFont, 14, FontStyle.Plain);
+        get directionsFont() {
+            return this.elementFonts.get(exports.NotationElement.EffectDirections);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.EffectDirections}
+         */
+        set directionsFont(value) {
+            this.elementFonts.set(exports.NotationElement.EffectDirections, value);
+        }
         /**
          * The font to use for displaying the fretboard numbers in chord diagrams.
          * @defaultValue `11px Arial, sans-serif`
          * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ChordDiagramFretboardNumbers}
          */
-        fretboardNumberFont = new Font(RenderingResources._sansFont, 11, FontStyle.Plain);
+        get fretboardNumberFont() {
+            return this.elementFonts.get(exports.NotationElement.ChordDiagramFretboardNumbers);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.ChordDiagramFretboardNumbers}
+         */
+        set fretboardNumberFont(value) {
+            this.elementFonts.set(exports.NotationElement.ChordDiagramFretboardNumbers, value);
+        }
+        /**
+         * Unused, see deprecation note.
+         * @defaultValue `14px Georgia, serif`
+         * @since 0.9.6
+         * @deprecated Since 1.7.0 alphaTab uses the glyphs contained in the SMuFL font
+         * @json_ignore
+         */
+        fingeringFont = RenderingResources._effectFont;
+        /**
+         * Unused, see deprecation note.
+         * @defaultValue `12px Georgia, serif`
+         * @since 1.4.0
+         * @deprecated Since 1.7.0 alphaTab uses the glyphs contained in the SMuFL font
+         * @json_ignore
+         */
+        inlineFingeringFont = RenderingResources._effectFont;
+        /**
+         * The font to use for section marker labels shown above the music sheet.
+         * @defaultValue `bold 14px Georgia, serif`
+         * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.EffectMarker}
+         */
+        get markerFont() {
+            return this.elementFonts.get(exports.NotationElement.EffectMarker);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.EffectMarker}
+         */
+        set markerFont(value) {
+            this.elementFonts.set(exports.NotationElement.EffectMarker, value);
+        }
+        /**
+         * Ununsed, see deprecation note.
+         * @defaultValue `italic 12px Georgia, serif`
+         * @since 0.9.6
+         * @deprecated use {@link elementFonts} with the respective
+         * @json_ignore
+         */
+        effectFont = RenderingResources._effectFont;
+        /**
+         * The font to use for displaying the bar numbers above the music sheet.
+         * @defaultValue `11px Arial, sans-serif`
+         * @since 0.9.6
+         * @deprecated use {@link elementFonts} with {@link NotationElement.BarNumber}
+         */
+        get barNumberFont() {
+            return this.elementFonts.get(exports.NotationElement.BarNumber);
+        }
+        /**
+         * @deprecated use {@link elementFonts} with {@link NotationElement.BarNumber}
+         */
+        set barNumberFont(value) {
+            this.elementFonts.set(exports.NotationElement.BarNumber, value);
+        }
+        // NOTE: the main staff fonts are still own properties.
+        /**
+         * The fonts used by individual elements. Check {@link defaultFonts} for the elements which have custom fonts.
+         * Removing fonts from this map can lead to unexpected side effects and errors. Only update it with new values.
+         * @json_immutable
+         */
+        elementFonts = new Map();
         /**
          * The font to use for displaying the numbered music notation in the music sheet.
          * @defaultValue `14px Arial, sans-serif`
@@ -42083,38 +42692,12 @@
          * @since 0.9.6
          */
         barSeparatorColor = new Color(34, 34, 17, 0xff);
-        /**
-         * The font to use for displaying the bar numbers above the music sheet.
-         * @defaultValue `11px Arial, sans-serif`
-         * @since 0.9.6
-         */
-        barNumberFont = new Font(RenderingResources._sansFont, 11, FontStyle.Plain);
         /**
          * The color to use for displaying the bar numbers above the music sheet.
          * @defaultValue `rgb(200, 0, 0)`
          * @since 0.9.6
          */
         barNumberColor = new Color(200, 0, 0, 0xff);
-        /**
-         * The font to use for displaying finger information in the music sheet.
-         * @defaultValue `14px Georgia, serif`
-         * @since 0.9.6
-         * @deprecated Since 1.7.0 alphaTab uses the glyphs contained in the SMuFL font
-         */
-        fingeringFont = new Font(RenderingResources._serifFont, 14, FontStyle.Plain);
-        /**
-         * The font to use for displaying finger information when inline into the music sheet.
-         * @defaultValue `12px Georgia, serif`
-         * @since 1.4.0
-         * @deprecated Since 1.7.0 alphaTab uses the glyphs contained in the SMuFL font
-         */
-        inlineFingeringFont = new Font(RenderingResources._serifFont, 12, FontStyle.Plain);
-        /**
-         * The font to use for section marker labels shown above the music sheet.
-         * @defaultValue `bold 14px Georgia, serif`
-         * @since 0.9.6
-         */
-        markerFont = new Font(RenderingResources._serifFont, 14, FontStyle.Plain, FontWeight.Bold);
         /**
          * The color to use for music notation elements of the primary voice.
          * @defaultValue `rgb(0, 0, 0)`
@@ -42133,28 +42716,50 @@
          * @since 0.9.6
          */
         scoreInfoColor = new Color(0, 0, 0, 0xff);
+        constructor() {
+            for (const [k, v] of RenderingResources.defaultFonts) {
+                this.elementFonts.set(k, v.withSize(v.size));
+            }
+        }
         /**
          * @internal
          * @param element
          */
         getFontForElement(element) {
+            let notationElement = exports.NotationElement.ScoreWords;
             switch (element) {
                 case ScoreSubElement.Title:
-                    return this.titleFont;
+                    notationElement = exports.NotationElement.ScoreTitle;
+                    break;
                 case ScoreSubElement.SubTitle:
+                    notationElement = exports.NotationElement.ScoreSubTitle;
+                    break;
                 case ScoreSubElement.Artist:
+                    notationElement = exports.NotationElement.ScoreArtist;
+                    break;
                 case ScoreSubElement.Album:
-                    return this.subTitleFont;
+                    notationElement = exports.NotationElement.ScoreAlbum;
+                    break;
                 case ScoreSubElement.Words:
+                    notationElement = exports.NotationElement.ScoreWords;
+                    break;
                 case ScoreSubElement.Music:
+                    notationElement = exports.NotationElement.ScoreMusic;
+                    break;
                 case ScoreSubElement.WordsAndMusic:
-                case ScoreSubElement.Transcriber:
-                    return this.wordsFont;
+                    notationElement = exports.NotationElement.ScoreWordsAndMusic;
+                    break;
                 case ScoreSubElement.Copyright:
                 case ScoreSubElement.CopyrightSecondLine:
-                    return this.copyrightFont;
+                    notationElement = exports.NotationElement.ScoreCopyright;
+                    break;
+                default:
+                    notationElement = exports.NotationElement.ScoreWords;
+                    break;
             }
-            return this.wordsFont;
+            return this.elementFonts.has(notationElement)
+                ? this.elementFonts.get(notationElement)
+                : RenderingResources.defaultFonts.get(exports.NotationElement.ScoreWords);
         }
     }
 
@@ -42459,6 +43064,13 @@
          * @defaultValue `5`
          */
         trackStaffPaddingBetween = 5;
+        /**
+         * The additional padding to apply between multiple lyric lines.
+         * @since 1.8.0
+         * @category Display
+         * @defaultValue `5`
+         */
+        lyricLinesPaddingBetween = 5;
         /**
          * The mode used to arrange staves and systems.
          * @since 1.3.0
@@ -42569,6 +43181,7 @@
             o.set("staffpaddingleft", obj.staffPaddingLeft);
             o.set("effectbandpaddingbottom", obj.effectBandPaddingBottom);
             o.set("trackstaffpaddingbetween", obj.trackStaffPaddingBetween);
+            o.set("lyriclinespaddingbetween", obj.lyricLinesPaddingBetween);
             o.set("systemslayoutmode", obj.systemsLayoutMode);
             return o;
         }
@@ -42655,6 +43268,9 @@
                 case "trackstaffpaddingbetween":
                     obj.trackStaffPaddingBetween = v;
                     return true;
+                case "lyriclinespaddingbetween":
+                    obj.lyricLinesPaddingBetween = v;
+                    return true;
                 case "systemslayoutmode":
                     obj.systemsLayoutMode = JsonHelper.parseEnum(v, exports.SystemsLayoutMode);
                     return true;
@@ -55363,23 +55979,20 @@
             this._contents = '';
             const element = api.container;
             if (settings.core.tex) {
-                this._contents = element.element.innerText;
+                this._contents = element.element.textContent;
                 element.element.innerText = '';
             }
             this._createStyleElements(settings);
             this._file = settings.core.file;
         }
         _setupFontCheckers(settings) {
-            this._registerFontChecker(settings.display.resources.copyrightFont);
-            this._registerFontChecker(settings.display.resources.effectFont);
+            for (const font of settings.display.resources.elementFonts.values()) {
+                this._registerFontChecker(font);
+            }
             this._registerFontChecker(settings.display.resources.graceFont);
-            this._registerFontChecker(settings.display.resources.markerFont);
             this._registerFontChecker(settings.display.resources.tablatureFont);
-            this._registerFontChecker(settings.display.resources.titleFont);
-            this._registerFontChecker(settings.display.resources.wordsFont);
-            this._registerFontChecker(settings.display.resources.barNumberFont);
-            this._registerFontChecker(settings.display.resources.fretboardNumberFont);
-            this._registerFontChecker(settings.display.resources.subTitleFont);
+            this._registerFontChecker(settings.display.resources.numberedNotationFont);
+            this._registerFontChecker(settings.display.resources.numberedNotationGraceFont);
         }
         _registerFontChecker(font) {
             if (!this._fontCheckers.has(font.families.join(', '))) {
@@ -57216,7 +57829,9 @@
         }
         doLayout() {
             super.doLayout();
-            this.height = this.renderer.resources.wordsFont.size + this.renderer.smuflMetrics.alternateEndingsPadding * 2;
+            this.height =
+                this.renderer.resources.elementFonts.get(exports.NotationElement.EffectAlternateEndings).size +
+                    this.renderer.smuflMetrics.alternateEndingsPadding * 2;
             let endingsStrings = '';
             for (let i = 0, j = this._endings.length; i < j; i++) {
                 endingsStrings += this._endings[i] + 1;
@@ -57252,7 +57867,7 @@
                 const baseline = canvas.textBaseline;
                 canvas.textBaseline = TextBaseline.Top;
                 const res = this.renderer.resources;
-                canvas.font = res.wordsFont;
+                canvas.font = res.elementFonts.get(exports.NotationElement.EffectAlternateEndings);
                 canvas.fillText(this._endingsString, cx + this.x + this.renderer.smuflMetrics.alternateEndingsPadding, cy + this.y + this.renderer.smuflMetrics.alternateEndingsPadding);
                 canvas.textBaseline = baseline;
             }
@@ -57394,10 +58009,12 @@
         _label;
         _dashed;
         _labelWidth = 0;
-        constructor(label, dashed = true) {
+        _fontElement;
+        constructor(label, fontElement, dashed = true) {
             super(BeatXPosition.OnNotes);
             this._label = label;
             this._dashed = dashed;
+            this._fontElement = fontElement;
         }
         doLayout() {
             if (this.renderer.settings.notation.extendLineEffectsToBeatEnd) {
@@ -57405,14 +58022,14 @@
                 this.forceGroupedRendering = true;
             }
             super.doLayout();
-            this.renderer.scoreRenderer.canvas.font = this.renderer.resources.effectFont;
+            this.renderer.scoreRenderer.canvas.font = this.renderer.resources.elementFonts.get(this._fontElement);
             const size = this.renderer.scoreRenderer.canvas.measureText(this._label);
             this.height = size.height;
             this._labelWidth = size.width;
         }
         paintNonGrouped(cx, cy, canvas) {
             const res = this.renderer.resources;
-            canvas.font = res.effectFont;
+            canvas.font = res.elementFonts.get(this._fontElement);
             const b = canvas.textBaseline;
             canvas.textBaseline = TextBaseline.Middle;
             canvas.fillText(this._label, cx + this.x - this._labelWidth / 2, cy + this.y + this.height / 2);
@@ -57473,7 +58090,7 @@
                     break;
             }
             barre += `B ${BeatBarreEffectInfo.toRoman(beat.barreFret)}`;
-            return new LineRangedGlyph(barre, false);
+            return new LineRangedGlyph(barre, exports.NotationElement.EffectBeatBarre, false);
         }
         static _romanLetters = new Map([
             // ['M', 1000],
@@ -57523,7 +58140,7 @@
             const seconds = ((this._timer - minutes * 60000) / 1000) | 0;
             this._text = `${minutes}:${seconds.toString().padStart(2, '0')}`;
             const c = this.renderer.scoreRenderer.canvas;
-            c.font = this.renderer.resources.timerFont;
+            c.font = this.renderer.resources.elementFonts.get(exports.NotationElement.EffectBeatTimer);
             const size = c.measureText(this._text);
             this._textHeight = c.font.size + this.renderer.smuflMetrics.beatTimerPadding * 2;
             this._textWidth = size.width + this.renderer.smuflMetrics.beatTimerPadding * 2;
@@ -57535,7 +58152,7 @@
             const f = canvas.font;
             const b = canvas.textBaseline;
             const a = canvas.textAlign;
-            canvas.font = this.renderer.resources.timerFont;
+            canvas.font = this.renderer.resources.elementFonts.get(exports.NotationElement.EffectBeatTimer);
             canvas.textBaseline = TextBaseline.Middle;
             canvas.textAlign = TextAlign.Center;
             canvas.fillText(this._text, cx + this.x, cy + this.y + this.height / 2);
@@ -57644,7 +58261,7 @@
             return beat.index === 0 && beat.voice.bar.index === 0 && beat.voice.bar.staff.capo !== 0;
         }
         createNewGlyph(renderer, beat) {
-            return new TextGlyph(0, 0, `Capo. fret ${beat.voice.bar.staff.capo}`, renderer.resources.effectFont, TextAlign.Left);
+            return new TextGlyph(0, 0, `Capo. fret ${beat.voice.bar.staff.capo}`, renderer.resources.elementFonts.get(exports.NotationElement.EffectCapo), TextAlign.Left);
         }
         canExpand(_from, _to) {
             return false;
@@ -57661,31 +58278,41 @@
         _fretRow = 0;
         _firstFretSpacing = 0;
         _center;
-        constructor(x, y, chord, center = false) {
+        _fontElement;
+        constructor(x, y, chord, fontElement, center = false) {
             super(x, y);
             this._chord = chord;
             this._center = center;
+            this._fontElement = fontElement;
         }
         doLayout() {
             super.doLayout();
             const res = this.renderer.resources;
-            this._textRow = res.effectFont.size * 1.5;
-            this._fretRow = res.effectFont.size * 1.5;
-            if (this._chord.firstFret > 1) {
-                this._firstFretSpacing = this.renderer.smuflMetrics.chordDiagramFretSpacing;
-            }
-            else {
-                this._firstFretSpacing = 0;
-            }
-            this.height =
-                this._textRow +
+            const font = res.elementFonts.get(this._fontElement);
+            this._textRow = font.size * 1.5;
+            this._fretRow = font.size * 1.5;
+            this.height = this._textRow;
+            this.width = 2 * this.renderer.smuflMetrics.chordDiagramPaddingX;
+            if (this.renderer.settings.notation.isNotationElementVisible(exports.NotationElement.ChordDiagramFretboardNumbers)) {
+                if (this._chord.firstFret > 1) {
+                    this._firstFretSpacing = this.renderer.smuflMetrics.chordDiagramFretSpacing;
+                }
+                else {
+                    this._firstFretSpacing = 0;
+                }
+                this.height +=
                     this._fretRow +
-                    ChordDiagramGlyph._frets * this.renderer.smuflMetrics.chordDiagramFretSpacing +
-                    2 * this.renderer.smuflMetrics.chordDiagramPaddingY;
-            this.width =
-                this._firstFretSpacing +
-                    (this._chord.strings.length - 1) * this.renderer.smuflMetrics.chordDiagramStringSpacing +
-                    2 * this.renderer.smuflMetrics.chordDiagramPaddingX;
+                        ChordDiagramGlyph._frets * this.renderer.smuflMetrics.chordDiagramFretSpacing +
+                        2 * this.renderer.smuflMetrics.chordDiagramPaddingY;
+                this.width +=
+                    this._firstFretSpacing +
+                        (this._chord.strings.length - 1) * this.renderer.smuflMetrics.chordDiagramStringSpacing;
+            }
+            else if (this._chord.showName) {
+                const canvas = this.renderer.scoreRenderer.canvas;
+                canvas.font = font;
+                this.width += canvas.measureText(this._chord.name).width;
+            }
         }
         paint(cx, cy, canvas) {
             cx += this.x + this.renderer.smuflMetrics.chordDiagramPaddingX + this._firstFretSpacing;
@@ -57693,25 +58320,35 @@
             if (this._center) {
                 cx -= this.width / 2;
             }
-            const stringSpacing = this.renderer.smuflMetrics.chordDiagramStringSpacing;
-            const fretSpacing = this.renderer.smuflMetrics.chordDiagramFretSpacing;
             const res = this.renderer.resources;
             const lineWidth = res.engravingSettings.chordDiagramLineWidth;
             const w = this.width - 2 * this.renderer.smuflMetrics.chordDiagramPaddingX - this._firstFretSpacing + lineWidth;
-            const circleHeight = res.engravingSettings.glyphHeights.get(MusicFontSymbol.FretboardFilledCircle);
-            const circleTopOffset = res.engravingSettings.glyphTop.get(MusicFontSymbol.FretboardFilledCircle);
-            const xTopOffset = res.engravingSettings.glyphHeights.get(MusicFontSymbol.FretboardX) / 2;
-            const oTopOffset = res.engravingSettings.glyphHeights.get(MusicFontSymbol.FretboardO) / 2;
             const align = canvas.textAlign;
             const baseline = canvas.textBaseline;
-            canvas.font = res.effectFont;
+            const font = res.elementFonts.get(this._fontElement);
+            canvas.font = font;
             canvas.textAlign = TextAlign.Center;
             canvas.textBaseline = TextBaseline.Top;
             if (this._chord.showName) {
-                canvas.fillText(this._chord.name, cx + w / 2, cy + res.effectFont.size / 2);
+                canvas.fillText(this._chord.name, cx + w / 2, cy + font.size / 2);
             }
+            if (this.renderer.settings.notation.isNotationElementVisible(exports.NotationElement.ChordDiagramFretboardNumbers)) {
+                this._paintFretboard(cx, cy, canvas, w);
+            }
+            canvas.textAlign = align;
+            canvas.textBaseline = baseline;
+        }
+        _paintFretboard(cx, cy, canvas, w) {
             cy += this._textRow;
-            canvas.font = res.fretboardNumberFont;
+            const res = this.renderer.resources;
+            const stringSpacing = this.renderer.smuflMetrics.chordDiagramStringSpacing;
+            const fretSpacing = this.renderer.smuflMetrics.chordDiagramFretSpacing;
+            const circleHeight = res.engravingSettings.glyphHeights.get(MusicFontSymbol.FretboardFilledCircle);
+            const circleTopOffset = res.engravingSettings.glyphTop.get(MusicFontSymbol.FretboardFilledCircle);
+            const xTopOffset = res.engravingSettings.glyphHeights.get(MusicFontSymbol.FretboardX) / 2;
+            const oTopOffset = res.engravingSettings.glyphHeights.get(MusicFontSymbol.FretboardO) / 2;
+            const lineWidth = res.engravingSettings.chordDiagramLineWidth;
+            canvas.font = res.elementFonts.get(exports.NotationElement.ChordDiagramFretboardNumbers);
             canvas.textBaseline = TextBaseline.Middle;
             for (let i = 0; i < this._chord.strings.length; i++) {
                 const x = cx + i * stringSpacing;
@@ -57774,8 +58411,6 @@
                 const xRight = cx + (this._chord.strings.length - strings[0] - 1) * stringSpacing;
                 canvas.fillRect(xLeft, y - circleHeight / 2, xRight - xLeft, circleHeight);
             }
-            canvas.textAlign = align;
-            canvas.textBaseline = baseline;
         }
     }
 
@@ -57801,8 +58436,8 @@
         createNewGlyph(renderer, beat) {
             const showDiagram = beat.voice.bar.staff.track.score.stylesheet.globalDisplayChordDiagramsInScore;
             return showDiagram
-                ? new ChordDiagramGlyph(0, 0, beat.chord, true)
-                : new TextGlyph(0, 0, beat.chord.name, renderer.resources.effectFont, TextAlign.Center);
+                ? new ChordDiagramGlyph(0, 0, beat.chord, exports.NotationElement.EffectChordNames, true)
+                : new TextGlyph(0, 0, beat.chord.name, renderer.resources.elementFonts.get(exports.NotationElement.EffectChordNames), TextAlign.Center);
         }
         canExpand(_from, _to) {
             return false;
@@ -57913,14 +58548,14 @@
         }
         doLayout() {
             const c = this.renderer.scoreRenderer.canvas;
-            c.font = this.renderer.resources.directionsFont;
+            c.font = this.renderer.resources.elementFonts.get(exports.NotationElement.EffectDirections);
             this.height = c.measureText(this._text).height;
         }
         paint(cx, cy, canvas) {
             const font = canvas.font;
             const baseline = canvas.textBaseline;
             const align = canvas.textAlign;
-            canvas.font = this.renderer.resources.directionsFont;
+            canvas.font = this.renderer.resources.elementFonts.get(exports.NotationElement.EffectDirections);
             canvas.textBaseline = TextBaseline.Middle;
             canvas.textAlign = TextAlign.Right;
             canvas.fillText(this._text, cx + this.x, cy + this.y + this.height / 2);
@@ -58816,7 +59451,7 @@
                 (masterBar.index === 0 || masterBar.isFreeTime !== masterBar.previousMasterBar.isFreeTime));
         }
         createNewGlyph(renderer, _beat) {
-            return new TextGlyph(0, 0, 'Free time', renderer.resources.effectFont, TextAlign.Left);
+            return new TextGlyph(0, 0, 'Free time', renderer.resources.elementFonts.get(exports.NotationElement.EffectFreeTime), TextAlign.Left);
         }
         canExpand(_from, _to) {
             return true;
@@ -58954,7 +59589,7 @@
             return EffectBarGlyphSizing.GroupedOnBeat;
         }
         createNewGlyph(_renderer, _beat) {
-            return new LineRangedGlyph(HarmonicsEffectInfo.harmonicToString(this._harmonicType));
+            return new LineRangedGlyph(HarmonicsEffectInfo.harmonicToString(this._harmonicType), exports.NotationElement.EffectHarmonics);
         }
         static harmonicToString(type) {
             switch (type) {
@@ -59027,7 +59662,7 @@
             return EffectBarGlyphSizing.GroupedOnBeat;
         }
         createNewGlyph(_renderer, _beat) {
-            return new LineRangedGlyph('LetRing');
+            return new LineRangedGlyph('LetRing', exports.NotationElement.EffectLetRing);
         }
         canExpand(_from, _to) {
             return true;
@@ -59039,6 +59674,7 @@
      */
     class LyricsGlyph extends EffectGlyph {
         _lines;
+        _linePositions = [];
         font;
         textAlign;
         constructor(x, y, lines, font, textAlign = TextAlign.Center) {
@@ -59049,7 +59685,17 @@
         }
         doLayout() {
             super.doLayout();
-            this.height = this.font.size * this._lines.length;
+            const lineSpacing = this.renderer.settings.display.lyricLinesPaddingBetween;
+            const canvas = this.renderer.scoreRenderer.canvas;
+            canvas.font = this.font;
+            let y = 0;
+            for (const line of this._lines) {
+                this._linePositions.push(y);
+                const size = canvas.measureText(line.length > 0 ? line : ' ');
+                y += size.height + lineSpacing;
+            }
+            y -= lineSpacing;
+            this.height = y;
         }
         paint(cx, cy, canvas) {
             canvas.font = this.font;
@@ -59057,7 +59703,7 @@
             canvas.textAlign = this.textAlign;
             for (let i = 0; i < this._lines.length; i++) {
                 if (this._lines[i]) {
-                    canvas.fillText(this._lines[i], cx + this.x, cy + this.y + i * this.font.size);
+                    canvas.fillText(this._lines[i], cx + this.x, cy + this.y + this._linePositions[i]);
                 }
             }
             canvas.textAlign = old;
@@ -59084,7 +59730,7 @@
             return !!beat.lyrics;
         }
         createNewGlyph(renderer, beat) {
-            return new LyricsGlyph(0, 0, beat.lyrics, renderer.resources.effectFont, TextAlign.Center);
+            return new LyricsGlyph(0, 0, beat.lyrics, renderer.resources.elementFonts.get(exports.NotationElement.EffectLyrics), TextAlign.Center);
         }
         canExpand(_from, _to) {
             return true;
@@ -59116,7 +59762,7 @@
         createNewGlyph(renderer, beat) {
             return new TextGlyph(0, 0, !beat.voice.bar.masterBar.section.marker
                 ? beat.voice.bar.masterBar.section.text
-                : `[${beat.voice.bar.masterBar.section.marker}] ${beat.voice.bar.masterBar.section.text}`, renderer.resources.markerFont, TextAlign.Left);
+                : `[${beat.voice.bar.masterBar.section.marker}] ${beat.voice.bar.masterBar.section.text}`, renderer.resources.elementFonts.get(exports.NotationElement.EffectMarker), TextAlign.Left);
         }
         canExpand(_from, _to) {
             return true;
@@ -59555,7 +60201,7 @@
             return EffectBarGlyphSizing.GroupedOnBeat;
         }
         createNewGlyph(_renderer, _beat) {
-            return new LineRangedGlyph('P.M.');
+            return new LineRangedGlyph('P.M.', exports.NotationElement.EffectPalmMute);
         }
     }
 
@@ -59573,7 +60219,7 @@
             return EffectBarGlyphSizing.GroupedOnBeat;
         }
         createNewGlyph(_renderer, _beat) {
-            return new LineRangedGlyph('P.S.');
+            return new LineRangedGlyph('P.S.', exports.NotationElement.EffectPickSlide);
         }
     }
 
@@ -59648,7 +60294,7 @@
             return EffectBarGlyphSizing.GroupedOnBeat;
         }
         createNewGlyph(_renderer, _beat) {
-            return new LineRangedGlyph('rasg.');
+            return new LineRangedGlyph('rasg.', exports.NotationElement.EffectRasgueado);
         }
         canExpand(_from, _to) {
             return true;
@@ -61154,6 +61800,7 @@
     class BeamingHelper {
         _staff;
         _renderer;
+        _beamingRuleLookup;
         voice = null;
         beats = [];
         shortestDuration = Duration.QuadrupleWhole;
@@ -61187,10 +61834,11 @@
         static beatHasFlag(beat) {
             return (!beat.deadSlapped && !beat.isRest && (beat.duration > Duration.Quarter || beat.graceType !== GraceType.None));
         }
-        constructor(staff, renderer) {
+        constructor(staff, renderer, beamingRuleLookup) {
             this._staff = staff;
             this._renderer = renderer;
             this.beats = [];
+            this._beamingRuleLookup = beamingRuleLookup;
         }
         alignWithBeats() {
             for (const v of this.drawingInfos.values()) {
@@ -61245,7 +61893,7 @@
                 switch (this.beats[this.beats.length - 1].beamingMode) {
                     case BeatBeamingMode.Auto:
                     case BeatBeamingMode.ForceSplitOnSecondaryToNext:
-                        add = BeamingHelper._canJoin(this.beats[this.beats.length - 1], beat);
+                        add = this._canJoin(this.beats[this.beats.length - 1], beat);
                         break;
                     case BeatBeamingMode.ForceSplitToNext:
                         add = false;
@@ -61317,8 +61965,7 @@
                 this._highestNoteCompareValueInHelper = highestValueForNote;
             }
         }
-        // TODO: Check if this beaming is really correct, I'm not sure if we are connecting beats correctly
-        static _canJoin(b1, b2) {
+        _canJoin(b1, b2) {
             // is this a voice we can join with?
             if (!b1 ||
                 !b2 ||
@@ -61356,19 +62003,10 @@
                     return true;
                 }
             }
-            // TODO: create more rules for automatic beaming
-            let divisionLength = MidiUtils.QuarterTime;
-            switch (m1.masterBar.timeSignatureDenominator) {
-                case 8:
-                    if (m1.masterBar.timeSignatureNumerator % 3 === 0) {
-                        divisionLength += (MidiUtils.QuarterTime / 2) | 0;
-                    }
-                    break;
-            }
-            // check if they are on the same division
-            const division1 = ((divisionLength + start1) / divisionLength) | 0 | 0;
-            const division2 = ((divisionLength + start2) / divisionLength) | 0 | 0;
-            return division1 === division2;
+            // check if they are on the same group as per rule definitions
+            const groupId1 = this._beamingRuleLookup.calculateGroupIndex(start1);
+            const groupId2 = this._beamingRuleLookup.calculateGroupIndex(start2);
+            return groupId1 === groupId2;
         }
         static _canJoinDuration(d) {
             switch (d) {
@@ -61535,6 +62173,61 @@
         }
     }
 
+    /**
+     * @internal
+     */
+    class BeamingRuleLookup {
+        _division = 0;
+        _slots = [];
+        _barDuration;
+        constructor(barDuration, division, slots) {
+            this._division = division;
+            this._slots = slots;
+            this._barDuration = barDuration;
+        }
+        calculateGroupIndex(beatStartTime) {
+            // no slots -> all have their own group based (use the start time as index)
+            if (this._slots.length === 0) {
+                return beatStartTime;
+            }
+            // rollover within the bar.
+            beatStartTime = beatStartTime % this._barDuration;
+            const slotIndex = Math.floor(beatStartTime / this._division);
+            return this._slots[slotIndex];
+        }
+        static build(masterBar, ruleDuration, ruleGroups) {
+            const totalDuration = masterBar.calculateDuration(false);
+            const division = MidiUtils.toTicks(ruleDuration);
+            const slotCount = totalDuration / division;
+            // should only happen in case of improper data.
+            if (slotCount < 0 || ruleGroups.length === 0) {
+                return new BeamingRuleLookup(0, 0, []);
+            }
+            let groupIndex = 0;
+            let remainingSlots = ruleGroups[groupIndex];
+            const slots = [];
+            for (let i = 0; i < slotCount; i++) {
+                if (groupIndex < ruleGroups.length) {
+                    slots.push(groupIndex);
+                    remainingSlots--;
+                    if (remainingSlots <= 0) {
+                        groupIndex++;
+                        if (groupIndex < ruleGroups.length) {
+                            remainingSlots = ruleGroups[groupIndex];
+                        }
+                    }
+                }
+                else {
+                    // no groups defined for the remaining slots: all slots are treated
+                    // as unjoined
+                    slots.push(groupIndex);
+                    groupIndex++;
+                }
+            }
+            return new BeamingRuleLookup(totalDuration, division, slots);
+        }
+    }
+
     /**
      * @internal
      */
@@ -61551,6 +62244,19 @@
         initialize() {
             const barRenderer = this._renderer;
             const bar = this._renderer.bar;
+            const masterBar = bar.masterBar;
+            const beamingRules = masterBar.actualBeamingRules ?? BarHelpers._findOrBuildDefaultBeamingRules(masterBar);
+            const rule = beamingRules.findRule(bar.shortestDuration);
+            // NOTE: moste rules have only one group definition, so its better to reuse the unique id
+            // than compute a potentially shorter id here.
+            const key = `beaming_${beamingRules.uniqueId}_${rule[0]}`;
+            let beamingRuleLookup = this._renderer.scoreRenderer.layout.beamingRuleLookups.has(key)
+                ? this._renderer.scoreRenderer.layout.beamingRuleLookups.get(key)
+                : undefined;
+            if (!beamingRuleLookup) {
+                beamingRuleLookup = BeamingRuleLookup.build(masterBar, rule[0], rule[1]);
+                this._renderer.scoreRenderer.layout.beamingRuleLookups.set(key, beamingRuleLookup);
+            }
             let currentBeamHelper = null;
             let currentGraceBeamHelper = null;
             for (let i = 0, j = bar.voices.length; i < j; i++) {
@@ -61576,7 +62282,7 @@
                             helperForBeat.finish();
                         }
                         // if not possible, create the next beaming helper
-                        helperForBeat = new BeamingHelper(bar.staff, barRenderer);
+                        helperForBeat = new BeamingHelper(bar.staff, barRenderer, beamingRuleLookup);
                         helperForBeat.preferredBeamDirection = this.preferredBeamDirection;
                         helperForBeat.checkBeat(b);
                         if (b.graceType !== GraceType.None) {
@@ -61599,6 +62305,69 @@
                 currentGraceBeamHelper = null;
             }
         }
+        static _defaultBeamingRules;
+        static _findOrBuildDefaultBeamingRules(masterBar) {
+            let defaultBeamingRules = BarHelpers._defaultBeamingRules;
+            if (!defaultBeamingRules) {
+                defaultBeamingRules = new Map([
+                    BeamingRules.createSimple(2, 16, Duration.Sixteenth, [1, 1]),
+                    BeamingRules.createSimple(1, 8, Duration.Eighth, [1]),
+                    BeamingRules.createSimple(1, 4, Duration.Quarter, [1]),
+                    BeamingRules.createSimple(3, 16, Duration.Sixteenth, [3]),
+                    BeamingRules.createSimple(4, 16, Duration.Sixteenth, [2, 2]),
+                    BeamingRules.createSimple(2, 8, Duration.Eighth, [1, 1]),
+                    BeamingRules.createSimple(5, 16, Duration.Sixteenth, [3, 2]),
+                    BeamingRules.createSimple(6, 16, Duration.Sixteenth, [3, 3]),
+                    BeamingRules.createSimple(3, 8, Duration.Eighth, [3]),
+                    BeamingRules.createSimple(4, 8, Duration.Eighth, [2, 2]),
+                    BeamingRules.createSimple(2, 4, Duration.Quarter, [1, 1]),
+                    BeamingRules.createSimple(9, 16, Duration.Sixteenth, [3, 3, 3]),
+                    BeamingRules.createSimple(5, 8, Duration.Eighth, [3, 2]),
+                    BeamingRules.createSimple(12, 16, Duration.Sixteenth, [3, 3, 3, 3]),
+                    BeamingRules.createSimple(6, 8, Duration.Eighth, [3, 3, 3]),
+                    BeamingRules.createSimple(3, 4, Duration.Quarter, [1, 1, 1]),
+                    BeamingRules.createSimple(7, 8, Duration.Eighth, [4, 3]),
+                    BeamingRules.createSimple(8, 8, Duration.Eighth, [3, 3, 2]),
+                    BeamingRules.createSimple(4, 4, Duration.Quarter, [1, 1, 1, 1]),
+                    BeamingRules.createSimple(9, 8, Duration.Eighth, [3, 3, 3]),
+                    BeamingRules.createSimple(10, 8, Duration.Eighth, [4, 3, 3]),
+                    BeamingRules.createSimple(5, 4, Duration.Quarter, [1, 1, 1, 1, 1]),
+                    BeamingRules.createSimple(12, 8, Duration.Eighth, [3, 3, 3, 3]),
+                    BeamingRules.createSimple(6, 4, Duration.Quarter, [1, 1, 1, 1, 1, 1]),
+                    BeamingRules.createSimple(15, 8, Duration.Eighth, [3, 3, 3, 3, 3, 3]),
+                    BeamingRules.createSimple(8, 4, Duration.Quarter, [1, 1, 1, 1, 1, 1, 1, 1]),
+                    BeamingRules.createSimple(18, 8, Duration.Eighth, [3, 3, 3, 3, 3, 3])
+                ].map(r => [`${r.timeSignatureNumerator}_${r.timeSignatureDenominator}`, r]));
+                BarHelpers._defaultBeamingRules = defaultBeamingRules;
+            }
+            const key = `${masterBar.timeSignatureNumerator}_${masterBar.timeSignatureDenominator}`;
+            if (defaultBeamingRules.has(key)) {
+                return defaultBeamingRules.get(key);
+            }
+            // NOTE: this is the old alphaTab logic how we used to beamed bars.
+            // we either group in quarters, or in 3x8ths depending on the key signature
+            let divisionLength = MidiUtils.QuarterTime;
+            switch (masterBar.timeSignatureDenominator) {
+                case 8:
+                    if (masterBar.timeSignatureNumerator % 3 === 0) {
+                        divisionLength += (MidiUtils.QuarterTime / 2) | 0;
+                    }
+                    break;
+            }
+            const numberOfDivisions = Math.ceil(masterBar.calculateDuration(false) / divisionLength);
+            const notesPerDivision = (divisionLength / MidiUtils.QuarterTime) * 2;
+            const fallback = new BeamingRules();
+            const groups = [];
+            for (let i = 0; i < numberOfDivisions; i++) {
+                groups.push(notesPerDivision);
+            }
+            fallback.groups.set(Duration.Eighth, groups);
+            fallback.timeSignatureNumerator = masterBar.timeSignatureNumerator;
+            fallback.timeSignatureDenominator = masterBar.timeSignatureDenominator;
+            fallback.finish();
+            defaultBeamingRules.set(key, fallback);
+            return fallback;
+        }
         getBeamingHelperForBeat(beat) {
             return this._beamHelperLookup.has(beat.id) ? this._beamHelperLookup.get(beat.id) : undefined;
         }
@@ -63256,12 +64025,12 @@
         createNewGlyph(renderer, beat) {
             const res = renderer.resources;
             if (beat.slap) {
-                return new TextGlyph(0, 0, 'S', res.effectFont, TextAlign.Center);
+                return new TextGlyph(0, 0, 'S', res.elementFonts.get(exports.NotationElement.EffectTap), TextAlign.Center);
             }
             if (beat.pop) {
-                return new TextGlyph(0, 0, 'P', res.effectFont, TextAlign.Center);
+                return new TextGlyph(0, 0, 'P', res.elementFonts.get(exports.NotationElement.EffectTap), TextAlign.Center);
             }
-            return new TextGlyph(0, 0, 'T', res.effectFont, TextAlign.Center);
+            return new TextGlyph(0, 0, 'T', res.elementFonts.get(exports.NotationElement.EffectTap), TextAlign.Center);
         }
         canExpand(_from, _to) {
             return true;
@@ -63290,7 +64059,7 @@
             for (const automation of this._tempoAutomations) {
                 let x = cx + this.renderer.getRatioPositionX(automation.ratioPosition);
                 const res = this.renderer.resources;
-                canvas.font = res.markerFont;
+                canvas.font = res.elementFonts.get(exports.NotationElement.EffectMarker);
                 const notePosY = cy +
                     this.y +
                     this.height +
@@ -63368,7 +64137,7 @@
             return !!beat.text;
         }
         createNewGlyph(renderer, beat) {
-            return new TextGlyph(0, 0, beat.text, renderer.resources.effectFont, TextAlign.Left);
+            return new TextGlyph(0, 0, beat.text, renderer.resources.elementFonts.get(exports.NotationElement.EffectText), TextAlign.Left);
         }
         canExpand(_from, _to) {
             return true;
@@ -63493,7 +64262,7 @@
             const textY = cy + this.height;
             const b = canvas.textBaseline;
             canvas.textBaseline = TextBaseline.Bottom;
-            canvas.font = this.renderer.resources.effectFont;
+            canvas.font = this.renderer.resources.elementFonts.get(exports.NotationElement.EffectTripletFeel);
             canvas.fillText('(', cx, textY);
             cx += canvas.measureText('( ').width;
             cx = this._drawGroup(cx, noteY + this._tupletHeight, canvas, leftNotes);
@@ -63735,7 +64504,7 @@
             return beat.hasWhammyBar;
         }
         createNewGlyph(_renderer, _beat) {
-            return new LineRangedGlyph('w/bar');
+            return new LineRangedGlyph('w/bar', exports.NotationElement.EffectWhammyBar);
         }
         canExpand(_from, _to) {
             return true;
@@ -63887,7 +64656,7 @@
     class ChordDiagramContainerGlyph extends RowContainerGlyph {
         addChord(chord) {
             if (chord.strings.length > 0) {
-                const chordDiagram = new ChordDiagramGlyph(0, 0, chord);
+                const chordDiagram = new ChordDiagramGlyph(0, 0, chord, exports.NotationElement.ChordDiagrams);
                 chordDiagram.renderer = this.renderer;
                 chordDiagram.doLayout();
                 this.glyphs.push(chordDiagram);
@@ -63951,7 +64720,7 @@
             this.height = 0;
             // Track name
             if (this._trackLabel.length > 0) {
-                const trackName = new TextGlyph(0, this.height, this._trackLabel, res.effectFont, TextAlign.Left);
+                const trackName = new TextGlyph(0, this.height, this._trackLabel, res.elementFonts.get(exports.NotationElement.GuitarTuning), TextAlign.Left);
                 trackName.renderer = this.renderer;
                 trackName.doLayout();
                 this.height += trackName.height;
@@ -63959,7 +64728,7 @@
             }
             // Name
             if (tuning.name.length > 0) {
-                const tuningName = new TextGlyph(0, this.height, tuning.name, res.effectFont, TextAlign.Left);
+                const tuningName = new TextGlyph(0, this.height, tuning.name, res.elementFonts.get(exports.NotationElement.GuitarTuning), TextAlign.Left);
                 tuningName.renderer = this.renderer;
                 tuningName.doLayout();
                 this.height += tuningName.height;
@@ -63967,7 +64736,7 @@
             }
             const circleScale = this.renderer.smuflMetrics.tuningGlyphCircleNumberScale;
             const circleHeight = this.renderer.smuflMetrics.glyphHeights.get(MusicFontSymbol.GuitarString0) * circleScale;
-            this.renderer.scoreRenderer.canvas.font = res.effectFont;
+            this.renderer.scoreRenderer.canvas.font = res.elementFonts.get(exports.NotationElement.GuitarTuning);
             const stringColumnWidth = (circleHeight + this.renderer.scoreRenderer.canvas.measureText(' = Gb').width) *
                 res.engravingSettings.tuningGlyphStringColumnScale;
             this.width = Math.max(this.renderer.scoreRenderer.canvas.measureText(this._trackLabel).width, Math.max(this.renderer.scoreRenderer.canvas.measureText(tuning.name).width, 2 * stringColumnWidth));
@@ -63981,7 +64750,7 @@
                     const symbol = (MusicFontSymbol.GuitarString0 + (i + 1));
                     this.addGlyph(new MusicFontGlyph(currentX, currentY + circleHeight, circleScale, symbol));
                     const str = ` = ${Tuning.getTextForTuning(tuning.tunings[i], false)}`;
-                    this.addGlyph(new TextGlyph(currentX + circleHeight, currentY + circleHeight / 2, str, res.effectFont, TextAlign.Left, TextBaseline.Middle));
+                    this.addGlyph(new TextGlyph(currentX + circleHeight, currentY + circleHeight / 2, str, res.elementFonts.get(exports.NotationElement.GuitarTuning), TextAlign.Left, TextBaseline.Middle));
                     currentY += circleHeight + this.renderer.smuflMetrics.tuningGlyphStringRowPadding;
                     const bottomY = currentY;
                     if (this.height < bottomY) {
@@ -65033,7 +65802,7 @@
                     let hasAnyTrackName = false;
                     if (shouldRender) {
                         const canvas = this.layout.renderer.canvas;
-                        const res = settings.display.resources.effectFont;
+                        const res = settings.display.resources.elementFonts.get(exports.NotationElement.TrackNames);
                         canvas.font = res;
                         for (const t of tracks) {
                             let trackNameText = '';
@@ -65187,7 +65956,7 @@
                 // Draw track names
                 const settings = this.layout.renderer.settings;
                 const hasTrackName = this.layout.renderer.settings.notation.isNotationElementVisible(exports.NotationElement.TrackNames);
-                canvas.font = res.effectFont;
+                canvas.font = res.elementFonts.get(exports.NotationElement.TrackNames);
                 if (hasTrackName) {
                     const stylesheet = this.layout.renderer.score.stylesheet;
                     const trackNamePolicy = this.layout.renderer.tracks.length === 1
@@ -65531,6 +66300,7 @@
             this.renderer = renderer;
         }
         slurRegistry = new SlurRegistry();
+        beamingRuleLookups = new Map();
         resize() {
             this._lazyPartials.clear();
             this.slurRegistry.clear();
@@ -65539,6 +66309,7 @@
         layoutAndRender() {
             this._lazyPartials.clear();
             this.slurRegistry.clear();
+            this.beamingRuleLookups.clear();
             this._barRendererLookup.clear();
             this.profile = Environment.staveProfiles.get(this.renderer.settings.display.staveProfile);
             const score = this.renderer.score;
@@ -65877,7 +66648,10 @@
             const msg = 'rendered by alphaTab';
             const resources = this.renderer.settings.display.resources;
             const size = 12;
-            const font = Font.withFamilyList(resources.copyrightFont.families, size, FontStyle.Plain, FontWeight.Bold);
+            const fontFamilies = resources.elementFonts.has(exports.NotationElement.ScoreCopyright)
+                ? resources.elementFonts.get(exports.NotationElement.ScoreCopyright).families
+                : resources.tablatureFont.families;
+            const font = Font.withFamilyList(fontFamilies, size, FontStyle.Plain, FontWeight.Bold);
             const fakeBarRenderer = new BarRendererBase(this.renderer, this.renderer.tracks[0].staves[0].bars[0]);
             const glyph = new TextGlyph(0, 0, msg, font, TextAlign.Center, undefined, resources.mainGlyphColor);
             glyph.renderer = fakeBarRenderer;
@@ -66790,13 +67564,7 @@
             this._number = `${num}  `;
         }
         doLayout() {
-            // TODO: activate this and update paddings accordingly.
-            // if (!this.renderer.staff!.isFirstInSystem) {
-            //     this.width = 0;
-            //     this.height = 0;
-            //     return;
-            // }
-            this.renderer.scoreRenderer.canvas.font = this.renderer.resources.barNumberFont;
+            this.renderer.scoreRenderer.canvas.font = this.renderer.resources.elementFonts.get(exports.NotationElement.BarNumber);
             const size = this.renderer.scoreRenderer.canvas.measureText(this._number);
             this.width = size.width;
             this.height = size.height;
@@ -66810,7 +67578,7 @@
             try {
                 const res = this.renderer.resources;
                 const baseline = canvas.textBaseline;
-                canvas.font = res.barNumberFont;
+                canvas.font = res.elementFonts.get(exports.NotationElement.BarNumber);
                 canvas.textBaseline = TextBaseline.Top;
                 canvas.fillText(this._number, cx + this.x, cy + this.y);
                 canvas.textBaseline = baseline;
@@ -67909,7 +68677,7 @@
             this._count = count;
         }
         doLayout() {
-            this.renderer.scoreRenderer.canvas.font = this.renderer.resources.barNumberFont;
+            this.renderer.scoreRenderer.canvas.font = this.renderer.resources.elementFonts.get(exports.NotationElement.RepeatCount);
             const size = this.renderer.scoreRenderer.canvas.measureText(`x${this._count}`);
             this.width = 0; // do not account width
             this.height = size.height;
@@ -67920,7 +68688,7 @@
             try {
                 const res = this.renderer.resources;
                 const oldAlign = canvas.textAlign;
-                canvas.font = res.barNumberFont;
+                canvas.font = res.elementFonts.get(exports.NotationElement.RepeatCount);
                 canvas.textAlign = TextAlign.Right;
                 const s = `x${this._count}`;
                 const w = canvas.measureText(s).width / 1.5;
@@ -68045,11 +68813,12 @@
         }
         createStartSpacing() {
             if (this._startSpacing) {
-                return;
+                return false;
             }
             const padding = this.index === 0 ? this.settings.display.firstStaffPaddingLeft : this.settings.display.staffPaddingLeft;
             this.addPreBeatGlyph(new SpacingGlyph(0, 0, padding));
             this._startSpacing = true;
+            return true;
         }
         paintTuplets(cx, cy, canvas, beatElement, bracketsAsArcs = false) {
             for (const v of this.voiceContainer.voiceDrawOrder) {
@@ -68391,16 +69160,45 @@
             super.createPreBeatGlyphs();
             this.addPreBeatGlyph(new BarLineGlyph(false, this.bar.staff.track.score.stylesheet.extendBarLines));
             this.createLinePreBeatGlyphs();
+            let hasSpaceAfterStartGlyphs = false;
             if (this.index === 0) {
-                this.createStartSpacing();
+                hasSpaceAfterStartGlyphs = this.createStartSpacing();
+            }
+            if (this.shouldCreateBarNumber()) {
+                this.addPreBeatGlyph(new BarNumberGlyph(0, this.getLineHeight(-0.5), this.bar.index + 1));
+            }
+            else if (!hasSpaceAfterStartGlyphs) {
+                this.addPreBeatGlyph(new SpacingGlyph(0, 0, this.smuflMetrics.oneStaffSpace));
+            }
+        }
+        shouldCreateBarNumber() {
+            let display = BarNumberDisplay.AllBars;
+            if (!this.settings.notation.isNotationElementVisible(exports.NotationElement.BarNumber)) {
+                display = BarNumberDisplay.Hide;
+            }
+            else if (this.bar.barNumberDisplay !== undefined) {
+                display = this.bar.barNumberDisplay;
+            }
+            else {
+                display = this.bar.staff.track.score.stylesheet.barNumberDisplay;
+            }
+            switch (display) {
+                case BarNumberDisplay.AllBars:
+                    return true;
+                case BarNumberDisplay.FirstOfSystem:
+                    return this.isFirstOfStaff;
+                case BarNumberDisplay.Hide:
+                    return false;
             }
-            this.addPreBeatGlyph(new BarNumberGlyph(0, this.getLineHeight(-0.5), this.bar.index + 1));
+            return true;
         }
         createPostBeatGlyphs() {
             super.createPostBeatGlyphs();
             const lastBar = this.lastBar;
             this.addPostBeatGlyph(new BarLineGlyph(true, this.bar.staff.track.score.stylesheet.extendBarLines));
-            if (lastBar.masterBar.isRepeatEnd && lastBar.masterBar.repeatCount > 2) {
+            if (lastBar.masterBar.isRepeatEnd &&
+                lastBar.masterBar.repeatCount > 2 &&
+                this.settings.notation.isNotationElementVisible(exports.NotationElement.RepeatCount)) {
                 this.addPostBeatGlyph(new RepeatCountGlyph(0, this.getLineHeight(-0.5), this.bar.masterBar.repeatCount));
             }
         }
@@ -68964,8 +69762,13 @@
                 this.addPreBeatGlyph(new BarLineGlyph(false, this.bar.staff.track.score.stylesheet.extendBarLines));
             }
             this.createLinePreBeatGlyphs();
-            this.createStartSpacing();
-            this.addPreBeatGlyph(new BarNumberGlyph(0, this.getLineHeight(-0.5), this.bar.index + 1));
+            const hasSpaceAfterStartGlyphs = this.createStartSpacing();
+            if (this.shouldCreateBarNumber()) {
+                this.addPreBeatGlyph(new BarNumberGlyph(0, this.getLineHeight(-0.5), this.bar.index + 1));
+            }
+            else if (!hasSpaceAfterStartGlyphs) {
+                this.addPreBeatGlyph(new SpacingGlyph(0, 0, this.smuflMetrics.oneStaffSpace));
+            }
         }
         createLinePreBeatGlyphs() {
             if (this._isOnlyNumbered &&
@@ -71513,7 +72316,7 @@
                 if (note.bendStyle === BendStyle.Gradual) {
                     const res = this.renderer.resources;
                     const c = this.renderer.scoreRenderer.canvas;
-                    c.font = res.barNumberFont; // see note in paint()
+                    c.font = res.elementFonts.get(exports.NotationElement.ScoreBendSlur);
                     slurHeight += c.measureText('grad.').height;
                 }
                 if (slurHeight > maxSlurHeight) {
@@ -71613,11 +72416,16 @@
             this._notes.sort((a, b) => {
                 return b.displayValue - a.displayValue;
             });
+            // draw slurs
+            if (this.renderer.settings.notation.isNotationElementVisible(exports.NotationElement.ScoreBendSlur)) {
+                this._paintSlurs(cx, cy, canvas, startNoteRenderer, startX, middleX, endBeatX);
+            }
+        }
+        _paintSlurs(cx, cy, canvas, startNoteRenderer, startX, middleX, endBeatX) {
             const directionBeat = this._beat.graceType === GraceType.BendGrace ? this._beat.nextBeat : this._beat;
             let direction = this._notes.length === 1 ? this.getTieDirection(directionBeat, startNoteRenderer) : BeamDirection.Up;
             const noteHeadHeight = this.renderer.smuflMetrics.glyphHeights.get(MusicFontSymbol.NoteheadBlack);
-            // draw slurs
-            canvas.font = this.renderer.resources.barNumberFont; // we have never have set it explicitly, that's the current state
+            canvas.font = this.renderer.resources.elementFonts.get(exports.NotationElement.ScoreBendSlur);
             for (let i = 0; i < this._notes.length; i++) {
                 const note = this._notes[i];
                 const _ = ElementStyleHelper.note(canvas, NoteSubElement.StandardNotationEffects, note);
@@ -77689,6 +78497,9 @@
             key.addElement('Sharps').innerText = 'Sharps';
             masterBarNode.addElement('Time').innerText =
                 `${masterBar.timeSignatureNumerator}/${masterBar.timeSignatureDenominator}`;
+            if (masterBar.actualBeamingRules) {
+                this._writeBarXProperties(masterBarNode, masterBar);
+            }
             if (masterBar.isFreeTime) {
                 masterBarNode.addElement('FreeTime');
             }
@@ -77798,6 +78609,29 @@
             }
             this._writeFermatas(masterBarNode, masterBar);
         }
+        _writeBarXProperties(masterBarNode, masterBar) {
+            const properties = masterBarNode.addElement('XProperties');
+            const beamingRules = masterBar.actualBeamingRules;
+            if (beamingRules) {
+                // prefer 8th note rule (that's what GP mostly has)
+                const rule = beamingRules.findRule(Duration.Eighth);
+                // NOTE: it's not clear if guitar pro supports quarter rules
+                // for that case we better convert this to an "8th" note rule.
+                let durationProp = rule[0];
+                let groupSizeFactor = 1;
+                if (rule[0] === Duration.Quarter) {
+                    durationProp = 8;
+                    groupSizeFactor = 2;
+                }
+                this._writeSimpleXPropertyNode(properties, '1124139010', 'Int', durationProp.toString());
+                const startGroupid = 1124139264;
+                let i = 0;
+                while (i < rule[1].length) {
+                    this._writeSimpleXPropertyNode(properties, (startGroupid + i).toString(), 'Int', (rule[1][i] * groupSizeFactor).toString());
+                    i++;
+                }
+            }
+        }
         _writeFermatas(parent, masterBar) {
             const fermataCount = masterBar.fermata?.size ?? 0;
             if (fermataCount === 0) {
@@ -79746,6 +80580,7 @@
         BackingTrack,
         Bar,
         get BarLineStyle () { return BarLineStyle; },
+        get BarNumberDisplay () { return BarNumberDisplay; },
         BarStyle,
         get BarSubElement () { return BarSubElement; },
         get BarreShape () { return BarreShape; },