@coderline/alphatab 1.3.0-alpha.518 → 1.3.0-alpha.519

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /**
- * alphaTab v1.3.0-alpha.518 (develop, build 518)
+ * alphaTab v1.3.0-alpha.519 (develop, build 519)
  * 
  * Copyright © 2023, Daniel Kuschny and Contributors, All rights reserved.
  * 
@@ -3887,11 +3887,11 @@
                             points.splice(1, 1);
                         }
                         else {
-                            Logger.warning('Model', 'Unsupported whammy type detected, fallback to custom', null);
+                            Logger.warning('Model', 'Unsupported whammy type detected, fallback to custom');
                         }
                     }
                     else {
-                        Logger.warning('Model', 'Unsupported whammy type detected, fallback to custom', null);
+                        Logger.warning('Model', 'Unsupported whammy type detected, fallback to custom');
                     }
                 }
             }
@@ -5686,39 +5686,35 @@
         AlphaTexSymbols[AlphaTexSymbols["MetaCommand"] = 12] = "MetaCommand";
         AlphaTexSymbols[AlphaTexSymbols["Multiply"] = 13] = "Multiply";
         AlphaTexSymbols[AlphaTexSymbols["LowerThan"] = 14] = "LowerThan";
-        AlphaTexSymbols[AlphaTexSymbols["Property"] = 15] = "Property";
     })(AlphaTexSymbols || (AlphaTexSymbols = {}));
     class AlphaTexError extends AlphaTabError {
-        constructor(message) {
+        constructor(message, position, line, col, nonTerm, expected, symbol, symbolData = null) {
             super(exports.AlphaTabErrorType.AlphaTex, message);
-            this.position = 0;
-            this.nonTerm = '';
-            this.expected = AlphaTexSymbols.No;
-            this.symbol = AlphaTexSymbols.No;
-            this.symbolData = null;
+            this.position = position;
+            this.line = line;
+            this.col = col;
+            this.nonTerm = nonTerm !== null && nonTerm !== void 0 ? nonTerm : '';
+            this.expected = expected !== null && expected !== void 0 ? expected : AlphaTexSymbols.No;
+            this.symbol = symbol !== null && symbol !== void 0 ? symbol : AlphaTexSymbols.No;
+            this.symbolData = symbolData;
             Object.setPrototypeOf(this, AlphaTexError.prototype);
         }
-        static symbolError(position, nonTerm, expected, symbol, symbolData = null) {
-            let message;
+        static symbolError(position, line, col, nonTerm, expected, symbol, symbolData = null) {
+            let message = `MalFormed AlphaTex: @${position} (line ${line}, col ${col}): Error on block ${nonTerm}`;
             if (expected !== symbol) {
-                message = `MalFormed AlphaTex: @${position}: Error on block ${nonTerm}, expected a ${AlphaTexSymbols[expected]} found a ${AlphaTexSymbols[symbol]}: '${symbolData}'`;
+                message += `, expected a ${AlphaTexSymbols[expected]} found a ${AlphaTexSymbols[symbol]}`;
+                if (symbolData !== null) {
+                    message += `: '${symbolData}'`;
+                }
             }
             else {
-                message = `MalFormed AlphaTex: @${position}: Error on block ${nonTerm}, invalid value: '${symbolData}'`;
-            }
-            let exception = new AlphaTexError(message);
-            exception.position = position;
-            exception.nonTerm = nonTerm;
-            exception.expected = expected;
-            exception.symbol = symbol;
-            exception.symbolData = symbolData;
-            return exception;
-        }
-        static errorMessage(position, message) {
-            message = `MalFormed AlphaTex: @${position}: ${message}`;
-            let exception = new AlphaTexError(message);
-            exception.position = position;
-            return exception;
+                message += `, invalid value: '${symbolData}'`;
+            }
+            return new AlphaTexError(message, position, line, col, nonTerm, expected, symbol, symbolData);
+        }
+        static errorMessage(message, position, line, col) {
+            message = `MalFormed AlphaTex: @${position} (line ${line}, col ${col}): ${message}`;
+            return new AlphaTexError(message, position, line, col, null, null, null, null);
         }
     }
     /**
@@ -5729,8 +5725,13 @@
             super();
             this._trackChannel = 0;
             this._input = "";
-            this._ch = 0;
+            this._ch = AlphaTexImporter.Eof;
+            // Keeps track of where in input string we are
             this._curChPos = 0;
+            this._line = 1;
+            this._col = 0;
+            // Last known position that had valid syntax/symbols
+            this._lastValidSpot = [0, 1, 0];
             this._sy = AlphaTexSymbols.No;
             this._syData = "";
             this._allowNegatives = false;
@@ -5759,6 +5760,9 @@
                 this._lyrics = new Map();
                 this.createDefaultScore();
                 this._curChPos = 0;
+                this._line = 1;
+                this._col = 0;
+                this.saveValidSpot();
                 this._currentDuration = Duration.Quarter;
                 this._currentDynamics = DynamicValue.F;
                 this._currentTuplet = 1;
@@ -5766,9 +5770,16 @@
                 this._sy = this.newSy();
                 if (this._sy === AlphaTexSymbols.LowerThan) {
                     // potential XML, stop parsing (alphaTex never starts with <)
-                    throw new UnsupportedFormatError('Unknown start sign <');
+                    throw new UnsupportedFormatError("Unknown start sign '<' (meant to import as XML?)");
+                }
+                else if (this._sy === AlphaTexSymbols.Eof) {
+                    throw new UnsupportedFormatError('Unexpected end of file');
+                }
+                const anyMetaRead = this.metaData();
+                const anyBarsRead = this.bars();
+                if (!anyMetaRead && !anyBarsRead) {
+                    throw new UnsupportedFormatError('No alphaTex data found');
                 }
-                this.score();
                 this.consolidate();
                 this._score.finish(this.settings);
                 this._score.rebuildRepeatGroups();
@@ -5779,16 +5790,18 @@
             }
             catch (e) {
                 if (e instanceof AlphaTexError) {
-                    throw new UnsupportedFormatError(e.message);
+                    throw new UnsupportedFormatError(e.message, e);
                 }
                 else {
                     throw e;
                 }
             }
         }
+        /**
+         * Ensures all staffs of all tracks have the correct number of bars
+         * (the number of bars per staff and track could be inconsistent)
+         */
         consolidate() {
-            // the number of bars per staff and track could be inconsistent,
-            // we need to ensure all staffs of all tracks have the correct number of bars
             for (let track of this._score.tracks) {
                 for (let staff of track.staves) {
                     while (staff.bars.length < this._score.masterBars.length) {
@@ -5800,21 +5813,33 @@
                 }
             }
         }
-        error(nonterm, expected, symbolError = true) {
-            let e;
-            if (symbolError) {
-                e = AlphaTexError.symbolError(this._curChPos, nonterm, expected, this._sy, this._syData);
+        error(nonterm, expected, wrongSymbol = true) {
+            let receivedSymbol;
+            let showSyData = false;
+            if (wrongSymbol) {
+                receivedSymbol = this._sy;
+                if (
+                // These are the only symbols that can have associated _syData set
+                receivedSymbol === AlphaTexSymbols.String ||
+                    receivedSymbol === AlphaTexSymbols.Number ||
+                    receivedSymbol === AlphaTexSymbols.MetaCommand // ||
+                // Tuning does not have a toString() yet, therefore excluded.
+                // receivedSymbol === AlphaTexSymbols.Tuning
+                ) {
+                    showSyData = true;
+                }
             }
             else {
-                e = AlphaTexError.symbolError(this._curChPos, nonterm, expected, expected, this._syData);
+                receivedSymbol = expected;
             }
+            let e = AlphaTexError.symbolError(this._lastValidSpot[0], this._lastValidSpot[1], this._lastValidSpot[2], nonterm, expected, receivedSymbol, showSyData ? this._syData : null);
             if (this.logErrors) {
                 Logger.error(this.name, e.message);
             }
             throw e;
         }
         errorMessage(message) {
-            let e = AlphaTexError.errorMessage(this._curChPos, message);
+            let e = AlphaTexError.errorMessage(message, this._lastValidSpot[0], this._lastValidSpot[1], this._lastValidSpot[2]);
             if (this.logErrors) {
                 Logger.error(this.name, e.message);
             }
@@ -6007,29 +6032,48 @@
             }
         }
         /**
-         * Reads the next character of the source stream.
+         * Reads, saves, and returns the next character of the source stream.
          */
         nextChar() {
             if (this._curChPos < this._input.length) {
                 this._ch = this._input.charCodeAt(this._curChPos++);
+                // line/col counting
+                if (this._ch === 0x0a /* \n */) {
+                    this._line++;
+                    this._col = 0;
+                }
+                else {
+                    this._col++;
+                }
             }
             else {
-                this._ch = 0;
+                this._ch = AlphaTexImporter.Eof;
             }
             return this._ch;
         }
         /**
-         * Reads the next terminal symbol.
+         * Saves the current position, line, and column.
+         * All parsed data until this point is assumed to be valid.
+         */
+        saveValidSpot() {
+            this._lastValidSpot = [this._curChPos, this._line, this._col];
+        }
+        /**
+         * Reads, saves, and returns the next terminal symbol.
          */
         newSy() {
+            // When a new symbol is read, the previous one is assumed to be valid.
+            // The valid spot is also moved forward when reading past whitespace or comments.
+            this.saveValidSpot();
             this._sy = AlphaTexSymbols.No;
-            do {
+            while (this._sy === AlphaTexSymbols.No) {
                 if (this._ch === AlphaTexImporter.Eof) {
                     this._sy = AlphaTexSymbols.Eof;
                 }
-                else if (this._ch === 0x20 || this._ch === 0x0b || this._ch === 0x0d || this._ch === 0x0a || this._ch === 0x09) {
+                else if (AlphaTexImporter.isWhiteSpace(this._ch)) {
                     // skip whitespaces
                     this._ch = this.nextChar();
+                    this.saveValidSpot();
                 }
                 else if (this._ch === 0x2f /* / */) {
                     this._ch = this.nextChar();
@@ -6057,8 +6101,9 @@
                         }
                     }
                     else {
-                        this.error('symbol', AlphaTexSymbols.String, false);
+                        this.error('comment', AlphaTexSymbols.String, false);
                     }
+                    this.saveValidSpot();
                 }
                 else if (this._ch === 0x22 /* " */ || this._ch === 0x27 /* ' */) {
                     let startChar = this._ch;
@@ -6069,6 +6114,9 @@
                         s += String.fromCharCode(this._ch);
                         this._ch = this.nextChar();
                     }
+                    if (this._ch === AlphaTexImporter.Eof) {
+                        this.errorMessage('String opened but never closed');
+                    }
                     this._syData = s;
                     this._ch = this.nextChar();
                 }
@@ -6129,7 +6177,7 @@
                     this._sy = AlphaTexSymbols.Number;
                     this._syData = this.readNumber();
                 }
-                else if (AlphaTexImporter.isLetter(this._ch)) {
+                else if (AlphaTexImporter.isNameLetter(this._ch)) {
                     let name = this.readName();
                     let tuning = this._allowTuning ? ModelUtils.parseTuning(name) : null;
                     if (tuning) {
@@ -6144,25 +6192,20 @@
                 else {
                     this.error('symbol', AlphaTexSymbols.String, false);
                 }
-            } while (this._sy === AlphaTexSymbols.No);
+            }
             return this._sy;
         }
         /**
-         * Checks if the given character is a letter.
+         * Checks if the given character is a valid letter for a name.
          * (no control characters, whitespaces, numbers or dots)
-         * @param code the character
-         * @returns true if the given character is a letter, otherwise false.
          */
-        static isLetter(code) {
-            // no control characters, whitespaces, numbers or dots
-            return (!AlphaTexImporter.isTerminal(code) &&
-                ((code >= 0x21 && code <= 0x2f) || (code >= 0x3a && code <= 0x7e) || code > 0x80)); /* Unicode Symbols */
+        static isNameLetter(ch) {
+            return (!AlphaTexImporter.isTerminal(ch) && ( // no control characters, whitespaces, numbers or dots
+            (0x21 <= ch && ch <= 0x2f) ||
+                (0x3a <= ch && ch <= 0x7e) ||
+                0x80 <= ch // Unicode Symbols
+            ));
         }
-        /**
-         * Checks if the given charater is a non terminal.
-         * @param ch the character
-         * @returns true if the given character is a terminal, otherwise false.
-         */
         static isTerminal(ch) {
             return (ch === 0x2e /* . */ ||
                 ch === 0x7b /* { */ ||
@@ -6176,13 +6219,17 @@
                 ch === 0x22 /* " */ ||
                 ch === 0x5c /* \ */);
         }
-        /**
-         * Checks if the given character is a digit.
-         * @param code the character
-         * @returns true if the given character is a digit, otherwise false.
-         */
-        isDigit(code) {
-            return (code >= 0x30 && code <= 0x39) /* 0-9 */ || (code === 0x2d /* - */ && this._allowNegatives); // allow - if negatives
+        static isWhiteSpace(ch) {
+            return (ch === 0x09 /* \t */ ||
+                ch === 0x0a /* \n */ ||
+                ch === 0x0b /* \v */ ||
+                ch === 0x0d /* \r */ ||
+                ch === 0x20 /* space */);
+        }
+        isDigit(ch) {
+            return ((ch >= 0x30 && ch <= 0x39) /* 0-9 */ ||
+                (this._allowNegatives && ch === 0x2d /* - */) // allow minus sign if negatives
+            );
         }
         /**
          * Reads a string from the stream.
@@ -6193,7 +6240,7 @@
             do {
                 str += String.fromCharCode(this._ch);
                 this._ch = this.nextChar();
-            } while (AlphaTexImporter.isLetter(this._ch) || this.isDigit(this._ch) || this._ch === 0x23 /* # */);
+            } while (AlphaTexImporter.isNameLetter(this._ch) || this.isDigit(this._ch));
             return str;
         }
         /**
@@ -6208,16 +6255,6 @@
             } while (this.isDigit(this._ch));
             return parseInt(str);
         }
-        score() {
-            if (this._sy === AlphaTexSymbols.Eof) {
-                throw new UnsupportedFormatError('Unexpected end of file');
-            }
-            const anyMetaRead = this.metaData();
-            const anyBarsRead = this.bars();
-            if (!anyMetaRead && !anyBarsRead) {
-                throw new UnsupportedFormatError('No alphaTex data found');
-            }
-        }
         metaData() {
             let anyMeta = false;
             let continueReading = true;
@@ -6513,45 +6550,40 @@
             return anyData;
         }
         trackStaffMeta() {
-            let anyMeta = false;
-            if (this._sy === AlphaTexSymbols.MetaCommand) {
-                anyMeta = true;
-                let syData = this._syData.toLowerCase();
-                if (syData === 'track') {
-                    this._staffHasExplicitTuning = false;
-                    this._staffTuningApplied = false;
+            if (this._sy !== AlphaTexSymbols.MetaCommand) {
+                return false;
+            }
+            if (this._syData.toLowerCase() === 'track') {
+                this._staffHasExplicitTuning = false;
+                this._staffTuningApplied = false;
+                this._sy = this.newSy();
+                // new track starting? - if no masterbars it's the \track of the initial track.
+                if (this._score.masterBars.length > 0) {
+                    this.newTrack();
+                }
+                // name
+                if (this._sy === AlphaTexSymbols.String) {
+                    this._currentTrack.name = this._syData;
                     this._sy = this.newSy();
-                    // new track starting? - if no masterbars it's the \track of the initial track.
-                    if (this._score.masterBars.length > 0) {
-                        this.newTrack();
-                    }
-                    // name
-                    if (this._sy === AlphaTexSymbols.String) {
-                        this._currentTrack.name = this._syData;
-                        this._sy = this.newSy();
-                    }
-                    // short name
-                    if (this._sy === AlphaTexSymbols.String) {
-                        this._currentTrack.shortName = this._syData;
-                        this._sy = this.newSy();
-                    }
                 }
-                if (this._sy === AlphaTexSymbols.MetaCommand) {
-                    syData = this._syData.toLowerCase();
-                    if (syData === 'staff') {
-                        this._staffHasExplicitTuning = false;
-                        this._staffTuningApplied = false;
-                        this._sy = this.newSy();
-                        if (this._currentTrack.staves[0].bars.length > 0) {
-                            this._currentTrack.ensureStaveCount(this._currentTrack.staves.length + 1);
-                            this._currentStaff = this._currentTrack.staves[this._currentTrack.staves.length - 1];
-                            this._currentDynamics = DynamicValue.F;
-                        }
-                        this.staffProperties();
-                    }
+                // short name
+                if (this._sy === AlphaTexSymbols.String) {
+                    this._currentTrack.shortName = this._syData;
+                    this._sy = this.newSy();
                 }
             }
-            return anyMeta;
+            if (this._sy === AlphaTexSymbols.MetaCommand && this._syData.toLowerCase() === 'staff') {
+                this._staffHasExplicitTuning = false;
+                this._staffTuningApplied = false;
+                this._sy = this.newSy();
+                if (this._currentTrack.staves[0].bars.length > 0) {
+                    this._currentTrack.ensureStaveCount(this._currentTrack.staves.length + 1);
+                    this._currentStaff = this._currentTrack.staves[this._currentTrack.staves.length - 1];
+                    this._currentDynamics = DynamicValue.F;
+                }
+                this.staffProperties();
+            }
+            return true;
         }
         staffProperties() {
             if (this._sy !== AlphaTexSymbols.LBrace) {
@@ -6605,7 +6637,7 @@
                 // reset to defaults
                 this._currentStaff.displayTranspositionPitch = 0;
                 this._currentStaff.stringTuning.tunings = [];
-                if (program == 15 || program >= 24 && program <= 31) {
+                if (program == 15 || (program >= 24 && program <= 31)) {
                     // dulcimer+guitar E4 B3 G3 D3 A2 E2
                     this._currentStaff.displayTranspositionPitch = -12;
                     this._currentStaff.stringTuning.tunings = Tuning.getDefaultTuningFor(6).tunings;
@@ -6723,7 +6755,7 @@
             beat.duration = this._currentDuration;
             beat.dynamics = this._currentDynamics;
             if (this._currentTuplet !== 1 && !beat.hasTuplet) {
-                this.applyTuplet(beat, this._currentTuplet);
+                AlphaTexImporter.applyTuplet(beat, this._currentTuplet);
             }
             // beat multiplier (repeat beat n times)
             let beatRepeat = 1;
@@ -6788,7 +6820,6 @@
             }
             this._sy = this.newSy();
             while (this._sy === AlphaTexSymbols.String) {
-                this._syData = this._syData.toLowerCase();
                 if (!this.applyBeatEffect(beat)) {
                     this.error('beat-effects', AlphaTexSymbols.String, false);
                 }
@@ -6837,7 +6868,7 @@
                     this.error('tuplet', AlphaTexSymbols.Number, true);
                     return false;
                 }
-                this.applyTuplet(beat, this._syData);
+                AlphaTexImporter.applyTuplet(beat, this._syData);
             }
             else if (syData === 'tb' || syData === 'tbe') {
                 let exact = syData === 'tbe';
@@ -7024,7 +7055,7 @@
         getChordId(currentStaff, chordName) {
             return chordName.toLowerCase() + currentStaff.index + currentStaff.track.index;
         }
-        applyTuplet(beat, tuplet) {
+        static applyTuplet(beat, tuplet) {
             switch (tuplet) {
                 case 3:
                     beat.tupletNumerator = 3;
@@ -7140,9 +7171,8 @@
             this._sy = this.newSy();
             while (this._sy === AlphaTexSymbols.String) {
                 let syData = this._syData.toLowerCase();
-                this._syData = syData;
                 if (syData === 'b' || syData === 'be') {
-                    let exact = this._syData === 'be';
+                    let exact = syData === 'be';
                     // read points
                     this._sy = this.newSy();
                     if (this._sy !== AlphaTexSymbols.LParensis) {
@@ -25632,7 +25662,7 @@
                 settings = new Settings();
             }
             let importers = Environment.buildImporters();
-            Logger.debug('ScoreLoader', 'Loading score from ' + data.length + ' bytes using ' + importers.length + ' importers', null);
+            Logger.debug('ScoreLoader', `Loading score from ${data.length} bytes using ${importers.length} importers`);
             let score = null;
             let bb = ByteBuffer.fromBuffer(data);
             for (let importer of importers) {
@@ -28306,7 +28336,8 @@
                 let currentBeatGlyph = beatGlyphs[i];
                 switch (currentBeatGlyph.beat.graceType) {
                     case GraceType.None:
-                        currentBeatGlyph.x = positions.get(currentBeatGlyph.beat.absoluteDisplayStart) * scale - currentBeatGlyph.onTimeX;
+                        currentBeatGlyph.x =
+                            positions.get(currentBeatGlyph.beat.absoluteDisplayStart) * scale - currentBeatGlyph.onTimeX;
                         break;
                     default:
                         const graceDisplayStart = currentBeatGlyph.beat.graceGroup.beats[0].absoluteDisplayStart;
@@ -28315,14 +28346,21 @@
                         if (currentBeatGlyph.beat.graceGroup.isComplete && positions.has(graceDisplayStart)) {
                             currentBeatGlyph.x = positions.get(graceDisplayStart) * scale - currentBeatGlyph.onTimeX;
                             let graceSprings = this.renderer.layoutingInfo.allGraceRods.get(graceGroupId);
-                            let graceTargetPreBeat = this.renderer.layoutingInfo.springs.get(graceDisplayStart).preBeatWidth;
+                            // get the pre beat stretch of this voice/staff, not the
+                            // shared space. This way we use the potentially empty space (see discussions/1092).
+                            const afterGraceBeat = currentBeatGlyph.beat.graceGroup.beats[currentBeatGlyph.beat.graceGroup.beats.length - 1]
+                                .nextBeat;
+                            const preBeatStretch = afterGraceBeat
+                                ? this.renderer.layoutingInfo.getPreBeatSize(afterGraceBeat) +
+                                    BeatContainerGlyph.GraceBeatPadding * this.renderer.scale
+                                : 0;
                             // move right in front to the note
-                            currentBeatGlyph.x -= graceTargetPreBeat;
+                            currentBeatGlyph.x -= preBeatStretch;
                             // respect the post beat width of the grace note
                             currentBeatGlyph.x -= graceSprings[currentBeatGlyph.beat.graceIndex].postSpringWidth;
                             // shift to right position of the particular grace note
                             currentBeatGlyph.x += graceSprings[currentBeatGlyph.beat.graceIndex].graceBeatWidth;
-                            // move the whole group again forward for cases where another track has e.g. 3 beats and here we have only 2. 
+                            // move the whole group again forward for cases where another track has e.g. 3 beats and here we have only 2.
                             // so we shift the whole group of this voice to stick to the end of the group.
                             const lastGraceSpring = graceSprings[currentBeatGlyph.beat.graceGroup.beats.length - 1];
                             currentBeatGlyph.x -= lastGraceSpring.graceBeatWidth;
@@ -28330,21 +28368,22 @@
                         else {
                             // placement for improper grace beats where no beat in the same bar follows
                             let graceSpring = this.renderer.layoutingInfo.incompleteGraceRods.get(graceGroupId);
-                            const relativeOffset = graceSpring[currentBeatGlyph.beat.graceIndex].postSpringWidth
-                                - graceSpring[currentBeatGlyph.beat.graceIndex].preSpringWidth;
+                            const relativeOffset = graceSpring[currentBeatGlyph.beat.graceIndex].postSpringWidth -
+                                graceSpring[currentBeatGlyph.beat.graceIndex].preSpringWidth;
                             if (i > 0) {
                                 if (currentBeatGlyph.beat.graceIndex === 0) {
                                     // we place the grace beat directly after the previous one
-                                    // otherwise this causes flickers on resizing 
+                                    // otherwise this causes flickers on resizing
                                     currentBeatGlyph.x = beatGlyphs[i - 1].x + beatGlyphs[i - 1].width;
                                 }
                                 else {
                                     // for the multiple grace glyphs we take the width of the grace rod
                                     // this width setting is aligned with the positioning logic below
-                                    currentBeatGlyph.x = beatGlyphs[i - 1].x
-                                        + graceSpring[currentBeatGlyph.beat.graceIndex - 1].postSpringWidth
-                                        - graceSpring[currentBeatGlyph.beat.graceIndex - 1].preSpringWidth
-                                        - relativeOffset;
+                                    currentBeatGlyph.x =
+                                        beatGlyphs[i - 1].x +
+                                            graceSpring[currentBeatGlyph.beat.graceIndex - 1].postSpringWidth -
+                                            graceSpring[currentBeatGlyph.beat.graceIndex - 1].preSpringWidth -
+                                            relativeOffset;
                                 }
                             }
                             else {
@@ -28394,8 +28433,7 @@
                 this.tupletGroups.push(bg.beat.tupletGroup);
             }
         }
-        doLayout() {
-        }
+        doLayout() { }
         paint(cx, cy, canvas) {
             // canvas.color = Color.random();
             // canvas.strokeRect(cx + this.x, cy + this.y, this.width, this.renderer.height);
@@ -32197,38 +32235,38 @@
             }
         }
         setPreBeatSize(beat, size) {
-            if (!this.preBeatSizes.has(beat.index) || this.preBeatSizes.get(beat.index) < size) {
-                this.preBeatSizes.set(beat.index, size);
+            if (!this.preBeatSizes.has(beat.id) || this.preBeatSizes.get(beat.id) < size) {
+                this.preBeatSizes.set(beat.id, size);
                 this.version++;
             }
         }
         getPreBeatSize(beat) {
-            if (this.preBeatSizes.has(beat.index)) {
-                return this.preBeatSizes.get(beat.index);
+            if (this.preBeatSizes.has(beat.id)) {
+                return this.preBeatSizes.get(beat.id);
             }
             return 0;
         }
         setOnBeatSize(beat, size) {
-            if (!this.onBeatSizes.has(beat.index) || this.onBeatSizes.get(beat.index) < size) {
-                this.onBeatSizes.set(beat.index, size);
+            if (!this.onBeatSizes.has(beat.id) || this.onBeatSizes.get(beat.id) < size) {
+                this.onBeatSizes.set(beat.id, size);
                 this.version++;
             }
         }
         getOnBeatSize(beat) {
-            if (this.onBeatSizes.has(beat.index)) {
-                return this.onBeatSizes.get(beat.index);
+            if (this.onBeatSizes.has(beat.id)) {
+                return this.onBeatSizes.get(beat.id);
             }
             return 0;
         }
         getBeatCenterX(beat) {
-            if (this.onBeatCenterX.has(beat.index)) {
-                return this.onBeatCenterX.get(beat.index);
+            if (this.onBeatCenterX.has(beat.id)) {
+                return this.onBeatCenterX.get(beat.id);
             }
             return 0;
         }
         setBeatCenterX(beat, x) {
-            if (!this.onBeatCenterX.has(beat.index) || this.onBeatCenterX.get(beat.index) < x) {
-                this.onBeatCenterX.set(beat.index, x);
+            if (!this.onBeatCenterX.has(beat.id) || this.onBeatCenterX.get(beat.id) < x) {
+                this.onBeatCenterX.set(beat.id, x);
                 this.version++;
             }
         }
@@ -36222,16 +36260,19 @@
             this._beat = beat;
         }
         doLayout() {
-            this.width = 10 * this.scale;
+            this.width =
+                this._beat.brushType === BrushType.ArpeggioUp || this._beat.brushType === BrushType.ArpeggioDown
+                    ? 10 * this.scale
+                    : 0;
         }
         paint(cx, cy, canvas) {
-            let scoreBarRenderer = this.renderer;
-            let lineSize = scoreBarRenderer.lineOffset;
-            let startY = cy + this.y + (scoreBarRenderer.getNoteY(this._beat.maxNote, NoteYPosition.Bottom) - lineSize);
-            let endY = cy + this.y + scoreBarRenderer.getNoteY(this._beat.minNote, NoteYPosition.Top) + lineSize;
-            let arrowX = cx + this.x + this.width / 2;
-            let arrowSize = 8 * this.scale;
-            if (this._beat.brushType !== BrushType.None) {
+            if (this._beat.brushType === BrushType.ArpeggioUp || this._beat.brushType === BrushType.ArpeggioDown) {
+                let scoreBarRenderer = this.renderer;
+                let lineSize = scoreBarRenderer.lineOffset;
+                let startY = cy + this.y + (scoreBarRenderer.getNoteY(this._beat.maxNote, NoteYPosition.Bottom) - lineSize);
+                let endY = cy + this.y + scoreBarRenderer.getNoteY(this._beat.minNote, NoteYPosition.Top) + lineSize;
+                let arrowX = cx + this.x + this.width / 2;
+                let arrowSize = 8 * this.scale;
                 let glyph = new NoteVibratoGlyph(0, 0, VibratoType.Slight, 1.2, true);
                 glyph.renderer = this.renderer;
                 glyph.doLayout();
@@ -41355,8 +41396,8 @@
     // </auto-generated>
     class VersionInfo {
     }
-    VersionInfo.version = '1.3.0-alpha.518';
-    VersionInfo.date = '2023-01-14T01:08:10.114Z';
+    VersionInfo.version = '1.3.0-alpha.519';
+    VersionInfo.date = '2023-01-15T01:15:31.341Z';
 
     var index$5 = /*#__PURE__*/Object.freeze({
         __proto__: null,