@scorelabs/core 1.0.3 → 1.0.5

package/dist/importers/MusicXMLParser.js

@@ -1,5 +1,6 @@
 import JSZip from 'jszip';
-import { Clef, Duration, Accidental, Articulation, BarlineStyle, } from '../models/types';
+import { getInstrumentByProgram } from '../models/Instrument';
+import { Clef, Duration, Accidental, Articulation, BarlineStyle, HairpinType, OttavaType, Ornament, Bowing, StemDirection, GlissandoType, NoteheadShape, Arpeggio, } from '../models/types';
 /**
  * MusicXML Parser
  *
@@ -10,10 +11,12 @@ export class MusicXMLParser {
     currentKeyFifths = 0;
     currentBeats = 4;
     currentBeatType = 4;
+    currentSymbol = 'normal';
     instrumentPitchMap = new Map();
     _domParser;
     constructor(domParserInstance) {
-        this._domParser = domParserInstance || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+        this._domParser =
+            domParserInstance || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
     }
     parseFromString(xmlString) {
         if (!this._domParser) {
@@ -45,37 +48,55 @@ export class MusicXMLParser {
     }
     parse(xmlString) {
         this.instrumentPitchMap.clear();
+        // Strip potential BOM and leading garbage
+        const firstBracket = xmlString.indexOf('<');
+        if (firstBracket === -1) {
+            const preview = xmlString.trim().substring(0, 50).replace(/\n/g, ' ');
+            throw new Error(`Invalid MusicXML: No '<' found in content. Content: "${preview}..."`);
+        }
+        xmlString = xmlString.substring(firstBracket).trim();
         const doc = this.parseFromString(xmlString);
         const parseError = doc.querySelector('parsererror');
-        if (parseError)
-            throw new Error(`XML parsing error: ${parseError.textContent}`);
+        if (parseError) {
+            const preview = xmlString.substring(0, 100).replace(/\n/g, ' ');
+            throw new Error(`XML parsing error: ${parseError.textContent}. Content preview: "${preview}..."`);
+        }
         const root = doc.documentElement;
         if (root.tagName !== 'score-partwise')
             throw new Error(`Unsupported format: ${root.tagName}`);
         const title = this.parseTitle(doc);
         const subtitle = this.parseSubtitle(doc);
         const composer = this.parseComposer(doc);
-        const partNames = this.parsePartList(doc);
-        const parts = this.parseParts(doc, partNames);
+        const partInfo = this.parsePartList(doc);
+        const parts = this.parseParts(doc, partInfo);
         let globalBpm = 120;
         let globalTempoDuration = Duration.Quarter;
         let globalTempoIsDotted = false;
+        let globalTempoText = '';
         if (parts.length > 0 && parts[0].staves.length > 0 && parts[0].staves[0].measures.length > 0) {
             const firstMeasure = parts[0].staves[0].measures[0];
             if (firstMeasure.tempo) {
                 globalBpm = firstMeasure.tempo.bpm;
                 globalTempoDuration = firstMeasure.tempo.duration;
                 globalTempoIsDotted = firstMeasure.tempo.isDotted;
+                globalTempoText = firstMeasure.tempo.text || '';
             }
         }
         const score = {
-            title, subtitle, composer,
-            timeSignature: { beats: this.currentBeats, beatType: this.currentBeatType },
+            title,
+            subtitle,
+            composer,
+            timeSignature: {
+                beats: this.currentBeats,
+                beatType: this.currentBeatType,
+                symbol: this.currentSymbol !== 'normal' ? this.currentSymbol : undefined,
+            },
             keySignature: { fifths: this.currentKeyFifths },
             parts,
             bpm: globalBpm,
             tempoDuration: globalTempoDuration,
             tempoIsDotted: globalTempoIsDotted,
+            tempoText: globalTempoText,
         };
         return this.postProcess(score);
     }
@@ -118,13 +139,27 @@ export class MusicXMLParser {
         return doc.querySelector('identification creator')?.textContent ?? 'Unknown';
     }
     parsePartList(doc) {
-        const partNames = new Map();
+        const partInfo = new Map();
         const scoreParts = doc.querySelectorAll('part-list score-part');
         for (const scorePart of Array.from(scoreParts)) {
             const id = scorePart.getAttribute('id');
-            const name = this.getText(scorePart, 'part-name');
-            if (id)
-                partNames.set(id, name?.trim() || 'Part');
+            const name = this.getText(scorePart, 'part-name') || 'Part';
+            let instrument = getInstrumentByProgram(0); // Default Piano
+            // Find first midi-instrument to determine main instrument
+            const firstMidiInst = scorePart.querySelector('midi-instrument');
+            if (firstMidiInst) {
+                const programStr = this.getText(firstMidiInst, 'midi-program');
+                if (programStr) {
+                    const program = parseInt(programStr);
+                    // MusicXML uses 1-128, MIDI uses 0-127. Adjust if needed.
+                    // Often it's accurate to 1-based, so checking bounds.
+                    // Assuming input is 1-based as per standard
+                    instrument = getInstrumentByProgram(Math.max(0, program - 1));
+                }
+            }
+            if (id) {
+                partInfo.set(id, { name: name.trim(), instrument });
+            }
             const midiInstruments = scorePart.querySelectorAll('midi-instrument');
             for (const midiInst of Array.from(midiInstruments)) {
                 const instId = midiInst.getAttribute('id');
@@ -133,15 +168,17 @@ export class MusicXMLParser {
                     this.instrumentPitchMap.set(instId, unpitched);
             }
         }
-        return partNames;
+        return partInfo;
     }
-    parseParts(doc, partNames) {
+    parseParts(doc, partInfo) {
         const parts = [];
         const partElements = doc.querySelectorAll('part');
         for (const partElement of Array.from(partElements)) {
             const id = partElement.getAttribute('id');
-            const name = partNames.get(id ?? '') ?? 'Part';
-            parts.push({ name, staves: this.parsePart(partElement) });
+            const info = partInfo.get(id ?? '');
+            const name = info?.name ?? 'Part';
+            const instrument = info?.instrument;
+            parts.push({ name, staves: this.parsePart(partElement), instrument });
         }
         return parts;
     }
@@ -154,7 +191,10 @@ export class MusicXMLParser {
             if (stavesNode)
                 numStaves = parseInt(stavesNode.textContent || '1');
         }
-        const staves = Array.from({ length: numStaves }, () => ({ clef: 'treble', measures: [] }));
+        const staves = Array.from({ length: numStaves }, () => ({
+            clef: 'treble',
+            measures: [],
+        }));
         const staffClefs = Array(numStaves).fill(Clef.Treble);
         for (const measureElement of Array.from(measureElements)) {
             let measureTimeSignature;
@@ -174,15 +214,20 @@ export class MusicXMLParser {
                     if (beatType !== null)
                         this.currentBeatType = beatType;
                     const timeElement = attributes.querySelector('time');
-                    let symbol = 'normal';
                     if (timeElement) {
                         const symAttr = timeElement.getAttribute('symbol');
                         if (symAttr === 'common')
-                            symbol = 'common';
-                        if (symAttr === 'cut')
-                            symbol = 'cut';
+                            this.currentSymbol = 'common';
+                        else if (symAttr === 'cut')
+                            this.currentSymbol = 'cut';
+                        else
+                            this.currentSymbol = 'normal';
                     }
-                    measureTimeSignature = { beats: this.currentBeats, beatType: this.currentBeatType, symbol };
+                    measureTimeSignature = {
+                        beats: this.currentBeats,
+                        beatType: this.currentBeatType,
+                        symbol: this.currentSymbol !== 'normal' ? this.currentSymbol : undefined,
+                    };
                 }
                 const clefElements = attributes.querySelectorAll('clef');
                 clefElements.forEach((clef) => {
@@ -205,25 +250,6 @@ export class MusicXMLParser {
             let rehearsalMark = undefined;
             let systemText = undefined;
             let contextDynamic = undefined;
-            const directions = measureElement.querySelectorAll('direction');
-            directions.forEach((dir) => {
-                const metronome = dir.querySelector('metronome');
-                if (metronome) {
-                    const beatUnit = this.getText(metronome, 'beat-unit') || 'quarter';
-                    const bpm = parseInt(this.getText(metronome, 'per-minute') || '120');
-                    const isDotted = metronome.querySelector('beat-unit-dot') !== null;
-                    measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
-                }
-                const rehearsal = dir.querySelector('rehearsal');
-                if (rehearsal)
-                    rehearsalMark = rehearsal.textContent || undefined;
-                const words = dir.querySelector('words');
-                if (words)
-                    systemText = words.textContent || undefined;
-                const dynamics = dir.querySelector('dynamics');
-                if (dynamics && dynamics.firstElementChild)
-                    contextDynamic = dynamics.firstElementChild.nodeName.toLowerCase();
-            });
             const { repeats, volta, barlineStyle } = this.parseBarlines(measureElement);
             const measureVoices = Array.from({ length: numStaves }, () => []);
             const children = Array.from(measureElement.children);
@@ -231,9 +257,72 @@ export class MusicXMLParser {
             let currentNoteSetMap = new Map();
             const beamGroupIdMap = new Map();
             let globalBeamId = 1;
+            let currentHairpin = undefined;
+            let currentOttava = undefined;
+            let currentPedal = undefined;
             children.forEach((child) => {
-                if (child.nodeName === 'harmony')
-                    pendingChord = this.parseHarmony(child);
+                if (child.nodeName === 'harmony') {
+                    const harmonyData = this.parseHarmony(child);
+                    if (harmonyData)
+                        pendingChord = harmonyData;
+                }
+                else if (child.nodeName === 'direction') {
+                    const metronome = child.querySelector('metronome');
+                    if (metronome) {
+                        const beatUnit = this.getText(metronome, 'beat-unit') || 'quarter';
+                        const bpm = parseInt(this.getText(metronome, 'per-minute') || '120');
+                        const isDotted = metronome.querySelector('beat-unit-dot') !== null;
+                        measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
+                    }
+                    const rehearsal = child.querySelector('rehearsal');
+                    if (rehearsal)
+                        rehearsalMark = rehearsal.textContent || undefined;
+                    const words = child.querySelector('words');
+                    if (words) {
+                        if (measureTempo)
+                            measureTempo.text = words.textContent || undefined;
+                        else
+                            systemText = words.textContent || undefined;
+                    }
+                    const wedge = child.querySelector('wedge');
+                    if (wedge) {
+                        const typeAttr = wedge.getAttribute('type');
+                        if (typeAttr === 'crescendo' || typeAttr === 'diminuendo' || typeAttr === 'stop') {
+                            currentHairpin = {
+                                type: typeAttr === 'crescendo' ? HairpinType.Crescendo : HairpinType.Decrescendo,
+                                placement: typeAttr === 'stop' ? 'stop' : 'start',
+                            };
+                        }
+                    }
+                    const octShift = child.querySelector('octave-shift');
+                    if (octShift) {
+                        const typeAttr = octShift.getAttribute('type');
+                        const size = parseInt(octShift.getAttribute('size') || '8');
+                        if (typeAttr === 'up' || typeAttr === 'down' || typeAttr === 'stop') {
+                            currentOttava = {
+                                type: size === 15
+                                    ? typeAttr === 'up'
+                                        ? OttavaType.QuindicesimaAlta
+                                        : OttavaType.QuindicesimaBassa
+                                    : typeAttr === 'up'
+                                        ? OttavaType.OttavaAlta
+                                        : OttavaType.OttavaBassa,
+                                placement: typeAttr === 'stop' ? 'stop' : 'start',
+                            };
+                        }
+                    }
+                    const pedalNode = child.querySelector('pedal');
+                    if (pedalNode) {
+                        const typeAttr = pedalNode.getAttribute('type');
+                        if (typeAttr === 'start' || typeAttr === 'stop') {
+                            currentPedal = { type: 'sustain', placement: typeAttr };
+                        }
+                    }
+                    const dynamics = child.querySelector('dynamics');
+                    if (dynamics && dynamics.firstElementChild) {
+                        contextDynamic = dynamics.firstElementChild.nodeName.toLowerCase();
+                    }
+                }
                 else if (child.nodeName === 'note') {
                     const staffNum = parseInt(this.getText(child, 'staff') || '1');
                     const staffIdx = Math.min(Math.max(staffNum - 1, 0), numStaves - 1);
@@ -258,13 +347,27 @@ export class MusicXMLParser {
                             }
                         }
                         if (pendingChord) {
-                            note.chord = pendingChord;
+                            note.chord = pendingChord.symbol;
+                            if (pendingChord.diagram)
+                                note.fretboardDiagram = pendingChord.diagram;
                             pendingChord = undefined;
                         }
                         if (contextDynamic) {
                             note.dynamic = contextDynamic;
                             contextDynamic = undefined;
                         }
+                        if (currentHairpin) {
+                            note.hairpin = currentHairpin;
+                            currentHairpin = undefined;
+                        }
+                        if (currentOttava) {
+                            note.ottava = currentOttava;
+                            currentOttava = undefined;
+                        }
+                        if (currentPedal) {
+                            note.pedal = currentPedal;
+                            currentPedal = undefined;
+                        }
                         if (isChord) {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
@@ -293,7 +396,7 @@ export class MusicXMLParser {
                     measureVoices[sIdx].push({ notes });
             }
             for (let i = 0; i < numStaves; i++) {
-                staves[i].measures.push({
+                const measure = {
                     voices: [measureVoices[i]],
                     timeSignature: measureTimeSignature,
                     keySignature: measureKeySignature,
@@ -304,7 +407,8 @@ export class MusicXMLParser {
                     rehearsalMark: i === 0 ? rehearsalMark : undefined,
                     systemText: i === 0 ? systemText : undefined,
                     barlineStyle,
-                });
+                };
+                staves[i].measures.push(measure);
                 staves[i].clef = staffClefs[i];
             }
         }
@@ -312,6 +416,7 @@ export class MusicXMLParser {
     }
     parseNote(noteElement) {
         const isRest = noteElement.querySelector('rest') !== null;
+        const isGrace = noteElement.querySelector('grace') !== null;
         const type = this.getText(noteElement, 'type');
         const duration = type ? this.mapDuration(type) : Duration.Quarter;
         const isDotted = noteElement.querySelector('dot') !== null;
@@ -356,11 +461,35 @@ export class MusicXMLParser {
         const noteheadEl = this.getText(noteElement, 'notehead');
         if (noteheadEl) {
             if (noteheadEl === 'x')
-                notehead = 'cross';
+                notehead = NoteheadShape.Cross;
             else if (['diamond', 'triangle', 'slash', 'square'].includes(noteheadEl))
                 notehead = noteheadEl;
         }
+        const stem = this.getText(noteElement, 'stem');
+        let stemDirection = undefined;
+        if (stem === 'up')
+            stemDirection = StemDirection.Up;
+        else if (stem === 'down')
+            stemDirection = StemDirection.Down;
         const notations = noteElement.querySelector('notations');
+        // Tuplet ratio
+        let tuplet = undefined;
+        const timeMod = noteElement.querySelector('time-modification');
+        if (timeMod) {
+            const actual = this.getNumber(timeMod, 'actual-notes') || 3;
+            const normal = this.getNumber(timeMod, 'normal-notes') || 2;
+            tuplet = { actual, normal, type: 'middle' };
+        }
+        if (notations) {
+            const tupletEl = notations.querySelector('tuplet');
+            if (tupletEl && tuplet) {
+                const type = tupletEl.getAttribute('type');
+                if (type === 'start')
+                    tuplet.type = 'start';
+                else if (type === 'stop')
+                    tuplet.type = 'stop';
+            }
+        }
         let slur = undefined;
         const slurEl = notations?.querySelector('slur');
         if (slurEl) {
@@ -375,48 +504,149 @@ export class MusicXMLParser {
             }
         }
         const tie = noteElement.querySelector('tie')?.getAttribute('type') === 'start' || undefined;
-        let articulation = undefined;
+        const articulations = [];
         const articEl = notations?.querySelector('articulations');
         if (articEl) {
             if (articEl.querySelector('staccato'))
-                articulation = Articulation.Staccato;
-            else if (articEl.querySelector('accent'))
-                articulation = Articulation.Accent;
-            else if (articEl.querySelector('tenuto'))
-                articulation = Articulation.Tenuto;
-            else if (articEl.querySelector('marcato'))
-                articulation = Articulation.Marcato;
-            else if (articEl.querySelector('staccatissimo'))
-                articulation = Articulation.Staccatissimo;
+                articulations.push(Articulation.Staccato);
+            if (articEl.querySelector('accent'))
+                articulations.push(Articulation.Accent);
+            if (articEl.querySelector('tenuto'))
+                articulations.push(Articulation.Tenuto);
+            if (articEl.querySelector('marcato'))
+                articulations.push(Articulation.Marcato);
+            if (articEl.querySelector('staccatissimo'))
+                articulations.push(Articulation.Staccatissimo);
+            if (articEl.querySelector('caesura'))
+                articulations.push(Articulation.Caesura);
+            if (articEl.querySelector('breath-mark'))
+                articulations.push(Articulation.BreathMark);
         }
         if (notations?.querySelector('fermata'))
-            articulation = Articulation.Fermata;
+            articulations.push(Articulation.Fermata);
+        let arpeggio = undefined;
+        const arpeggiateEl = notations?.querySelector('arpeggiate');
+        if (arpeggiateEl) {
+            const dir = arpeggiateEl.getAttribute('direction');
+            if (dir === 'up')
+                arpeggio = Arpeggio.Up;
+            else if (dir === 'down')
+                arpeggio = Arpeggio.Down;
+            else
+                arpeggio = Arpeggio.Normal;
+        }
+        const ornaments = notations?.querySelector('ornaments');
+        let ornament = undefined;
+        if (ornaments) {
+            if (ornaments.querySelector('trill-mark'))
+                ornament = Ornament.Trill;
+            else if (ornaments.querySelector('mordent'))
+                ornament = Ornament.Mordent;
+            else if (ornaments.querySelector('inverted-mordent'))
+                ornament = Ornament.InvertedMordent;
+            else if (ornaments.querySelector('turn'))
+                ornament = Ornament.Turn;
+            else if (ornaments.querySelector('inverted-turn'))
+                ornament = Ornament.InvertedTurn;
+            else if (ornaments.querySelector('tremolo'))
+                ornament = Ornament.Tremolo;
+        }
+        const technical = notations?.querySelector('technical');
+        let bowing = undefined;
+        let fingering = undefined;
+        let fret = undefined;
+        let stringNumber = undefined;
+        let isStringCircled = undefined;
+        let palmMute = undefined;
+        let hammerOn = undefined;
+        let pullOff = undefined;
+        if (technical) {
+            if (technical.querySelector('up-bow'))
+                bowing = Bowing.UpBow;
+            else if (technical.querySelector('down-bow'))
+                bowing = Bowing.DownBow;
+            const fingeringEl = technical.querySelector('fingering');
+            if (fingeringEl)
+                fingering = parseInt(fingeringEl.textContent || '0');
+            const fretEl = technical.querySelector('fret');
+            if (fretEl)
+                fret = parseInt(fretEl.textContent || '0');
+            const stringEl = technical.querySelector('string');
+            if (stringEl) {
+                stringNumber = parseInt(stringEl.textContent || '0');
+                isStringCircled = true;
+            }
+            const palmMuteEl = technical.querySelector('palm-mute');
+            if (palmMuteEl)
+                palmMute = palmMuteEl.getAttribute('type') || 'start';
+            const hammerOnEl = technical.querySelector('hammer-on');
+            if (hammerOnEl)
+                hammerOn = hammerOnEl.getAttribute('type') || 'start';
+            const pullOffEl = technical.querySelector('pull-off');
+            if (pullOffEl)
+                pullOff = pullOffEl.getAttribute('type') || 'start';
+        }
+        let glissando = undefined;
+        const glissEl = notations?.querySelector('glissando') || notations?.querySelector('slide');
+        if (glissEl) {
+            const type = glissEl.getAttribute('type');
+            if (type === 'start' || type === 'stop') {
+                glissando = {
+                    type: glissEl.nodeName === 'slide' ? GlissandoType.Straight : GlissandoType.Wavy,
+                    placement: type,
+                };
+            }
+        }
         const notesDyn = notations?.querySelector('dynamics');
         const dynamic = notesDyn?.firstElementChild?.nodeName.toLowerCase();
         const lyrics = [];
         noteElement.querySelectorAll('lyric').forEach((lyricEl) => {
-            let text = this.getText(lyricEl, 'text') || '';
+            const text = this.getText(lyricEl, 'text') || '';
             const syllabic = this.getText(lyricEl, 'syllabic');
+            const extend = lyricEl.querySelector('extend') !== null;
             const number = parseInt(lyricEl.getAttribute('number') || '1');
-            if (text) {
-                if (syllabic === 'begin' || syllabic === 'middle')
-                    text += '-';
-                lyrics[number - 1] = text;
+            if (text || extend) {
+                lyrics[number - 1] = {
+                    text,
+                    syllabic: syllabic || undefined,
+                    isExtension: extend || undefined,
+                };
             }
         });
         return {
-            duration, pitch: { midiNumber, step: this.stepToNumber(step), alter, octave },
-            isDotted, accidental, slur, tie, articulation, dynamic,
-            lyrics: lyrics.length > 0 ? lyrics : undefined, notehead,
+            duration,
+            pitch: { midiNumber, step: this.stepToNumber(step), alter, octave },
+            isDotted,
+            accidental,
+            slur,
+            tie,
+            articulations: articulations.length > 0 ? articulations : undefined,
+            dynamic,
+            arpeggio,
+            lyrics: lyrics.length > 0 ? lyrics : undefined,
+            notehead,
+            isGrace: isGrace || undefined,
+            tuplet,
+            ornament,
+            bowing,
+            fingering,
+            stemDirection,
+            glissando,
+            fret,
+            string: stringNumber,
+            isStringCircled,
+            palmMute,
+            hammerOn,
+            pullOff,
         };
     }
     parseHarmony(harmonyElement) {
         const root = harmonyElement.querySelector('root');
         if (!root)
-            return '';
+            return null;
         const step = this.getText(root, 'root-step');
         if (!step)
-            return '';
+            return null;
         const alter = this.getNumber(root, 'root-alter') || 0;
         const kind = this.getText(harmonyElement, 'kind') || 'major';
         let accidental = '';
@@ -470,6 +700,12 @@ export class MusicXMLParser {
                 kindNotation = 'm6';
                 break;
         }
+        // Parse Frame (Fretboard Diagram)
+        let diagram = undefined;
+        const frame = harmonyElement.querySelector('frame');
+        if (frame) {
+            diagram = this.parseFrame(frame);
+        }
         const bass = harmonyElement.querySelector('bass');
         let bassPart = '';
         if (bass) {
@@ -484,7 +720,58 @@ export class MusicXMLParser {
                 bassPart = '/' + bStep + bAcc;
             }
         }
-        return step + accidental + kindNotation + bassPart;
+        return { symbol: step + accidental + kindNotation + bassPart, diagram };
+    }
+    parseFrame(frame) {
+        const strings = this.getNumber(frame, 'frame-strings') || 6;
+        const frets = this.getNumber(frame, 'frame-frets') || 5;
+        const firstFret = this.getNumber(frame, 'first-fret') || 1;
+        const dots = [];
+        const barres = [];
+        const openStrings = [];
+        const mutedStrings = [];
+        const openBarres = new Map(); // fret -> startString
+        frame.querySelectorAll('frame-note').forEach((fn) => {
+            const string = this.getNumber(fn, 'string');
+            const fret = this.getNumber(fn, 'fret');
+            const fingering = this.getText(fn, 'fingering');
+            const barre = fn.querySelector('barre')?.getAttribute('type'); // start/stop
+            if (string !== null && fret !== null) {
+                if (fret === 0) {
+                    openStrings.push(string);
+                }
+                else {
+                    dots.push({ string, fret, label: fingering || undefined });
+                }
+                if (barre === 'start') {
+                    openBarres.set(fret, string);
+                }
+                else if (barre === 'stop') {
+                    const startString = openBarres.get(fret);
+                    if (startString !== undefined) {
+                        barres.push({
+                            fret,
+                            startString: Math.min(startString, string),
+                            endString: Math.max(startString, string),
+                        });
+                        openBarres.delete(fret);
+                    }
+                }
+            }
+        });
+        // MusicXML handling of barres is complex (start/stop on strings).
+        // Simple implementation: Group dots/barres later or parse strictly if provided.
+        // For now, let's extract basic dots.
+        // Note: Real parsing of barres requires tracking the 'start' and 'stop' across strings for the same fret.
+        return {
+            strings,
+            frets,
+            startingFret: firstFret,
+            dots,
+            barres: barres.length > 0 ? barres : undefined,
+            openStrings: openStrings.length > 0 ? openStrings : undefined,
+            mutedStrings: mutedStrings.length > 0 ? mutedStrings : undefined,
+        };
     }
     parseBarlines(measureElement) {
         const repeats = [];
@@ -502,7 +789,11 @@ export class MusicXMLParser {
                     barlineStyle = BarlineStyle.Dotted;
             }
             if (barline.querySelector('repeat'))
-                repeats.push({ type: barline.querySelector('repeat')?.getAttribute('direction') === 'forward' ? 'start' : 'end' });
+                repeats.push({
+                    type: barline.querySelector('repeat')?.getAttribute('direction') === 'forward'
+                        ? 'start'
+                        : 'end',
+                });
             const ending = barline.querySelector('ending');
             if (ending) {
                 const type = ending.getAttribute('type');
@@ -554,7 +845,12 @@ export class MusicXMLParser {
                                         state[step] = alter;
                                 }
                                 else if (state[step] !== alter) {
-                                    note.accidental = alter === 0 ? Accidental.Natural : alter === 1 ? Accidental.Sharp : Accidental.Flat;
+                                    note.accidental =
+                                        alter === 0
+                                            ? Accidental.Natural
+                                            : alter === 1
+                                                ? Accidental.Sharp
+                                                : Accidental.Flat;
                                     state[step] = alter;
                                 }
                             });
@@ -569,17 +865,31 @@ export class MusicXMLParser {
         return (octave + 1) * 12 + (steps[step.toUpperCase()] ?? 0) + alter;
     }
     mapDuration(type) {
-        const map = { whole: Duration.Whole, half: Duration.Half, quarter: Duration.Quarter, eighth: Duration.Eighth, '16th': Duration.Sixteenth, '32nd': Duration.ThirtySecond, '64th': Duration.SixtyFourth };
+        const map = {
+            whole: Duration.Whole,
+            half: Duration.Half,
+            quarter: Duration.Quarter,
+            eighth: Duration.Eighth,
+            '16th': Duration.Sixteenth,
+            '32nd': Duration.ThirtySecond,
+            '64th': Duration.SixtyFourth,
+        };
         return map[type] ?? Duration.Quarter;
     }
     mapClef(sign, line = 0) {
         switch (sign.toUpperCase()) {
-            case 'G': return Clef.Treble;
-            case 'F': return Clef.Bass;
-            case 'C': return line === 4 ? Clef.Tenor : Clef.Alto;
-            case 'PERCUSSION': return Clef.Percussion;
-            case 'TAB': return Clef.Tab;
-            default: return Clef.Treble;
+            case 'G':
+                return Clef.Treble;
+            case 'F':
+                return Clef.Bass;
+            case 'C':
+                return line === 4 ? Clef.Tenor : Clef.Alto;
+            case 'PERCUSSION':
+                return Clef.Percussion;
+            case 'TAB':
+                return Clef.Tab;
+            default:
+                return Clef.Treble;
         }
     }
     mapAccidental(alter) {