@scorelabs/core 1.0.7 → 1.0.10

package/dist/importers/MusicXMLParser.js

@@ -1,6 +1,6 @@
 import JSZip from 'jszip';
-import { getInstrumentByProgram } from '../models/Instrument';
-import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, } from '../models/types';
+import { getInstrumentByProgram, guessInstrumentByName } from '../models/Instrument';
+import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, DURATION_VALUES, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, decomposeDuration, } from '../models/types';
 /**
  * MusicXML Parser
  *
@@ -18,6 +18,52 @@ export class MusicXMLParser {
         this._domParser =
             domParserInstance || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
     }
+    querySelector(el, selector) {
+        if (el.querySelector)
+            return el.querySelector(selector);
+        const parts = selector.split(' ');
+        let current = el;
+        for (const part of parts) {
+            if (!current)
+                return null;
+            const results = current.getElementsByTagName(part);
+            if (results.length === 0)
+                return null;
+            current = results[0];
+        }
+        return current;
+    }
+    getChildren(el) {
+        const parent = el;
+        if (parent.children)
+            return Array.from(parent.children);
+        return Array.from(el.childNodes).filter((node) => node.nodeType === 1);
+    }
+    getFirstElementChild(el) {
+        if (el.firstElementChild)
+            return el.firstElementChild;
+        const children = this.getChildren(el);
+        return children.length > 0 ? children[0] : null;
+    }
+    querySelectorAll(el, selector) {
+        if (el.querySelectorAll)
+            return Array.from(el.querySelectorAll(selector));
+        const parts = selector.split(' ');
+        if (parts.length === 1) {
+            return Array.from(el.getElementsByTagName(parts[0]));
+        }
+        // Simple nested selector support (only two levels for now as needed)
+        if (parts.length === 2) {
+            const firstLevel = Array.from(el.getElementsByTagName(parts[0]));
+            const results = [];
+            firstLevel.forEach((parent) => {
+                const children = Array.from(parent.getElementsByTagName(parts[1]));
+                results.push(...children);
+            });
+            return results;
+        }
+        return [];
+    }
     parseFromString(xmlString) {
         if (!this._domParser) {
             throw new Error('No DOMParser available. Please provide one in the constructor for Node.js environments.');
@@ -35,7 +81,7 @@ export class MusicXMLParser {
             if (!_parser)
                 throw new Error('No DOMParser available');
             const containerDoc = _parser.parseFromString(containerXml, 'application/xml');
-            const rootfile = containerDoc.querySelector('rootfile');
+            const rootfile = (new MusicXMLParser(_parser)).querySelector(containerDoc, 'rootfile');
             const fullPath = rootfile?.getAttribute('full-path');
             if (!fullPath)
                 throw new Error('Invalid MXL: Could not find main score file path');
@@ -63,7 +109,7 @@ export class MusicXMLParser {
         }
         xmlString = xmlString.substring(firstBracket).trim();
         const doc = this.parseFromString(xmlString);
-        const parseError = doc.querySelector('parsererror');
+        const parseError = this.querySelector(doc, 'parsererror');
         if (parseError) {
             const preview = xmlString.substring(0, 100).replace(/\n/g, ' ');
             throw new Error(`XML parsing error: ${parseError.textContent}. Content preview: "${preview}..."`);
@@ -74,6 +120,7 @@ export class MusicXMLParser {
         const title = this.parseTitle(doc);
         const subtitle = this.parseSubtitle(doc);
         const composer = this.parseComposer(doc);
+        const copyright = this.parseCopyright(doc);
         const partInfo = this.parsePartList(doc);
         const parts = this.parseParts(doc, partInfo);
         let globalBpm = 120;
@@ -104,6 +151,7 @@ export class MusicXMLParser {
             tempoDuration: globalTempoDuration,
             tempoIsDotted: globalTempoIsDotted,
             tempoText: globalTempoText,
+            copyright,
         };
         return this.postProcess(score);
     }
@@ -111,7 +159,7 @@ export class MusicXMLParser {
         let subtitle = this.getText(doc.documentElement, 'movement-subtitle');
         if (subtitle)
             return subtitle;
-        const work = doc.querySelector('work');
+        const work = this.querySelector(doc, 'work');
         if (work) {
             subtitle = this.getText(work, 'work-subtitle');
             if (subtitle)
@@ -120,11 +168,11 @@ export class MusicXMLParser {
             if (subtitle)
                 return subtitle;
         }
-        const credits = doc.querySelectorAll('credit');
+        const credits = this.querySelectorAll(doc, 'credit');
         for (const credit of Array.from(credits)) {
-            const type = credit.querySelector('credit-type');
+            const type = this.querySelector(credit, 'credit-type');
             if (type?.textContent?.toLowerCase() === 'subtitle') {
-                const words = credit.querySelector('credit-words');
+                const words = this.querySelector(credit, 'credit-words');
                 if (words?.textContent)
                     return words.textContent;
             }
@@ -137,37 +185,65 @@ export class MusicXMLParser {
             title = this.getText(doc.documentElement, 'movement-title');
         return title ?? 'Untitled';
     }
+    parseCopyright(doc) {
+        const identification = this.querySelector(doc, 'identification');
+        if (identification) {
+            const rights = this.getText(identification, 'rights');
+            if (rights)
+                return rights;
+        }
+        const credits = this.querySelectorAll(doc, 'credit');
+        for (const credit of Array.from(credits)) {
+            const type = this.querySelector(credit, 'credit-type');
+            if (type?.textContent?.toLowerCase() === 'rights' ||
+                type?.textContent?.toLowerCase() === 'copyright') {
+                const words = this.querySelector(credit, 'credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return '';
+    }
     parseComposer(doc) {
-        const creators = doc.querySelectorAll('identification creator');
+        const creators = this.querySelectorAll(doc, 'identification creator');
         for (const creator of Array.from(creators)) {
             if (creator.getAttribute('type') === 'composer')
                 return creator.textContent ?? 'Unknown';
         }
-        return doc.querySelector('identification creator')?.textContent ?? 'Unknown';
+        return this.querySelector(doc, 'identification creator')?.textContent ?? 'Unknown';
     }
     parsePartList(doc) {
         const partInfo = new Map();
-        const scoreParts = doc.querySelectorAll('part-list score-part');
+        const scoreParts = this.querySelectorAll(doc, 'part-list score-part');
         for (const scorePart of Array.from(scoreParts)) {
             const id = scorePart.getAttribute('id');
             const name = this.getText(scorePart, 'part-name') || 'Part';
-            let instrument = getInstrumentByProgram(0); // Default Piano
+            let instrument;
             // Find first midi-instrument to determine main instrument
-            const firstMidiInst = scorePart.querySelector('midi-instrument');
+            const firstMidiInst = this.querySelector(scorePart, '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));
                 }
             }
+            // Fallback: guess by part name
+            if (!instrument || instrument.sound === 'piano') {
+                const guessed = guessInstrumentByName(name);
+                // Only override if the guess is more specific than default piano
+                if (guessed.sound !== 'piano') {
+                    instrument = guessed;
+                }
+            }
+            // Final default
+            if (!instrument) {
+                instrument = getInstrumentByProgram(0);
+            }
             if (id) {
                 partInfo.set(id, { name: name.trim(), instrument });
             }
-            const midiInstruments = scorePart.querySelectorAll('midi-instrument');
+            const midiInstruments = this.querySelectorAll(scorePart, 'midi-instrument');
             for (const midiInst of Array.from(midiInstruments)) {
                 const instId = midiInst.getAttribute('id');
                 const unpitched = this.getNumber(midiInst, 'midi-unpitched');
@@ -179,7 +255,7 @@ export class MusicXMLParser {
     }
     parseParts(doc, partInfo) {
         const parts = [];
-        const partElements = doc.querySelectorAll('part');
+        const partElements = this.querySelectorAll(doc, 'part');
         for (const partElement of Array.from(partElements)) {
             const id = partElement.getAttribute('id');
             const info = partInfo.get(id ?? '');
@@ -190,11 +266,11 @@ export class MusicXMLParser {
         return parts;
     }
     parsePart(partElement) {
-        const measureElements = partElement.querySelectorAll('measure');
+        const measureElements = this.querySelectorAll(partElement, 'measure');
         let numStaves = 1;
-        const firstMeasure = partElement.querySelector('measure');
+        const firstMeasure = this.querySelector(partElement, 'measure');
         if (firstMeasure) {
-            const stavesNode = firstMeasure.querySelector('attributes staves');
+            const stavesNode = this.querySelector(firstMeasure, 'attributes staves');
             if (stavesNode)
                 numStaves = parseInt(stavesNode.textContent || '1');
         }
@@ -203,12 +279,17 @@ export class MusicXMLParser {
             measures: [],
         }));
         const staffClefs = Array(numStaves).fill(Clef.Treble);
-        for (const measureElement of Array.from(measureElements)) {
+        const lastVoicePerStaff = new Map();
+        let divisions = 1;
+        for (const [mIdx, measureElement] of Array.from(measureElements).entries()) {
             let measureTimeSignature;
             let measureKeySignature;
-            const isPickup = measureElement.getAttribute('implicit') === 'yes';
-            const attributes = measureElement.querySelector('attributes');
+            let isPickup = measureElement.getAttribute('implicit') === 'yes';
+            const attributes = this.querySelector(measureElement, 'attributes');
             if (attributes) {
+                const divNode = this.querySelector(attributes, 'divisions');
+                if (divNode)
+                    divisions = parseInt(divNode.textContent || '1');
                 const fifths = this.getNumber(attributes, 'key fifths');
                 if (fifths !== null) {
                     this.currentKeyFifths = fifths;
@@ -220,7 +301,7 @@ export class MusicXMLParser {
                     this.currentBeats = beats;
                     if (beatType !== null)
                         this.currentBeatType = beatType;
-                    const timeElement = attributes.querySelector('time');
+                    const timeElement = this.querySelector(attributes, 'time');
                     if (timeElement) {
                         const symAttr = timeElement.getAttribute('symbol');
                         if (symAttr === 'common')
@@ -236,16 +317,18 @@ export class MusicXMLParser {
                         symbol: this.currentSymbol !== 'normal' ? this.currentSymbol : undefined,
                     };
                 }
-                const clefElements = attributes.querySelectorAll('clef');
+                const clefElements = this.querySelectorAll(attributes, 'clef');
                 clefElements.forEach((clef) => {
-                    const number = parseInt(clef.getAttribute('number') || '1');
+                    const numberAttrs = clef.getAttribute('number');
+                    const number = numberAttrs ? parseInt(numberAttrs) : 1;
                     const sign = this.getText(clef, 'sign');
                     if (sign && number <= numStaves) {
                         const line = this.getNumber(clef, 'line') || 0;
-                        staffClefs[number - 1] = this.mapClef(sign, line);
+                        const octaveChange = this.getNumber(clef, 'clef-octave-change') || 0;
+                        staffClefs[number - 1] = this.mapClef(sign, line, octaveChange);
                     }
                 });
-                const staffDetails = attributes.querySelectorAll('staff-details');
+                const staffDetails = this.querySelectorAll(attributes, 'staff-details');
                 staffDetails.forEach((sd) => {
                     const number = parseInt(sd.getAttribute('number') || '1');
                     const lines = this.getNumber(sd, 'staff-lines');
@@ -258,8 +341,11 @@ export class MusicXMLParser {
             let systemText = undefined;
             let contextDynamic = undefined;
             const { repeats, volta, barlineStyle } = this.parseBarlines(measureElement);
-            const measureVoices = Array.from({ length: numStaves }, () => []);
-            const children = Array.from(measureElement.children);
+            // Map of staffIndex -> Map of voiceId -> NoteSetJSON[]
+            const staffVoices = new Map();
+            for (let i = 0; i < numStaves; i++)
+                staffVoices.set(i, new Map());
+            const children = this.getChildren(measureElement);
             let pendingChord = undefined;
             let currentNoteSetMap = new Map();
             const beamGroupIdMap = new Map();
@@ -274,24 +360,24 @@ export class MusicXMLParser {
                         pendingChord = harmonyData;
                 }
                 else if (child.nodeName === 'direction') {
-                    const metronome = child.querySelector('metronome');
+                    const metronome = this.querySelector(child, '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;
+                        const isDotted = this.querySelector(metronome, 'beat-unit-dot') !== null;
                         measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
                     }
-                    const rehearsal = child.querySelector('rehearsal');
+                    const rehearsal = this.querySelector(child, 'rehearsal');
                     if (rehearsal)
                         rehearsalMark = rehearsal.textContent || undefined;
-                    const words = child.querySelector('words');
+                    const words = this.querySelector(child, 'words');
                     if (words) {
                         if (measureTempo)
                             measureTempo.text = words.textContent || undefined;
                         else
                             systemText = words.textContent || undefined;
                     }
-                    const wedge = child.querySelector('wedge');
+                    const wedge = this.querySelector(child, 'wedge');
                     if (wedge) {
                         const typeAttr = wedge.getAttribute('type');
                         if (typeAttr === 'crescendo' || typeAttr === 'diminuendo' || typeAttr === 'stop') {
@@ -301,7 +387,7 @@ export class MusicXMLParser {
                             };
                         }
                     }
-                    const octShift = child.querySelector('octave-shift');
+                    const octShift = this.querySelector(child, 'octave-shift');
                     if (octShift) {
                         const typeAttr = octShift.getAttribute('type');
                         const size = parseInt(octShift.getAttribute('size') || '8');
@@ -318,25 +404,27 @@ export class MusicXMLParser {
                             };
                         }
                     }
-                    const pedalNode = child.querySelector('pedal');
+                    const pedalNode = this.querySelector(child, '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();
+                    const dynamics = this.querySelector(child, 'dynamics');
+                    if (dynamics) {
+                        const firstChild = this.getFirstElementChild(dynamics);
+                        if (firstChild)
+                            contextDynamic = firstChild.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);
-                    const isChord = child.querySelector('chord') !== null;
+                    const isChord = this.querySelector(child, 'chord') !== null;
                     const note = this.parseNote(child);
                     if (note) {
-                        const beamEl = child.querySelector('beam[number="1"]');
+                        const beamEl = this.querySelector(child, 'beam[number="1"]');
                         if (beamEl) {
                             const beamType = beamEl.textContent;
                             if (beamType === 'begin') {
@@ -375,6 +463,12 @@ export class MusicXMLParser {
                             note.pedal = currentPedal;
                             currentPedal = undefined;
                         }
+                        const voiceId = this.getText(child, 'voice') || '1';
+                        lastVoicePerStaff.set(staffIdx, voiceId);
+                        const voiceMap = staffVoices.get(staffIdx);
+                        if (!voiceMap.has(voiceId))
+                            voiceMap.set(voiceId, []);
+                        const voiceNoteSets = voiceMap.get(voiceId);
                         if (isChord) {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
@@ -385,26 +479,65 @@ export class MusicXMLParser {
                         else {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
-                                measureVoices[staffIdx].push({ notes: existing });
+                                voiceNoteSets.push({ notes: existing });
                             currentNoteSetMap.set(staffIdx, [note]);
                         }
                     }
                 }
                 else if (child.nodeName === 'backup' || child.nodeName === 'forward') {
                     for (const [sIdx, notes] of currentNoteSetMap.entries()) {
-                        if (notes.length > 0)
-                            measureVoices[sIdx].push({ notes });
+                        if (notes.length > 0) {
+                            const voiceId = lastVoicePerStaff.get(sIdx) || '1';
+                            const voiceMap = staffVoices.get(sIdx);
+                            if (!voiceMap.has(voiceId))
+                                voiceMap.set(voiceId, []);
+                            voiceMap.get(voiceId).push({ notes });
+                        }
                     }
                     currentNoteSetMap.clear();
                 }
             });
+            // Cleanup: push remaining notes
             for (const [sIdx, notes] of currentNoteSetMap.entries()) {
-                if (notes.length > 0)
-                    measureVoices[sIdx].push({ notes });
+                if (notes.length > 0) {
+                    const voiceId = lastVoicePerStaff.get(sIdx) || '1';
+                    const voiceMap = staffVoices.get(sIdx);
+                    if (!voiceMap.has(voiceId))
+                        voiceMap.set(voiceId, []);
+                    voiceMap.get(voiceId).push({ notes });
+                }
+            }
+            // Check if it's a pickup measure if mIdx is 0 and implicit is not set
+            if (mIdx === 0 && !isPickup) {
+                // Calculate the actual duration of the first staff's first voice
+                const vMap0 = staffVoices.get(0);
+                const v1 = vMap0.get('1') || vMap0.get(Array.from(vMap0.keys())[0]);
+                if (v1) {
+                    // Check duration of first voice in first staff
+                    const expectedDivisions = this.currentBeats * (divisions * 4 / this.currentBeatType);
+                    let totalMeasureDivs = 0;
+                    const notes = this.querySelectorAll(measureElement, 'note');
+                    // Find first voice in first staff
+                    for (const n of notes) {
+                        if ((this.getText(n, 'staff') || '1') === '1' && (this.getText(n, 'voice') || '1') === (Array.from(vMap0.keys())[0] || '1')) {
+                            if (this.querySelector(n, 'chord'))
+                                continue;
+                            totalMeasureDivs += this.getNumber(n, 'duration') || 0;
+                        }
+                    }
+                    if (totalMeasureDivs > 0 && totalMeasureDivs < expectedDivisions - 1) {
+                        isPickup = true;
+                    }
+                }
             }
             for (let i = 0; i < numStaves; i++) {
+                const vMap = staffVoices.get(i);
+                let voicesIndices = Array.from(vMap.keys()).sort();
+                if (voicesIndices.length === 0)
+                    voicesIndices = ['1'];
+                const voices = voicesIndices.map(id => vMap.get(id) || []);
                 const measure = {
-                    voices: [measureVoices[i]],
+                    voices: voices,
                     timeSignature: measureTimeSignature,
                     keySignature: measureKeySignature,
                     isPickup: isPickup || undefined,
@@ -415,6 +548,30 @@ export class MusicXMLParser {
                     systemText: i === 0 ? systemText : undefined,
                     barlineStyle,
                 };
+                // Padding with rests if not a pickup
+                if (!isPickup) {
+                    const targetDur = (this.currentBeats * 4) / this.currentBeatType;
+                    measure.voices = measure.voices.map((v) => {
+                        const currentDur = v.reduce((sum, ns) => {
+                            const base = DURATION_VALUES[ns.notes[0].duration];
+                            return sum + (ns.notes[0].isDotted ? base * 1.5 : base);
+                        }, 0);
+                        if (currentDur < targetDur - 0.001) {
+                            const gap = targetDur - currentDur;
+                            const rests = decomposeDuration(gap).map((d) => ({
+                                notes: [
+                                    {
+                                        duration: d.duration,
+                                        isRest: true,
+                                        isDotted: d.isDotted,
+                                    },
+                                ],
+                            }));
+                            return [...v, ...rests];
+                        }
+                        return v;
+                    });
+                }
                 staves[i].measures.push(measure);
                 staves[i].clef = staffClefs[i];
             }
@@ -422,21 +579,21 @@ export class MusicXMLParser {
         return staves;
     }
     parseNote(noteElement) {
-        const isRest = noteElement.querySelector('rest') !== null;
-        const isGrace = noteElement.querySelector('grace') !== null;
+        const isRest = this.querySelector(noteElement, 'rest') !== null;
+        const isGrace = this.querySelector(noteElement, 'grace') !== null;
         const type = this.getText(noteElement, 'type');
         const duration = type ? this.mapDuration(type) : Duration.Quarter;
-        const isDotted = noteElement.querySelector('dot') !== null;
+        const isDotted = this.querySelector(noteElement, 'dot') !== null;
         if (isRest)
             return { duration, isRest: true, isDotted };
         let step = 'C', octave = 4, alter = 0;
-        const unpitched = noteElement.querySelector('unpitched');
+        const unpitched = this.querySelector(noteElement, 'unpitched');
         if (unpitched) {
             step = this.getText(unpitched, 'display-step') || 'C';
             octave = this.getNumber(unpitched, 'display-octave') ?? 4;
         }
         else {
-            const pitch = noteElement.querySelector('pitch');
+            const pitch = this.querySelector(noteElement, 'pitch');
             if (!pitch)
                 return null;
             step = this.getText(pitch, 'step') || 'C';
@@ -444,7 +601,7 @@ export class MusicXMLParser {
             alter = this.getNumber(pitch, 'alter') ?? 0;
         }
         let midiNumber = this.pitchToMidi(step, octave, alter);
-        const instrument = noteElement.querySelector('instrument');
+        const instrument = this.querySelector(noteElement, 'instrument');
         if (instrument) {
             const instId = instrument.getAttribute('id');
             if (instId && this.instrumentPitchMap.has(instId))
@@ -478,17 +635,17 @@ export class MusicXMLParser {
             stemDirection = StemDirection.Up;
         else if (stem === 'down')
             stemDirection = StemDirection.Down;
-        const notations = noteElement.querySelector('notations');
+        const notations = this.querySelector(noteElement, 'notations');
         // Tuplet ratio
         let tuplet = undefined;
-        const timeMod = noteElement.querySelector('time-modification');
+        const timeMod = this.querySelector(noteElement, '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');
+            const tupletEl = this.querySelector(notations, 'tuplet');
             if (tupletEl && tuplet) {
                 const type = tupletEl.getAttribute('type');
                 if (type === 'start')
@@ -498,7 +655,7 @@ export class MusicXMLParser {
             }
         }
         let slur = undefined;
-        const slurEl = notations?.querySelector('slur');
+        const slurEl = notations ? this.querySelector(notations, 'slur') : null;
         if (slurEl) {
             const type = slurEl.getAttribute('type');
             if (type === 'start' || type === 'stop') {
@@ -510,29 +667,29 @@ export class MusicXMLParser {
                     slur.direction = 'down';
             }
         }
-        const tie = noteElement.querySelector('tie')?.getAttribute('type') === 'start' || undefined;
+        const tie = this.querySelector(noteElement, 'tie')?.getAttribute('type') === 'start' || undefined;
         const articulations = [];
-        const articEl = notations?.querySelector('articulations');
+        const articEl = notations ? this.querySelector(notations, 'articulations') : null;
         if (articEl) {
-            if (articEl.querySelector('staccato'))
+            if (this.querySelector(articEl, 'staccato'))
                 articulations.push(Articulation.Staccato);
-            if (articEl.querySelector('accent'))
+            if (this.querySelector(articEl, 'accent'))
                 articulations.push(Articulation.Accent);
-            if (articEl.querySelector('tenuto'))
+            if (this.querySelector(articEl, 'tenuto'))
                 articulations.push(Articulation.Tenuto);
-            if (articEl.querySelector('marcato'))
+            if (this.querySelector(articEl, 'marcato'))
                 articulations.push(Articulation.Marcato);
-            if (articEl.querySelector('staccatissimo'))
+            if (this.querySelector(articEl, 'staccatissimo'))
                 articulations.push(Articulation.Staccatissimo);
-            if (articEl.querySelector('caesura'))
+            if (this.querySelector(articEl, 'caesura'))
                 articulations.push(Articulation.Caesura);
-            if (articEl.querySelector('breath-mark'))
+            if (this.querySelector(articEl, 'breath-mark'))
                 articulations.push(Articulation.BreathMark);
         }
-        if (notations?.querySelector('fermata'))
+        if (notations && this.querySelector(notations, 'fermata'))
             articulations.push(Articulation.Fermata);
         let arpeggio = undefined;
-        const arpeggiateEl = notations?.querySelector('arpeggiate');
+        const arpeggiateEl = notations ? this.querySelector(notations, 'arpeggiate') : null;
         if (arpeggiateEl) {
             const dir = arpeggiateEl.getAttribute('direction');
             if (dir === 'up')
@@ -542,23 +699,23 @@ export class MusicXMLParser {
             else
                 arpeggio = Arpeggio.Normal;
         }
-        const ornaments = notations?.querySelector('ornaments');
+        const ornaments = notations ? this.querySelector(notations, 'ornaments') : null;
         let ornament = undefined;
         if (ornaments) {
-            if (ornaments.querySelector('trill-mark'))
+            if (this.querySelector(ornaments, 'trill-mark'))
                 ornament = Ornament.Trill;
-            else if (ornaments.querySelector('mordent'))
+            else if (this.querySelector(ornaments, 'mordent'))
                 ornament = Ornament.Mordent;
-            else if (ornaments.querySelector('inverted-mordent'))
+            else if (this.querySelector(ornaments, 'inverted-mordent'))
                 ornament = Ornament.InvertedMordent;
-            else if (ornaments.querySelector('turn'))
+            else if (this.querySelector(ornaments, 'turn'))
                 ornament = Ornament.Turn;
-            else if (ornaments.querySelector('inverted-turn'))
+            else if (this.querySelector(ornaments, 'inverted-turn'))
                 ornament = Ornament.InvertedTurn;
-            else if (ornaments.querySelector('tremolo'))
+            else if (this.querySelector(ornaments, 'tremolo'))
                 ornament = Ornament.Tremolo;
         }
-        const technical = notations?.querySelector('technical');
+        const technical = notations ? this.querySelector(notations, 'technical') : null;
         let bowing = undefined;
         let fingering = undefined;
         let fret = undefined;
@@ -568,33 +725,33 @@ export class MusicXMLParser {
         let hammerOn = undefined;
         let pullOff = undefined;
         if (technical) {
-            if (technical.querySelector('up-bow'))
+            if (this.querySelector(technical, 'up-bow'))
                 bowing = Bowing.UpBow;
-            else if (technical.querySelector('down-bow'))
+            else if (this.querySelector(technical, 'down-bow'))
                 bowing = Bowing.DownBow;
-            const fingeringEl = technical.querySelector('fingering');
+            const fingeringEl = this.querySelector(technical, 'fingering');
             if (fingeringEl)
                 fingering = parseInt(fingeringEl.textContent || '0');
-            const fretEl = technical.querySelector('fret');
+            const fretEl = this.querySelector(technical, 'fret');
             if (fretEl)
                 fret = parseInt(fretEl.textContent || '0');
-            const stringEl = technical.querySelector('string');
+            const stringEl = this.querySelector(technical, 'string');
             if (stringEl) {
                 stringNumber = parseInt(stringEl.textContent || '0');
                 isStringCircled = true;
             }
-            const palmMuteEl = technical.querySelector('palm-mute');
+            const palmMuteEl = this.querySelector(technical, 'palm-mute');
             if (palmMuteEl)
                 palmMute = palmMuteEl.getAttribute('type') || 'start';
-            const hammerOnEl = technical.querySelector('hammer-on');
+            const hammerOnEl = this.querySelector(technical, 'hammer-on');
             if (hammerOnEl)
                 hammerOn = hammerOnEl.getAttribute('type') || 'start';
-            const pullOffEl = technical.querySelector('pull-off');
+            const pullOffEl = this.querySelector(technical, 'pull-off');
             if (pullOffEl)
                 pullOff = pullOffEl.getAttribute('type') || 'start';
         }
         let glissando = undefined;
-        const glissEl = notations?.querySelector('glissando') || notations?.querySelector('slide');
+        const glissEl = notations ? (this.querySelector(notations, 'glissando') || this.querySelector(notations, 'slide')) : null;
         if (glissEl) {
             const type = glissEl.getAttribute('type');
             if (type === 'start' || type === 'stop') {
@@ -604,13 +761,14 @@ export class MusicXMLParser {
                 };
             }
         }
-        const notesDyn = notations?.querySelector('dynamics');
-        const dynamic = notesDyn?.firstElementChild?.nodeName.toLowerCase();
+        const notesDyn = notations ? this.querySelector(notations, 'dynamics') : null;
+        const firstChild = notesDyn ? this.getFirstElementChild(notesDyn) : null;
+        const dynamic = firstChild?.nodeName.toLowerCase();
         const lyrics = [];
-        noteElement.querySelectorAll('lyric').forEach((lyricEl) => {
+        this.querySelectorAll(noteElement, 'lyric').forEach((lyricEl) => {
             const text = this.getText(lyricEl, 'text') || '';
             const syllabic = this.getText(lyricEl, 'syllabic');
-            const extend = lyricEl.querySelector('extend') !== null;
+            const extend = this.querySelector(lyricEl, 'extend') !== null;
             const number = parseInt(lyricEl.getAttribute('number') || '1');
             if (text || extend) {
                 lyrics[number - 1] = {
@@ -648,7 +806,7 @@ export class MusicXMLParser {
         };
     }
     parseHarmony(harmonyElement) {
-        const root = harmonyElement.querySelector('root');
+        const root = this.querySelector(harmonyElement, 'root');
         if (!root)
             return null;
         const step = this.getText(root, 'root-step');
@@ -709,11 +867,11 @@ export class MusicXMLParser {
         }
         // Parse Frame (Fretboard Diagram)
         let diagram = undefined;
-        const frame = harmonyElement.querySelector('frame');
+        const frame = this.querySelector(harmonyElement, 'frame');
         if (frame) {
             diagram = this.parseFrame(frame);
         }
-        const bass = harmonyElement.querySelector('bass');
+        const bass = this.querySelector(harmonyElement, 'bass');
         let bassPart = '';
         if (bass) {
             const bStep = this.getText(bass, 'bass-step');
@@ -738,11 +896,11 @@ export class MusicXMLParser {
         const openStrings = [];
         const mutedStrings = [];
         const openBarres = new Map(); // fret -> startString
-        frame.querySelectorAll('frame-note').forEach((fn) => {
+        this.querySelectorAll(frame, '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
+            const barre = this.querySelector(fn, 'barre')?.getAttribute('type'); // start/stop
             if (string !== null && fret !== null) {
                 if (fret === 0) {
                     openStrings.push(string);
@@ -784,7 +942,7 @@ export class MusicXMLParser {
         const repeats = [];
         let volta = undefined;
         let barlineStyle = BarlineStyle.Regular;
-        measureElement.querySelectorAll('barline').forEach((barline) => {
+        this.querySelectorAll(measureElement, 'barline').forEach((barline) => {
             const location = barline.getAttribute('location') || 'right';
             const barStyle = this.getText(barline, 'bar-style');
             if (location === 'right') {
@@ -795,7 +953,7 @@ export class MusicXMLParser {
                 else if (barStyle === 'dotted')
                     barlineStyle = BarlineStyle.Dotted;
             }
-            const repeatEl = barline.querySelector('repeat');
+            const repeatEl = this.querySelector(barline, 'repeat');
             if (repeatEl) {
                 const direction = repeatEl.getAttribute('direction');
                 const times = repeatEl.getAttribute('times');
@@ -804,7 +962,7 @@ export class MusicXMLParser {
                     times: times ? parseInt(times) : undefined,
                 });
             }
-            const ending = barline.querySelector('ending');
+            const ending = this.querySelector(barline, 'ending');
             if (ending) {
                 const type = ending.getAttribute('type');
                 const numberAttr = ending.getAttribute('number') || '1';
@@ -891,12 +1049,12 @@ export class MusicXMLParser {
         };
         return map[type] ?? Duration.Quarter;
     }
-    mapClef(sign, line = 0) {
+    mapClef(sign, line = 0, octaveChange = 0) {
         switch (sign.toUpperCase()) {
             case 'G':
-                return Clef.Treble;
+                return octaveChange === -1 ? Clef.Treble8vaBassa : Clef.Treble;
             case 'F':
-                return Clef.Bass;
+                return octaveChange === -1 ? Clef.Bass8vaBassa : Clef.Bass;
             case 'C':
                 return line === 4 ? Clef.Tenor : Clef.Alto;
             case 'PERCUSSION':
@@ -925,7 +1083,7 @@ export class MusicXMLParser {
         return map[step.toUpperCase()] ?? 0;
     }
     getText(element, tagName) {
-        const child = element.querySelector(tagName);
+        const child = this.querySelector(element, tagName);
         return child?.textContent ?? null;
     }
     getNumber(element, tagName) {