@coderline/alphatab 1.3.0-alpha.355 → 1.3.0-alpha.374

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /**
- * alphaTab v1.3.0-alpha.355 (develop, build 355)
+ * alphaTab v1.3.0-alpha.374 (develop, build 374)
  * 
  * Copyright © 2022, Daniel Kuschny and Contributors, All rights reserved.
  * 
@@ -4037,6 +4037,73 @@
         }
     }
 
+    /**
+     * This public enumeration lists all available key signatures
+     */
+    var KeySignature;
+    (function (KeySignature) {
+        /**
+         * Cb (7 flats)
+         */
+        KeySignature[KeySignature["Cb"] = -7] = "Cb";
+        /**
+         * Gb (6 flats)
+         */
+        KeySignature[KeySignature["Gb"] = -6] = "Gb";
+        /**
+         * Db (5 flats)
+         */
+        KeySignature[KeySignature["Db"] = -5] = "Db";
+        /**
+         * Ab (4 flats)
+         */
+        KeySignature[KeySignature["Ab"] = -4] = "Ab";
+        /**
+         * Eb (3 flats)
+         */
+        KeySignature[KeySignature["Eb"] = -3] = "Eb";
+        /**
+         * Bb (2 flats)
+         */
+        KeySignature[KeySignature["Bb"] = -2] = "Bb";
+        /**
+         * F (1 flat)
+         */
+        KeySignature[KeySignature["F"] = -1] = "F";
+        /**
+         * C (no signs)
+         */
+        KeySignature[KeySignature["C"] = 0] = "C";
+        /**
+         * G (1 sharp)
+         */
+        KeySignature[KeySignature["G"] = 1] = "G";
+        /**
+         * D (2 sharp)
+         */
+        KeySignature[KeySignature["D"] = 2] = "D";
+        /**
+         * A (3 sharp)
+         */
+        KeySignature[KeySignature["A"] = 3] = "A";
+        /**
+         * E (4 sharp)
+         */
+        KeySignature[KeySignature["E"] = 4] = "E";
+        /**
+         * B (5 sharp)
+         */
+        KeySignature[KeySignature["B"] = 5] = "B";
+        /**
+         * F# (6 sharp)
+         */
+        KeySignature[KeySignature["FSharp"] = 6] = "FSharp";
+        /**
+         * C# (7 sharp)
+         */
+        KeySignature[KeySignature["CSharp"] = 7] = "CSharp";
+    })(KeySignature || (KeySignature = {}));
+
     var LyricsState;
     (function (LyricsState) {
         LyricsState[LyricsState["IgnoreSpaces"] = 0] = "IgnoreSpaces";
@@ -4172,73 +4239,6 @@
     Lyrics.CharCodeBrackedOpen = 91;
     Lyrics.CharCodeDash = 45;
 
-    /**
-     * This public enumeration lists all available key signatures
-     */
-    var KeySignature;
-    (function (KeySignature) {
-        /**
-         * Cb (7 flats)
-         */
-        KeySignature[KeySignature["Cb"] = -7] = "Cb";
-        /**
-         * Gb (6 flats)
-         */
-        KeySignature[KeySignature["Gb"] = -6] = "Gb";
-        /**
-         * Db (5 flats)
-         */
-        KeySignature[KeySignature["Db"] = -5] = "Db";
-        /**
-         * Ab (4 flats)
-         */
-        KeySignature[KeySignature["Ab"] = -4] = "Ab";
-        /**
-         * Eb (3 flats)
-         */
-        KeySignature[KeySignature["Eb"] = -3] = "Eb";
-        /**
-         * Bb (2 flats)
-         */
-        KeySignature[KeySignature["Bb"] = -2] = "Bb";
-        /**
-         * F (1 flat)
-         */
-        KeySignature[KeySignature["F"] = -1] = "F";
-        /**
-         * C (no signs)
-         */
-        KeySignature[KeySignature["C"] = 0] = "C";
-        /**
-         * G (1 sharp)
-         */
-        KeySignature[KeySignature["G"] = 1] = "G";
-        /**
-         * D (2 sharp)
-         */
-        KeySignature[KeySignature["D"] = 2] = "D";
-        /**
-         * A (3 sharp)
-         */
-        KeySignature[KeySignature["A"] = 3] = "A";
-        /**
-         * E (4 sharp)
-         */
-        KeySignature[KeySignature["E"] = 4] = "E";
-        /**
-         * B (5 sharp)
-         */
-        KeySignature[KeySignature["B"] = 5] = "B";
-        /**
-         * F# (6 sharp)
-         */
-        KeySignature[KeySignature["FSharp"] = 6] = "FSharp";
-        /**
-         * C# (8 sharp)
-         */
-        KeySignature[KeySignature["CSharp"] = 7] = "CSharp";
-    })(KeySignature || (KeySignature = {}));
-
     /**
      * This public enumeration lists all available types of KeySignatures
      */
@@ -5707,11 +5707,11 @@
         }
         static symbolError(position, nonTerm, expected, symbol, symbolData = null) {
             let message;
-            if (!symbolData) {
+            if (expected !== symbol) {
                 message = `MalFormed AlphaTex: @${position}: Error on block ${nonTerm}, expected a ${AlphaTexSymbols[expected]} found a ${AlphaTexSymbols[symbol]}: '${symbolData}'`;
             }
             else {
-                message = `MalFormed AlphaTex: @${position}: Error on block ${nonTerm}, invalid value: ${symbolData}`;
+                message = `MalFormed AlphaTex: @${position}: Error on block ${nonTerm}, invalid value: '${symbolData}'`;
             }
             let exception = new AlphaTexError(message);
             exception.position = position;
@@ -5722,7 +5722,7 @@
             return exception;
         }
         static errorMessage(position, message) {
-            message = 'MalFormed AlphaTex: @' + position + ': ' + message;
+            message = `MalFormed AlphaTex: @${position}: ${message}`;
             let exception = new AlphaTexError(message);
             exception.position = position;
             return exception;
@@ -5810,7 +5810,7 @@
         error(nonterm, expected, symbolError = true) {
             let e;
             if (symbolError) {
-                e = AlphaTexError.symbolError(this._curChPos, nonterm, expected, this._sy, null);
+                e = AlphaTexError.symbolError(this._curChPos, nonterm, expected, this._sy, this._syData);
             }
             else {
                 e = AlphaTexError.symbolError(this._curChPos, nonterm, expected, expected, this._syData);
@@ -5951,37 +5951,65 @@
         parseKeySignature(str) {
             switch (str.toLowerCase()) {
                 case 'cb':
-                    return -7;
+                case 'cbmajor':
+                    return KeySignature.Cb;
                 case 'gb':
-                    return -6;
+                case 'gbmajor':
+                case 'd#minor':
+                    return KeySignature.Gb;
                 case 'db':
-                    return -5;
+                case 'dbmajor':
+                case 'bbminor':
+                    return KeySignature.Db;
                 case 'ab':
-                    return -4;
+                case 'abmajor':
+                case 'fminor':
+                    return KeySignature.Ab;
                 case 'eb':
-                    return -3;
+                case 'ebmajor':
+                case 'cminor':
+                    return KeySignature.Eb;
                 case 'bb':
-                    return -2;
+                case 'bbmajor':
+                case 'gminor':
+                    return KeySignature.Bb;
                 case 'f':
-                    return -1;
+                case 'fmajor':
+                case 'dminor':
+                    return KeySignature.F;
                 case 'c':
-                    return 0;
+                case 'cmajor':
+                case 'aminor':
+                    return KeySignature.C;
                 case 'g':
-                    return 1;
+                case 'gmajor':
+                case 'eminor':
+                    return KeySignature.G;
                 case 'd':
-                    return 2;
+                case 'dmajor':
+                case 'bminor':
+                    return KeySignature.D;
                 case 'a':
-                    return 3;
+                case 'amajor':
+                case 'f#minor':
+                    return KeySignature.A;
                 case 'e':
-                    return 4;
+                case 'emajor':
+                case 'c#minor':
+                    return KeySignature.E;
                 case 'b':
-                    return 5;
+                case 'bmajor':
+                case 'g#minor':
+                    return KeySignature.B;
                 case 'f#':
-                    return 6;
+                case 'f#major':
+                case 'ebminor':
+                    return KeySignature.FSharp;
                 case 'c#':
-                    return 7;
+                case 'c#major':
+                    return KeySignature.CSharp;
                 default:
-                    return 0;
+                    return KeySignature.C;
                 // error("keysignature-value", AlphaTexSymbols.String, false); return 0
             }
         }
@@ -6022,7 +6050,7 @@
                     }
                     else if (this._ch === 0x2a /* * */) {
                         // multiline comment
-                        while (this._ch !== 0) {
+                        while (this._ch !== AlphaTexImporter.Eof) {
                             if (this._ch === 0x2a /* * */) {
                                 this._ch = this.nextChar();
                                 if (this._ch === 0x2f /* / */) {
@@ -6055,9 +6083,8 @@
                     // negative number
                     // is number?
                     if (this._allowNegatives && this.isDigit(this._ch)) {
-                        let num = this.readNumber();
                         this._sy = AlphaTexSymbols.Number;
-                        this._syData = num;
+                        this._syData = this.readNumber();
                     }
                     else {
                         this._sy = AlphaTexSymbols.String;
@@ -6078,9 +6105,8 @@
                 }
                 else if (this._ch === 0x5c /* \ */) {
                     this._ch = this.nextChar();
-                    let name = this.readName();
                     this._sy = AlphaTexSymbols.MetaCommand;
-                    this._syData = name;
+                    this._syData = this.readName();
                 }
                 else if (this._ch === 0x29 /* ) */) {
                     this._sy = AlphaTexSymbols.RParensis;
@@ -6107,9 +6133,8 @@
                     this._ch = this.nextChar();
                 }
                 else if (this.isDigit(this._ch)) {
-                    let num = this.readNumber();
                     this._sy = AlphaTexSymbols.Number;
-                    this._syData = num;
+                    this._syData = this.readNumber();
                 }
                 else if (AlphaTexImporter.isLetter(this._ch)) {
                     let name = this.readName();
@@ -7372,8 +7397,8 @@
             }
             this._sy = this.newSy();
         }
-        toFinger(syData) {
-            switch (syData) {
+        toFinger(num) {
+            switch (num) {
                 case 1:
                     return Fingers.Thumb;
                 case 2:
@@ -7409,6 +7434,8 @@
                     return Duration.SixtyFourth;
                 case 128:
                     return Duration.OneHundredTwentyEighth;
+                case 256:
+                    return Duration.TwoHundredFiftySixth;
                 default:
                     return Duration.Quarter;
             }
@@ -7441,6 +7468,9 @@
                     if (this._sy !== AlphaTexSymbols.Number) {
                         this.error('repeatclose', AlphaTexSymbols.Number, true);
                     }
+                    if (this._syData > 2048) {
+                        this.error('repeatclose', AlphaTexSymbols.Number, false);
+                    }
                     master.repeatCount = this._syData;
                     this._sy = this.newSy();
                 }
@@ -7472,14 +7502,14 @@
                     if (this._sy !== AlphaTexSymbols.String) {
                         this.error('keysignature', AlphaTexSymbols.String, true);
                     }
-                    master.keySignature = this.parseKeySignature(this._syData.toLowerCase());
+                    master.keySignature = this.parseKeySignature(this._syData);
                     this._sy = this.newSy();
                 }
                 else if (syData === 'clef') {
                     this._sy = this.newSy();
                     switch (this._sy) {
                         case AlphaTexSymbols.String:
-                            bar.clef = this.parseClefFromString(this._syData.toLowerCase());
+                            bar.clef = this.parseClefFromString(this._syData);
                             break;
                         case AlphaTexSymbols.Number:
                             bar.clef = this.parseClefFromInt(this._syData);
@@ -7530,7 +7560,7 @@
                     this._allowTuning = true;
                     switch (this._sy) {
                         case AlphaTexSymbols.String:
-                            master.tripletFeel = this.parseTripletFeelFromString(this._syData.toLowerCase());
+                            master.tripletFeel = this.parseTripletFeelFromString(this._syData);
                             break;
                         case AlphaTexSymbols.Number:
                             master.tripletFeel = this.parseTripletFeelFromInt(this._syData);
@@ -14536,7 +14566,7 @@
             }
         }
         get currentTime() {
-            return this._currentState.currentTime;
+            return this._currentState.currentTime / this.playbackSpeed;
         }
         /**
          * Gets the duration of the song in ticks.
@@ -17463,6 +17493,11 @@
                     this._notPlayedSamples += samples.length;
                     this.output.addSamples(samples);
                 }
+                else {
+                    // Tell output that there is no data left for it.
+                    let samples = new Float32Array(0);
+                    this.output.addSamples(samples);
+                }
             });
             this.output.samplesPlayed.on(this.onSamplesPlayed.bind(this));
             this.output.open(bufferTimeInMilliseconds);
@@ -17565,7 +17600,7 @@
                 Logger.debug('AlphaSynth', 'Starting countin');
                 this._sequencer.startCountIn();
                 this._synthesizer.setupMetronomeChannel(this._countInVolume);
-                this.tickPosition = 0;
+                this.updateTimePosition(0, true);
             }
             this.output.play();
             return true;
@@ -17717,6 +17752,7 @@
                     this._sequencer.resetCountIn();
                     this.timePosition = this._sequencer.currentTime;
                     this.playInternal();
+                    this.output.resetSamples();
                 }
                 else if (this._sequencer.isPlayingOneTimeMidi) {
                     Logger.debug('AlphaSynth', 'Finished playback (one time)');
@@ -17968,6 +18004,7 @@
             this.lineHeight = 'normal';
             this.size = '1rem';
             this.families = [];
+            this.parseOnlyFamilies = false;
             this._currentTokenIndex = -1;
             this._input = '';
             this._currentToken = null;
@@ -18005,13 +18042,26 @@
                         return;
                 }
             }
-            this.fontStyleVariantWeight();
-            this.fontSizeLineHeight();
+            if (!this.parseOnlyFamilies) {
+                this.fontStyleVariantWeight();
+                this.fontSizeLineHeight();
+            }
             this.fontFamily();
         }
+        static parseFamilies(value) {
+            const parser = new FontParser(value);
+            parser.parseOnlyFamilies = true;
+            parser.parse();
+            return parser.families;
+        }
         fontFamily() {
             if (!this._currentToken) {
-                throw new Error(`Missing font list`);
+                if (this.parseOnlyFamilies) {
+                    return;
+                }
+                else {
+                    throw new Error(`Missing font list`);
+                }
             }
             const familyListInput = this._input.substr(this._currentToken.startPos).trim();
             let pos = 0;
@@ -18187,6 +18237,13 @@
             this._currentTokenIndex = -1;
             this.nextToken();
         }
+        static quoteFont(f) {
+            if (f.indexOf(' ') === -1) {
+                return f;
+            }
+            const escapedQuotes = f.replaceAll('"', '\\"');
+            return `"${escapedQuotes}"`;
+        }
     }
     /**
      * Lists all flags for font styles.
@@ -18229,7 +18286,7 @@
          */
         constructor(family, size, style = FontStyle.Plain, weight = FontWeight.Regular) {
             this._cssScale = 0.0;
-            this._family = family;
+            this._families = FontParser.parseFamilies(family);
             this._size = size;
             this._style = style;
             this._weight = weight;
@@ -18240,16 +18297,30 @@
             this._css = this.toCssString();
         }
         /**
-         * Gets the font family name.
+         * Gets the first font family name.
+         * @deprecated Consider using {@link families} for multi font family support.
          */
         get family() {
-            return this._family;
+            return this._families[0];
         }
         /**
-         * Sets the font family name.
+         * Sets the font family list.
+         * @deprecated Consider using {@link families} for multi font family support.
          */
         set family(value) {
-            this._family = value;
+            this.families = FontParser.parseFamilies(value);
+        }
+        /**
+         * Gets the font family name.
+         */
+        get families() {
+            return this._families;
+        }
+        /**
+         * Sets the font family name.
+         */
+        set families(value) {
+            this._families = value;
             this.reset();
         }
         /**
@@ -18297,6 +18368,18 @@
         get isItalic() {
             return this.style === FontStyle.Italic;
         }
+        /**
+         * Initializes a new instance of the {@link Font} class.
+         * @param families The families.
+         * @param size The size.
+         * @param style The style.
+         * @param weight The weight.
+         */
+        static withFamilyList(families, size, style = FontStyle.Plain, weight = FontWeight.Regular) {
+            const f = new Font("", size, style, weight);
+            f.families = families;
+            return f;
+        }
         toCssString(scale = 1) {
             if (!this._css || !(Math.abs(scale - this._cssScale) < 0.01)) {
                 let buf = '';
@@ -18308,9 +18391,7 @@
                 }
                 buf += this.size * scale;
                 buf += 'px ';
-                buf += "'";
-                buf += this.family;
-                buf += "'";
+                buf += this.families.map(f => FontParser.quoteFont(f)).join(', ');
                 this._css = buf;
                 this._cssScale = scale;
             }
@@ -18322,21 +18403,17 @@
                     return null;
                 case 'object': {
                     const m = v;
-                    let family = m.get('family');
+                    let families = m.get('families');
                     // tslint:disable-next-line: no-unnecessary-type-assertion
                     let size = m.get('size');
                     let style = JsonHelper.parseEnum(m.get('style'), FontStyle);
                     let weight = JsonHelper.parseEnum(m.get('weight'), FontWeight);
-                    return new Font(family, size, style, weight);
+                    return Font.withFamilyList(families, size, style, weight);
                 }
                 case 'string': {
                     const parser = new FontParser(v);
                     parser.parse();
-                    let family = parser.families[0];
-                    if ((family.startsWith("'") && family.endsWith("'")) ||
-                        (family.startsWith('"') && family.endsWith('"'))) {
-                        family = family.substr(1, family.length - 2);
-                    }
+                    let families = parser.families;
                     let fontSizeString = parser.size.toLowerCase();
                     let fontSize = 0;
                     // as per https://websemantics.uk/articles/font-size-conversion/
@@ -18399,7 +18476,7 @@
                             fontWeight = FontWeight.Bold;
                             break;
                     }
-                    return new Font(family, fontSize, fontStyle, fontWeight);
+                    return Font.withFamilyList(families, fontSize, fontStyle, fontWeight);
                 }
                 default:
                     return null;
@@ -18407,7 +18484,7 @@
         }
         static toJson(font) {
             const o = new Map();
-            o.set('family', font.family);
+            o.set('families', font.families);
             o.set('size', font.size);
             o.set('style', font.style);
             o.set('weight', font.weight);
@@ -18491,8 +18568,8 @@
             this.scoreInfoColor = new Color(0, 0, 0, 0xff);
         }
     }
-    RenderingResources.sansFont = 'Arial';
-    RenderingResources.serifFont = 'Georgia';
+    RenderingResources.sansFont = 'Arial, sans-serif';
+    RenderingResources.serifFont = 'Georgia, serif';
 
     /**
      * The display settings control how the general layout and display of alphaTab is done.
@@ -21058,9 +21135,17 @@
                 FontSizes.FontSizeLookupTables.set(family, new Uint8Array([8]));
             }
         }
-        static measureString(s, family, size, style, weight) {
+        static measureString(s, families, size, style, weight) {
             let data;
             let dataSize = 11;
+            let family = families[0]; // default to first font
+            // find a font which is maybe registered already
+            for (let i = 0; i < families.length; i++) {
+                if (FontSizes.FontSizeLookupTables.has(families[i])) {
+                    family = families[i];
+                    break;
+                }
+            }
             if (!FontSizes.FontSizeLookupTables.has(family)) {
                 FontSizes.generateFontLookup(family);
             }
@@ -24359,6 +24444,10 @@
          * Applies any changes that were done to the settings object and informs the {@link renderer} about any new values to consider.
          */
         updateSettings() {
+            const score = this.score;
+            if (score) {
+                ModelUtils.applyPitchOffsets(this.settings, score);
+            }
             this.renderer.updateSettings(this.settings);
             // enable/disable player if needed
             if (this.settings.player.enablePlayer) {
@@ -24440,8 +24529,8 @@
             }
         }
         internalRenderTracks(score, tracks) {
+            ModelUtils.applyPitchOffsets(this.settings, score);
             if (score !== this.score) {
-                ModelUtils.applyPitchOffsets(this.settings, score);
                 this.score = score;
                 this.tracks = tracks;
                 this._trackIndexes = [];
@@ -25733,11 +25822,12 @@
      * @target web
      */
     class FontLoadingChecker {
-        constructor(family) {
+        constructor(families) {
             this._isStarted = false;
             this.isFontLoaded = false;
             this.fontLoaded = new EventEmitterOfT();
-            this._family = family;
+            this._originalFamilies = families;
+            this._families = families;
         }
         checkForFontAvailability() {
             if (Environment.isRunningInWorker) {
@@ -25751,30 +25841,62 @@
             this._isStarted = true;
             let failCounter = 0;
             let failCounterId = window.setInterval(() => {
-                failCounter++;
-                Logger.warning('Rendering', `Could not load font '${this._family}' within ${failCounter * 5} seconds`, null);
+                Logger.warning('Rendering', `Could not load font '${this._families[0]}' within ${(failCounter + 1) * 5} seconds`, null);
+                // try loading next font if there are more than 1 left
+                if (this._families.length > 1) {
+                    this._families.shift();
+                    failCounter = 0;
+                }
+                else {
+                    failCounter++;
+                }
             }, 5000);
-            Logger.debug('Font', `Start checking for font availablility: ${this._family}`);
-            Logger.debug('Font', `[${this._family}] Font API available`);
+            Logger.debug('Font', `Start checking for font availablility: ${this._families.join(', ')}`);
+            let errorHandler = () => {
+                if (this._families.length > 1) {
+                    Logger.debug('Font', `[${this._families[0]}] Loading Failed, switching to ${this._families[1]}`);
+                    this._families.shift();
+                    window.setTimeout(() => {
+                        checkFont();
+                    }, 0);
+                }
+                else {
+                    Logger.error('Font', `[${this._originalFamilies.join(',')}] Loading Failed, rendering cannot start`);
+                    window.clearInterval(failCounterId);
+                }
+            };
+            let successHandler = (font) => {
+                Logger.debug('Rendering', `[${font}] Font API signaled available`);
+                this.isFontLoaded = true;
+                window.clearInterval(failCounterId);
+                this.fontLoaded.trigger(this._families[0]);
+            };
             let checkFont = () => {
-                document.fonts.load(`1em ${this._family}`).then(() => {
-                    Logger.debug('Font', `[${this._family}] Font API signaled loaded`);
-                    if (document.fonts.check('1em ' + this._family)) {
-                        Logger.debug('Rendering', `[${this._family}] Font API signaled available`);
-                        this.isFontLoaded = true;
-                        window.clearInterval(failCounterId);
-                        this.fontLoaded.trigger(this._family);
+                // Fast Path: check if one of the specified fonts is already available.
+                for (const font of this._families) {
+                    if (document.fonts.check('1em ' + font)) {
+                        successHandler(font);
+                        return;
+                    }
+                }
+                // Slow path: Wait for fonts to be loaded sequentially
+                const promise = document.fonts.load(`1em ${this._families[0]}`);
+                promise.then(() => {
+                    Logger.debug('Font', `[${this._families[0]}] Font API signaled loaded`);
+                    if (document.fonts.check('1em ' + this._families[0])) {
+                        successHandler(this._families[0]);
                     }
                     else {
-                        Logger.debug('Font', `[${this._family}] Font API loaded reported, but font not available, checking later again`, null);
-                        window.setTimeout(() => {
-                            checkFont();
-                        }, 250);
+                        errorHandler();
                     }
                     return true;
+                }, reason => {
+                    errorHandler();
                 });
             };
-            checkFont();
+            document.fonts.ready.then(() => {
+                checkFont();
+            });
         }
     }
 
@@ -26899,9 +27021,9 @@
             this.registerFontChecker(settings.display.resources.subTitleFont);
         }
         registerFontChecker(font) {
-            if (!this._fontCheckers.has(font.family)) {
-                let checker = new FontLoadingChecker(font.family);
-                this._fontCheckers.set(font.family, checker);
+            if (!this._fontCheckers.has(font.families.join(', '))) {
+                let checker = new FontLoadingChecker(font.families);
+                this._fontCheckers.set(font.families.join(', '), checker);
                 checker.fontLoaded.on(this.onFontLoaded.bind(this));
                 checker.checkForFontAvailability();
             }
@@ -27876,7 +27998,7 @@
             if (!text) {
                 return 0;
             }
-            return FontSizes.measureString(text, this.font.family, this.font.size, this.font.style, this.font.weight);
+            return FontSizes.measureString(text, this.font.families, this.font.size, this.font.style, this.font.weight);
         }
         onRenderFinished() {
             // nothing to do
@@ -31368,7 +31490,7 @@
         renderTriplet(cx, cy, canvas) {
             cy += 2 * this.scale;
             let font = this.renderer.resources.effectFont;
-            canvas.font = new Font(font.family, font.size * 0.8, font.style);
+            canvas.font = Font.withFamilyList(font.families, font.size * 0.8, font.style);
             let rightX = cx + TripletFeelGlyph.NoteSeparation * this.scale + 3 * this.scale;
             canvas.beginPath();
             canvas.moveTo(cx, cy + 3 * this.scale);
@@ -32881,7 +33003,7 @@
             let size = 12 * this.renderer.settings.display.scale;
             let height = Math.floor(size * 2);
             const e = new RenderFinishedEventArgs();
-            const font = new Font(resources.copyrightFont.family, size, FontStyle.Plain, FontWeight.Bold);
+            const font = Font.withFamilyList(resources.copyrightFont.families, size, FontStyle.Plain, FontWeight.Bold);
             this.renderer.canvas.font = font;
             const centered = Environment.getLayoutEngineFactory(this.renderer.settings.display.layoutMode).vertical;
             e.width = this.renderer.canvas.measureText(msg);
@@ -38392,8 +38514,8 @@
         }
         paint(cx, cy, canvas) {
             let tabBarRenderer = this.renderer;
-            let startY = cy + this.x + (tabBarRenderer.getNoteY(this._beat.maxNote, NoteYPosition.Top));
-            let endY = cy + this.y + tabBarRenderer.getNoteY(this._beat.minNote, NoteYPosition.Bottom);
+            let startY = cy + this.x + (tabBarRenderer.getNoteY(this._beat.maxStringNote, NoteYPosition.Top));
+            let endY = cy + this.y + tabBarRenderer.getNoteY(this._beat.minStringNote, NoteYPosition.Bottom);
             let arrowX = (cx + this.x + this.width / 2) | 0;
             let arrowSize = 8 * this.scale;
             if (this._beat.brushType !== BrushType.None) {
@@ -40765,6 +40887,11 @@
                     Document.prototype.replaceChildren = Element.prototype.replaceChildren;
                     DocumentFragment.prototype.replaceChildren = Element.prototype.replaceChildren;
                 }
+                if (!('replaceAll' in String.prototype)) {
+                    String.prototype.replaceAll = function (str, newStr) {
+                        return this.replace(new RegExp(str, 'g'), newStr);
+                    };
+                }
             }
         }
         /**
@@ -40839,7 +40966,7 @@
     /**
      * @target web
      */
-    Environment.bravuraFontChecker = new FontLoadingChecker('alphaTab');
+    Environment.bravuraFontChecker = new FontLoadingChecker(['alphaTab']);
     Environment.renderEngines = Environment.createDefaultRenderEngines();
     Environment.layoutEngines = Environment.createDefaultLayoutEngines();
     Environment.staveProfiles = Environment.createDefaultStaveProfiles();
@@ -40984,8 +41111,8 @@
     // </auto-generated>
     class VersionInfo {
     }
-    VersionInfo.version = '1.3.0-alpha.355';
-    VersionInfo.date = '2022-08-09T00:56:55.506Z';
+    VersionInfo.version = '1.3.0-alpha.374';
+    VersionInfo.date = '2022-08-28T00:56:29.356Z';
 
     var index$5 = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -44049,13 +44176,18 @@
     var index = /*#__PURE__*/Object.freeze({
         __proto__: null,
         AlphaSynth: AlphaSynth,
+        CircularSampleBuffer: CircularSampleBuffer,
         PlaybackRange: PlaybackRange,
         get PlayerState () { return PlayerState; },
         PlayerStateChangedEventArgs: PlayerStateChangedEventArgs,
         PlaybackRangeChangedEventArgs: PlaybackRangeChangedEventArgs,
         PositionChangedEventArgs: PositionChangedEventArgs,
+        MidiEventsPlayedEventArgs: MidiEventsPlayedEventArgs,
         ActiveBeatsChangedEventArgs: ActiveBeatsChangedEventArgs,
-        AlphaSynthWebWorkerApi: AlphaSynthWebWorkerApi
+        AlphaSynthWebWorkerApi: AlphaSynthWebWorkerApi,
+        AlphaSynthWebAudioOutputBase: AlphaSynthWebAudioOutputBase,
+        AlphaSynthScriptProcessorOutput: AlphaSynthScriptProcessorOutput,
+        AlphaSynthAudioWorkletOutput: AlphaSynthAudioWorkletOutput
     });
 
     exports.AlphaTabApi = AlphaTabApi;