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

package/dist/alphaTab.core.mjs

@@ -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.
  *
@@ -203,9 +203,9 @@ class AlphaTabError extends Error {
  * @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}`);
@@ -1315,6 +1315,23 @@ var NotationElement;
      * 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";
 })(NotationElement || (NotationElement = {}));
 /**
  * The notation settings control how various music notation elements are shown and behaving
@@ -2174,6 +2191,17 @@ class Bar {
      * 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.
@@ -2245,12 +2273,16 @@ class Bar {
         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;
@@ -2347,6 +2379,116 @@ var TripletFeel;
     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.
@@ -2464,6 +2606,16 @@ class MasterBar {
      * 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.
      */
@@ -2596,6 +2748,32 @@ class MasterBar {
         }
         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);
+        }
+    }
 }
 
 /**
@@ -2668,6 +2846,25 @@ var TrackNameOrientation;
      */
     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.
@@ -2761,6 +2958,10 @@ class RenderStylesheet {
      * {@link hideEmptyStaves}
      */
     showSingleStaffBrackets = false;
+    /**
+     * How bar numbers should be displayed.
+     */
+    barNumberDisplay = BarNumberDisplay.AllBars;
 }
 
 /**
@@ -2923,6 +3124,12 @@ let Voice$1 = class Voice {
     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) {
@@ -3016,6 +3223,7 @@ let Voice$1 = class Voice {
         }
         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;
@@ -3024,6 +3232,9 @@ let Voice$1 = class Voice {
             // 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];
@@ -3484,7 +3695,7 @@ class Score {
             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 +
@@ -3548,9 +3759,7 @@ class Score {
         }
         // 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);
         }
     }
     /**
@@ -8432,6 +8641,12 @@ class AlphaTex1EnumMappings {
         ['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'],
@@ -8626,7 +8841,8 @@ class AlphaTex1LanguageDefinitions {
         ['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]]]],
@@ -8911,7 +9127,17 @@ class AlphaTex1LanguageDefinitions {
         ['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([
         [
@@ -8969,6 +9195,7 @@ class AlphaTex1LanguageDefinitions {
         ['hideemptystaves', null],
         ['hideemptystavesinfirstsystem', null],
         ['showsinglestaffbrackets', null],
+        ['defaultbarnumberdisplay', null],
         [
             'tuning',
             [
@@ -9025,7 +9252,9 @@ class AlphaTex1LanguageDefinitions {
         ['sph', null],
         ['spu', null],
         ['db', null],
-        ['voicemode', null]
+        ['voicemode', null],
+        ['barnumberdisplay', null],
+        ['beaming', null]
     ]);
     static metaDataSignatures = [
         AlphaTex1LanguageDefinitions.scoreMetaDataSignatures,
@@ -12740,6 +12969,7 @@ var BeamDirection;
  */
 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) {
@@ -12876,6 +13106,13 @@ class AlphaTex1LanguageHandler {
             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;
         }
@@ -13154,8 +13391,29 @@ class AlphaTex1LanguageHandler {
             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:
@@ -13178,6 +13436,8 @@ class AlphaTex1LanguageHandler {
                         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) {
@@ -13367,10 +13627,64 @@ class AlphaTex1LanguageHandler {
                 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) {
@@ -14734,6 +15048,9 @@ class AlphaTex1LanguageHandler {
         if (stylesheet.showSingleStaffBrackets) {
             nodes.push(Atnf.meta('showSingleStaffBrackets'));
         }
+        if (stylesheet.barNumberDisplay !== BarNumberDisplay.AllBars) {
+            nodes.push(Atnf.identMeta('defaultBarNumberDisplay', BarNumberDisplay[stylesheet.barNumberDisplay]));
+        }
         // Unsupported:
         // 'globaldisplaychorddiagramsontop',
         // 'pertrackchorddiagramsontop',
@@ -14867,6 +15184,9 @@ class AlphaTex1LanguageHandler {
                 }
             ];
         }
+        if (bar.barNumberDisplay !== undefined) {
+            nodes.push(Atnf.identMeta('barNumberDisplay', BarNumberDisplay[bar.barNumberDisplay]));
+        }
         return nodes;
     }
     static _buildStaffMetaDataNodes(nodes, staff) {
@@ -14957,6 +15277,15 @@ class AlphaTex1LanguageHandler {
                 ])));
             }
         }
+        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)));
@@ -19535,6 +19864,10 @@ class Gp3To5Importer extends ScoreImporter {
             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);
@@ -19615,11 +19948,11 @@ class Gp3To5Importer extends ScoreImporter {
             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);
@@ -19651,11 +19984,11 @@ class Gp3To5Importer extends ScoreImporter {
             }
         }
         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);
             }
         }
     }
@@ -20929,6 +21262,19 @@ class BinaryStylesheet {
                     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;
             }
         }
     }
@@ -21118,6 +21464,17 @@ class BinaryStylesheet {
                 }
             }
         }
+        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();
@@ -22929,6 +23286,8 @@ class GpifParser {
         }
     }
     _parseMasterBarXProperties(masterBar, node) {
+        let beamingRuleDuration = Number.NaN;
+        let beamingRuleGroups = undefined;
         for (const c of node.childElements()) {
             switch (c.localName) {
                 case 'XProperty':
@@ -22937,10 +23296,32 @@ class GpifParser {
                         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;
@@ -24824,6 +25205,8 @@ class MusicXmlImporter extends ScoreImporter {
     _idToTrackInfo = new Map();
     _indexToTrackInfo = new Map();
     _staffToContext = new Map();
+    _currentBarNumberDisplayPart;
+    _currentBarNumberDisplayBar;
     _divisionsPerQuarterNote = 1;
     _currentDynamics = DynamicValue.F;
     get name() {
@@ -25437,20 +25820,29 @@ class MusicXmlImporter extends ScoreImporter {
                     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';
@@ -25469,13 +25861,13 @@ class MusicXmlImporter extends ScoreImporter {
         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
     /**
@@ -25487,7 +25879,7 @@ class MusicXmlImporter extends ScoreImporter {
      * 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;
@@ -25514,7 +25906,7 @@ class MusicXmlImporter extends ScoreImporter {
                     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);
@@ -25535,16 +25927,51 @@ class MusicXmlImporter extends ScoreImporter {
         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) {
@@ -26654,7 +27081,7 @@ class MusicXmlImporter extends ScoreImporter {
         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);
@@ -29583,7 +30010,7 @@ class MidiFileSequencer {
             }
             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));
             }
@@ -29701,7 +30128,7 @@ class MidiFileSequencer {
                 }
                 else {
                     const previousSyncPoint = syncPoints[i - 1];
-                    previousModifiedTempo = previousSyncPoint.syncBpm;
+                    previousModifiedTempo = MidiFileSequencer._sanitizeBpm(previousSyncPoint.syncBpm);
                     previousMillisecondOffset = previousSyncPoint.syncTime;
                     previousTick = previousSyncPoint.synthTick;
                 }
@@ -29725,7 +30152,7 @@ class MidiFileSequencer {
                         syncPoint.syncTime = interpolatedMillisecondOffset;
                         syncPoint.syncBpm = previousModifiedTempo;
                     }
-                    bpm = state.tempoChanges[tempoChangeIndex].bpm;
+                    bpm = MidiFileSequencer._sanitizeBpm(state.tempoChanges[tempoChangeIndex].bpm);
                     tempoChangeIndex++;
                 }
                 deltaTick = p.synthTick - absTick;
@@ -29746,10 +30173,13 @@ class MidiFileSequencer {
         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);
     }
@@ -36427,6 +36857,43 @@ class JsonHelper {
     }
 }
 
+/**
+ * @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
  */
@@ -36605,6 +37072,9 @@ class MasterBarSerializer {
         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) {
@@ -36657,6 +37127,15 @@ class MasterBarSerializer {
             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;
@@ -37481,6 +37960,7 @@ class BarSerializer {
         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));
         }
@@ -37534,6 +38014,9 @@ class BarSerializer {
             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();
@@ -38028,6 +38511,7 @@ class RenderStylesheetSerializer {
         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) {
@@ -38098,6 +38582,9 @@ class RenderStylesheetSerializer {
             case "showsinglestaffbrackets":
                 obj.showSingleStaffBrackets = v;
                 return true;
+            case "barnumberdisplay":
+                obj.barNumberDisplay = JsonHelper.parseEnum(v, BarNumberDisplay);
+                return true;
         }
         return false;
     }
@@ -41829,25 +42316,20 @@ class RenderingResourcesSerializer {
         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));
@@ -41858,29 +42340,10 @@ class RenderingResourcesSerializer {
             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, NotationElement), Font.fromJson(v));
+                });
                 return true;
             case "numberednotationfont":
                 obj.numberedNotationFont = Font.fromJson(v);
@@ -41900,21 +42363,9 @@ class RenderingResourcesSerializer {
             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;
@@ -41971,6 +42422,46 @@ var StaveProfile;
 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([
+        [NotationElement.ScoreTitle, new Font(RenderingResources._serifFont, 32, FontStyle.Plain)],
+        [NotationElement.ScoreSubTitle, new Font(RenderingResources._serifFont, 20, FontStyle.Plain)],
+        [NotationElement.ScoreArtist, new Font(RenderingResources._serifFont, 20, FontStyle.Plain)],
+        [NotationElement.ScoreAlbum, new Font(RenderingResources._serifFont, 20, FontStyle.Plain)],
+        [NotationElement.ScoreWords, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+        [NotationElement.ScoreMusic, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+        [NotationElement.ScoreWordsAndMusic, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)],
+        [NotationElement.ScoreCopyright, new Font(RenderingResources._sansFont, 12, FontStyle.Plain, FontWeight.Bold)],
+        [NotationElement.EffectBeatTimer, new Font(RenderingResources._serifFont, 12, FontStyle.Plain)],
+        [NotationElement.EffectDirections, new Font(RenderingResources._serifFont, 14, FontStyle.Plain)],
+        [NotationElement.ChordDiagramFretboardNumbers, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+        [NotationElement.EffectFingering, new Font(RenderingResources._serifFont, 14, FontStyle.Plain)],
+        [NotationElement.EffectMarker, new Font(RenderingResources._serifFont, 14, FontStyle.Plain, FontWeight.Bold)],
+        [NotationElement.EffectCapo, RenderingResources._effectFont],
+        [NotationElement.EffectFreeTime, RenderingResources._effectFont],
+        [NotationElement.EffectLyrics, RenderingResources._effectFont],
+        [NotationElement.EffectTap, RenderingResources._effectFont],
+        [NotationElement.ChordDiagrams, RenderingResources._effectFont],
+        [NotationElement.EffectChordNames, RenderingResources._effectFont],
+        [NotationElement.EffectText, RenderingResources._effectFont],
+        [NotationElement.EffectPalmMute, RenderingResources._effectFont],
+        [NotationElement.EffectLetRing, RenderingResources._effectFont],
+        [NotationElement.EffectBeatBarre, RenderingResources._effectFont],
+        [NotationElement.EffectTripletFeel, RenderingResources._effectFont],
+        [NotationElement.EffectHarmonics, RenderingResources._effectFont],
+        [NotationElement.EffectPickSlide, RenderingResources._effectFont],
+        [NotationElement.GuitarTuning, RenderingResources._effectFont],
+        [NotationElement.EffectRasgueado, RenderingResources._effectFont],
+        [NotationElement.EffectWhammyBar, RenderingResources._effectFont],
+        [NotationElement.TrackNames, RenderingResources._effectFont],
+        [NotationElement.RepeatCount, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+        [NotationElement.BarNumber, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+        [NotationElement.ScoreBendSlur, new Font(RenderingResources._sansFont, 11, FontStyle.Plain)],
+        [NotationElement.EffectAlternateEndings, new Font(RenderingResources._serifFont, 15, FontStyle.Plain)]
+    ]);
     /**
      * The name of the SMuFL Font to use for rendering music symbols.
      *
@@ -41997,50 +42488,168 @@ class RenderingResources {
      * 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(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(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(NotationElement.ScoreTitle);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreTitle}
      */
-    titleFont = new Font(RenderingResources._serifFont, 32, FontStyle.Plain);
+    set titleFont(value) {
+        this.elementFonts.set(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(NotationElement.ScoreSubTitle);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.ScoreSubTitle}
+     */
+    set subTitleFont(value) {
+        this.elementFonts.set(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(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(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(NotationElement.EffectBeatTimer);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.EffectBeatTimer}
+     */
+    set timerFont(value) {
+        this.elementFonts.set(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(NotationElement.EffectDirections);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.EffectDirections}
+     */
+    set directionsFont(value) {
+        this.elementFonts.set(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(NotationElement.ChordDiagramFretboardNumbers);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.ChordDiagramFretboardNumbers}
+     */
+    set fretboardNumberFont(value) {
+        this.elementFonts.set(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(NotationElement.EffectMarker);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.EffectMarker}
+     */
+    set markerFont(value) {
+        this.elementFonts.set(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(NotationElement.BarNumber);
+    }
+    /**
+     * @deprecated use {@link elementFonts} with {@link NotationElement.BarNumber}
+     */
+    set barNumberFont(value) {
+        this.elementFonts.set(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`
@@ -42077,38 +42686,12 @@ class RenderingResources {
      * @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)`
@@ -42127,28 +42710,50 @@ class RenderingResources {
      * @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 = NotationElement.ScoreWords;
         switch (element) {
             case ScoreSubElement.Title:
-                return this.titleFont;
+                notationElement = NotationElement.ScoreTitle;
+                break;
             case ScoreSubElement.SubTitle:
+                notationElement = NotationElement.ScoreSubTitle;
+                break;
             case ScoreSubElement.Artist:
+                notationElement = NotationElement.ScoreArtist;
+                break;
             case ScoreSubElement.Album:
-                return this.subTitleFont;
+                notationElement = NotationElement.ScoreAlbum;
+                break;
             case ScoreSubElement.Words:
+                notationElement = NotationElement.ScoreWords;
+                break;
             case ScoreSubElement.Music:
+                notationElement = NotationElement.ScoreMusic;
+                break;
             case ScoreSubElement.WordsAndMusic:
-            case ScoreSubElement.Transcriber:
-                return this.wordsFont;
+                notationElement = NotationElement.ScoreWordsAndMusic;
+                break;
             case ScoreSubElement.Copyright:
             case ScoreSubElement.CopyrightSecondLine:
-                return this.copyrightFont;
+                notationElement = NotationElement.ScoreCopyright;
+                break;
+            default:
+                notationElement = NotationElement.ScoreWords;
+                break;
         }
-        return this.wordsFont;
+        return this.elementFonts.has(notationElement)
+            ? this.elementFonts.get(notationElement)
+            : RenderingResources.defaultFonts.get(NotationElement.ScoreWords);
     }
 }
 
@@ -42453,6 +43058,13 @@ class DisplaySettings {
      * @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
@@ -42563,6 +43175,7 @@ class DisplaySettingsSerializer {
         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;
     }
@@ -42649,6 +43262,9 @@ class DisplaySettingsSerializer {
             case "trackstaffpaddingbetween":
                 obj.trackStaffPaddingBetween = v;
                 return true;
+            case "lyriclinespaddingbetween":
+                obj.lyricLinesPaddingBetween = v;
+                return true;
             case "systemslayoutmode":
                 obj.systemsLayoutMode = JsonHelper.parseEnum(v, SystemsLayoutMode);
                 return true;
@@ -55357,23 +55973,20 @@ class BrowserUiFacade {
         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(', '))) {
@@ -57210,7 +57823,9 @@ class AlternateEndingsGlyph extends EffectGlyph {
     }
     doLayout() {
         super.doLayout();
-        this.height = this.renderer.resources.wordsFont.size + this.renderer.smuflMetrics.alternateEndingsPadding * 2;
+        this.height =
+            this.renderer.resources.elementFonts.get(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;
@@ -57246,7 +57861,7 @@ class AlternateEndingsGlyph extends EffectGlyph {
             const baseline = canvas.textBaseline;
             canvas.textBaseline = TextBaseline.Top;
             const res = this.renderer.resources;
-            canvas.font = res.wordsFont;
+            canvas.font = res.elementFonts.get(NotationElement.EffectAlternateEndings);
             canvas.fillText(this._endingsString, cx + this.x + this.renderer.smuflMetrics.alternateEndingsPadding, cy + this.y + this.renderer.smuflMetrics.alternateEndingsPadding);
             canvas.textBaseline = baseline;
         }
@@ -57388,10 +58003,12 @@ class LineRangedGlyph extends GroupedEffectGlyph {
     _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) {
@@ -57399,14 +58016,14 @@ class LineRangedGlyph extends GroupedEffectGlyph {
             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);
@@ -57467,7 +58084,7 @@ class BeatBarreEffectInfo extends EffectInfo {
                 break;
         }
         barre += `B ${BeatBarreEffectInfo.toRoman(beat.barreFret)}`;
-        return new LineRangedGlyph(barre, false);
+        return new LineRangedGlyph(barre, NotationElement.EffectBeatBarre, false);
     }
     static _romanLetters = new Map([
         // ['M', 1000],
@@ -57517,7 +58134,7 @@ class BeatTimerGlyph extends EffectGlyph {
         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(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;
@@ -57529,7 +58146,7 @@ class BeatTimerGlyph extends EffectGlyph {
         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(NotationElement.EffectBeatTimer);
         canvas.textBaseline = TextBaseline.Middle;
         canvas.textAlign = TextAlign.Center;
         canvas.fillText(this._text, cx + this.x, cy + this.y + this.height / 2);
@@ -57638,7 +58255,7 @@ class CapoEffectInfo extends EffectInfo {
         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(NotationElement.EffectCapo), TextAlign.Left);
     }
     canExpand(_from, _to) {
         return false;
@@ -57655,31 +58272,41 @@ class ChordDiagramGlyph extends EffectGlyph {
     _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(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;
@@ -57687,25 +58314,35 @@ class ChordDiagramGlyph extends EffectGlyph {
         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(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(NotationElement.ChordDiagramFretboardNumbers);
         canvas.textBaseline = TextBaseline.Middle;
         for (let i = 0; i < this._chord.strings.length; i++) {
             const x = cx + i * stringSpacing;
@@ -57768,8 +58405,6 @@ class ChordDiagramGlyph extends EffectGlyph {
             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;
     }
 }
 
@@ -57795,8 +58430,8 @@ class ChordsEffectInfo extends EffectInfo {
     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, NotationElement.EffectChordNames, true)
+            : new TextGlyph(0, 0, beat.chord.name, renderer.resources.elementFonts.get(NotationElement.EffectChordNames), TextAlign.Center);
     }
     canExpand(_from, _to) {
         return false;
@@ -57907,14 +58542,14 @@ class JumpDirectionGlyph extends Glyph {
     }
     doLayout() {
         const c = this.renderer.scoreRenderer.canvas;
-        c.font = this.renderer.resources.directionsFont;
+        c.font = this.renderer.resources.elementFonts.get(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(NotationElement.EffectDirections);
         canvas.textBaseline = TextBaseline.Middle;
         canvas.textAlign = TextAlign.Right;
         canvas.fillText(this._text, cx + this.x, cy + this.y + this.height / 2);
@@ -58810,7 +59445,7 @@ class FreeTimeEffectInfo extends EffectInfo {
             (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(NotationElement.EffectFreeTime), TextAlign.Left);
     }
     canExpand(_from, _to) {
         return true;
@@ -58948,7 +59583,7 @@ class HarmonicsEffectInfo extends NoteEffectInfoBase {
         return EffectBarGlyphSizing.GroupedOnBeat;
     }
     createNewGlyph(_renderer, _beat) {
-        return new LineRangedGlyph(HarmonicsEffectInfo.harmonicToString(this._harmonicType));
+        return new LineRangedGlyph(HarmonicsEffectInfo.harmonicToString(this._harmonicType), NotationElement.EffectHarmonics);
     }
     static harmonicToString(type) {
         switch (type) {
@@ -59021,7 +59656,7 @@ class LetRingEffectInfo extends EffectInfo {
         return EffectBarGlyphSizing.GroupedOnBeat;
     }
     createNewGlyph(_renderer, _beat) {
-        return new LineRangedGlyph('LetRing');
+        return new LineRangedGlyph('LetRing', NotationElement.EffectLetRing);
     }
     canExpand(_from, _to) {
         return true;
@@ -59033,6 +59668,7 @@ class LetRingEffectInfo extends EffectInfo {
  */
 class LyricsGlyph extends EffectGlyph {
     _lines;
+    _linePositions = [];
     font;
     textAlign;
     constructor(x, y, lines, font, textAlign = TextAlign.Center) {
@@ -59043,7 +59679,17 @@ class LyricsGlyph extends EffectGlyph {
     }
     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;
@@ -59051,7 +59697,7 @@ class LyricsGlyph extends EffectGlyph {
         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;
@@ -59078,7 +59724,7 @@ class LyricsEffectInfo extends EffectInfo {
         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(NotationElement.EffectLyrics), TextAlign.Center);
     }
     canExpand(_from, _to) {
         return true;
@@ -59110,7 +59756,7 @@ class MarkerEffectInfo extends EffectInfo {
     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(NotationElement.EffectMarker), TextAlign.Left);
     }
     canExpand(_from, _to) {
         return true;
@@ -59549,7 +60195,7 @@ class PalmMuteEffectInfo extends NoteEffectInfoBase {
         return EffectBarGlyphSizing.GroupedOnBeat;
     }
     createNewGlyph(_renderer, _beat) {
-        return new LineRangedGlyph('P.M.');
+        return new LineRangedGlyph('P.M.', NotationElement.EffectPalmMute);
     }
 }
 
@@ -59567,7 +60213,7 @@ class PickSlideEffectInfo extends NoteEffectInfoBase {
         return EffectBarGlyphSizing.GroupedOnBeat;
     }
     createNewGlyph(_renderer, _beat) {
-        return new LineRangedGlyph('P.S.');
+        return new LineRangedGlyph('P.S.', NotationElement.EffectPickSlide);
     }
 }
 
@@ -59642,7 +60288,7 @@ class RasgueadoEffectInfo extends EffectInfo {
         return EffectBarGlyphSizing.GroupedOnBeat;
     }
     createNewGlyph(_renderer, _beat) {
-        return new LineRangedGlyph('rasg.');
+        return new LineRangedGlyph('rasg.', NotationElement.EffectRasgueado);
     }
     canExpand(_from, _to) {
         return true;
@@ -61148,6 +61794,7 @@ class BeamingHelperDrawInfo {
 class BeamingHelper {
     _staff;
     _renderer;
+    _beamingRuleLookup;
     voice = null;
     beats = [];
     shortestDuration = Duration.QuadrupleWhole;
@@ -61181,10 +61828,11 @@ class BeamingHelper {
     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()) {
@@ -61239,7 +61887,7 @@ class BeamingHelper {
             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;
@@ -61311,8 +61959,7 @@ class BeamingHelper {
             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 ||
@@ -61350,19 +61997,10 @@ class BeamingHelper {
                 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) {
@@ -61529,6 +62167,61 @@ class BarCollisionHelper {
     }
 }
 
+/**
+ * @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
  */
@@ -61545,6 +62238,19 @@ class BarHelpers {
     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++) {
@@ -61570,7 +62276,7 @@ class BarHelpers {
                         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) {
@@ -61593,6 +62299,69 @@ class BarHelpers {
             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;
     }
@@ -63250,12 +64019,12 @@ class TapEffectInfo extends EffectInfo {
     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(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(NotationElement.EffectTap), TextAlign.Center);
         }
-        return new TextGlyph(0, 0, 'T', res.effectFont, TextAlign.Center);
+        return new TextGlyph(0, 0, 'T', res.elementFonts.get(NotationElement.EffectTap), TextAlign.Center);
     }
     canExpand(_from, _to) {
         return true;
@@ -63284,7 +64053,7 @@ class BarTempoGlyph extends EffectGlyph {
         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(NotationElement.EffectMarker);
             const notePosY = cy +
                 this.y +
                 this.height +
@@ -63362,7 +64131,7 @@ class TextEffectInfo extends EffectInfo {
         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(NotationElement.EffectText), TextAlign.Left);
     }
     canExpand(_from, _to) {
         return true;
@@ -63487,7 +64256,7 @@ class TripletFeelGlyph extends EffectGlyph {
         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(NotationElement.EffectTripletFeel);
         canvas.fillText('(', cx, textY);
         cx += canvas.measureText('( ').width;
         cx = this._drawGroup(cx, noteY + this._tupletHeight, canvas, leftNotes);
@@ -63729,7 +64498,7 @@ class WhammyBarEffectInfo extends EffectInfo {
         return beat.hasWhammyBar;
     }
     createNewGlyph(_renderer, _beat) {
-        return new LineRangedGlyph('w/bar');
+        return new LineRangedGlyph('w/bar', NotationElement.EffectWhammyBar);
     }
     canExpand(_from, _to) {
         return true;
@@ -63881,7 +64650,7 @@ class RowContainerGlyph extends GlyphGroup {
 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, NotationElement.ChordDiagrams);
             chordDiagram.renderer = this.renderer;
             chordDiagram.doLayout();
             this.glyphs.push(chordDiagram);
@@ -63945,7 +64714,7 @@ class TuningGlyph extends GlyphGroup {
         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(NotationElement.GuitarTuning), TextAlign.Left);
             trackName.renderer = this.renderer;
             trackName.doLayout();
             this.height += trackName.height;
@@ -63953,7 +64722,7 @@ class TuningGlyph extends GlyphGroup {
         }
         // 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(NotationElement.GuitarTuning), TextAlign.Left);
             tuningName.renderer = this.renderer;
             tuningName.doLayout();
             this.height += tuningName.height;
@@ -63961,7 +64730,7 @@ class TuningGlyph extends GlyphGroup {
         }
         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(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));
@@ -63975,7 +64744,7 @@ class TuningGlyph extends GlyphGroup {
                 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(NotationElement.GuitarTuning), TextAlign.Left, TextBaseline.Middle));
                 currentY += circleHeight + this.renderer.smuflMetrics.tuningGlyphStringRowPadding;
                 const bottomY = currentY;
                 if (this.height < bottomY) {
@@ -65027,7 +65796,7 @@ class StaffSystem {
                 let hasAnyTrackName = false;
                 if (shouldRender) {
                     const canvas = this.layout.renderer.canvas;
-                    const res = settings.display.resources.effectFont;
+                    const res = settings.display.resources.elementFonts.get(NotationElement.TrackNames);
                     canvas.font = res;
                     for (const t of tracks) {
                         let trackNameText = '';
@@ -65181,7 +65950,7 @@ class StaffSystem {
             // Draw track names
             const settings = this.layout.renderer.settings;
             const hasTrackName = this.layout.renderer.settings.notation.isNotationElementVisible(NotationElement.TrackNames);
-            canvas.font = res.effectFont;
+            canvas.font = res.elementFonts.get(NotationElement.TrackNames);
             if (hasTrackName) {
                 const stylesheet = this.layout.renderer.score.stylesheet;
                 const trackNamePolicy = this.layout.renderer.tracks.length === 1
@@ -65525,6 +66294,7 @@ class ScoreLayout {
         this.renderer = renderer;
     }
     slurRegistry = new SlurRegistry();
+    beamingRuleLookups = new Map();
     resize() {
         this._lazyPartials.clear();
         this.slurRegistry.clear();
@@ -65533,6 +66303,7 @@ class ScoreLayout {
     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;
@@ -65871,7 +66642,10 @@ class ScoreLayout {
         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(NotationElement.ScoreCopyright)
+            ? resources.elementFonts.get(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;
@@ -66784,13 +67558,7 @@ class BarNumberGlyph extends Glyph {
         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(NotationElement.BarNumber);
         const size = this.renderer.scoreRenderer.canvas.measureText(this._number);
         this.width = size.width;
         this.height = size.height;
@@ -66804,7 +67572,7 @@ class BarNumberGlyph extends Glyph {
         try {
             const res = this.renderer.resources;
             const baseline = canvas.textBaseline;
-            canvas.font = res.barNumberFont;
+            canvas.font = res.elementFonts.get(NotationElement.BarNumber);
             canvas.textBaseline = TextBaseline.Top;
             canvas.fillText(this._number, cx + this.x, cy + this.y);
             canvas.textBaseline = baseline;
@@ -67903,7 +68671,7 @@ class RepeatCountGlyph extends Glyph {
         this._count = count;
     }
     doLayout() {
-        this.renderer.scoreRenderer.canvas.font = this.renderer.resources.barNumberFont;
+        this.renderer.scoreRenderer.canvas.font = this.renderer.resources.elementFonts.get(NotationElement.RepeatCount);
         const size = this.renderer.scoreRenderer.canvas.measureText(`x${this._count}`);
         this.width = 0; // do not account width
         this.height = size.height;
@@ -67914,7 +68682,7 @@ class RepeatCountGlyph extends Glyph {
         try {
             const res = this.renderer.resources;
             const oldAlign = canvas.textAlign;
-            canvas.font = res.barNumberFont;
+            canvas.font = res.elementFonts.get(NotationElement.RepeatCount);
             canvas.textAlign = TextAlign.Right;
             const s = `x${this._count}`;
             const w = canvas.measureText(s).width / 1.5;
@@ -68039,11 +68807,12 @@ class LineBarRenderer extends BarRendererBase {
     }
     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) {
@@ -68385,16 +69154,45 @@ class LineBarRenderer extends BarRendererBase {
         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(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(NotationElement.RepeatCount)) {
             this.addPostBeatGlyph(new RepeatCountGlyph(0, this.getLineHeight(-0.5), this.bar.masterBar.repeatCount));
         }
     }
@@ -68958,8 +69756,13 @@ class NumberedBarRenderer extends LineBarRenderer {
             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 &&
@@ -71507,7 +72310,7 @@ class ScoreBendGlyph extends ScoreHelperNotesBaseGlyph {
             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(NotationElement.ScoreBendSlur);
                 slurHeight += c.measureText('grad.').height;
             }
             if (slurHeight > maxSlurHeight) {
@@ -71607,11 +72410,16 @@ class ScoreBendGlyph extends ScoreHelperNotesBaseGlyph {
         this._notes.sort((a, b) => {
             return b.displayValue - a.displayValue;
         });
+        // draw slurs
+        if (this.renderer.settings.notation.isNotationElementVisible(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(NotationElement.ScoreBendSlur);
         for (let i = 0; i < this._notes.length; i++) {
             const note = this._notes[i];
             const _ = ElementStyleHelper.note(canvas, NoteSubElement.StandardNotationEffects, note);
@@ -77683,6 +78491,9 @@ class GpifWriter {
         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');
         }
@@ -77792,6 +78603,29 @@ class GpifWriter {
         }
         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) {
@@ -79740,6 +80574,7 @@ const _barrel$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty(
     BackingTrack,
     Bar,
     get BarLineStyle () { return BarLineStyle; },
+    get BarNumberDisplay () { return BarNumberDisplay; },
     BarStyle,
     get BarSubElement () { return BarSubElement; },
     get BarreShape () { return BarreShape; },