@scorelabs/core 1.0.9 → 1.0.11

package/dist/importers/MusicXMLParser.js

@@ -1,6 +1,7 @@
 import JSZip from 'jszip';
-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';
+import { getInstrumentByProgram, guessInstrumentByName } from '../models/Instrument.js';
+import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, calculateDurationValue, decomposeDuration, } from '../models/types.js';
+// TODO: Write tests for MusicXMLParser. It is important to test it thoroughly.
 /**
  * MusicXML Parser
  *
@@ -18,6 +19,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 +82,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 +110,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,12 +121,15 @@ export class MusicXMLParser {
         const title = this.parseTitle(doc);
         const subtitle = this.parseSubtitle(doc);
         const composer = this.parseComposer(doc);
+        const lyricist = this.parseLyricist(doc);
+        const copyright = this.parseCopyright(doc);
         const partInfo = this.parsePartList(doc);
         const parts = this.parseParts(doc, partInfo);
         let globalBpm = 120;
         let globalTempoDuration = Duration.Quarter;
         let globalTempoIsDotted = false;
         let globalTempoText = '';
+        let globalTempoDotCount = 0;
         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) {
@@ -87,6 +137,7 @@ export class MusicXMLParser {
                 globalTempoDuration = firstMeasure.tempo.duration;
                 globalTempoIsDotted = firstMeasure.tempo.isDotted;
                 globalTempoText = firstMeasure.tempo.text || '';
+                globalTempoDotCount = firstMeasure.tempo.dotCount || 0;
             }
         }
         const score = {
@@ -104,6 +155,9 @@ export class MusicXMLParser {
             tempoDuration: globalTempoDuration,
             tempoIsDotted: globalTempoIsDotted,
             tempoText: globalTempoText,
+            tempoDotCount: globalTempoDotCount,
+            copyright,
+            lyricist,
         };
         return this.postProcess(score);
     }
@@ -111,7 +165,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 +174,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,23 +191,73 @@ 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';
+        // If no type="composer", but there is only one creator, assume it's the composer
+        if (creators.length === 1)
+            return (creators[0].textContent ?? 'Unknown');
+        // Check credits for composer type
+        const credits = this.querySelectorAll(doc, 'credit');
+        for (const credit of Array.from(credits)) {
+            const type = this.querySelector(credit, 'credit-type');
+            if (type?.textContent?.toLowerCase() === 'composer') {
+                const words = this.querySelector(credit, 'credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return creators.length > 0 ? creators[0].textContent ?? 'Unknown' : 'Unknown';
+    }
+    parseLyricist(doc) {
+        const creators = this.querySelectorAll(doc, 'identification creator');
+        for (const creator of Array.from(creators)) {
+            if (creator.getAttribute('type') === 'lyricist')
+                return creator.textContent ?? '';
+        }
+        // Check credits for lyricist type
+        const credits = this.querySelectorAll(doc, 'credit');
+        for (const credit of Array.from(credits)) {
+            const type = this.querySelector(credit, 'credit-type');
+            if (type?.textContent?.toLowerCase() === 'lyricist') {
+                const words = this.querySelector(credit, 'credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return '';
     }
     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;
             // 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) {
@@ -176,7 +280,7 @@ export class MusicXMLParser {
             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');
@@ -188,7 +292,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 ?? '');
@@ -199,11 +303,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');
         }
@@ -212,12 +316,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;
@@ -229,7 +338,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')
@@ -245,9 +354,10 @@ 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;
@@ -255,7 +365,7 @@ export class MusicXMLParser {
                         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');
@@ -272,9 +382,9 @@ export class MusicXMLParser {
             const staffVoices = new Map();
             for (let i = 0; i < numStaves; i++)
                 staffVoices.set(i, new Map());
-            const children = Array.from(measureElement.children);
+            const children = this.getChildren(measureElement);
             let pendingChord = undefined;
-            let currentNoteSetMap = new Map();
+            const currentNoteSetMap = new Map();
             const beamGroupIdMap = new Map();
             let globalBeamId = 1;
             let currentHairpin = undefined;
@@ -287,24 +397,25 @@ 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;
-                        measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
+                        const dotCount = this.querySelectorAll(metronome, 'beat-unit-dot').length;
+                        const isDotted = dotCount > 0;
+                        measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted, dotCount };
                     }
-                    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') {
@@ -314,7 +425,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');
@@ -331,25 +442,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') {
@@ -389,6 +502,7 @@ export class MusicXMLParser {
                             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, []);
@@ -411,7 +525,7 @@ export class MusicXMLParser {
                 else if (child.nodeName === 'backup' || child.nodeName === 'forward') {
                     for (const [sIdx, notes] of currentNoteSetMap.entries()) {
                         if (notes.length > 0) {
-                            const voiceId = this.getText(child.previousElementSibling, 'voice') || '1';
+                            const voiceId = lastVoicePerStaff.get(sIdx) || '1';
                             const voiceMap = staffVoices.get(sIdx);
                             if (!voiceMap.has(voiceId))
                                 voiceMap.set(voiceId, []);
@@ -421,22 +535,46 @@ export class MusicXMLParser {
                     currentNoteSetMap.clear();
                 }
             });
+            // Cleanup: push remaining notes
             for (const [sIdx, notes] of currentNoteSetMap.entries()) {
                 if (notes.length > 0) {
-                    // Last note in measure
-                    const voiceId = '1'; // Defaulting to 1 for final push if not tracked
+                    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 voices = voicesIndices.map((id) => vMap.get(id) || []);
                 const measure = {
                     voices: voices,
                     timeSignature: measureTimeSignature,
@@ -454,8 +592,7 @@ export class MusicXMLParser {
                     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);
+                            return sum + calculateDurationValue(ns.notes[0].duration, ns.notes[0].dotCount || (ns.notes[0].isDotted ? 1 : 0));
                         }, 0);
                         if (currentDur < targetDur - 0.001) {
                             const gap = targetDur - currentDur;
@@ -480,21 +617,22 @@ 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 dotCount = this.querySelectorAll(noteElement, 'dot').length;
+        const isDotted = dotCount > 0;
         if (isRest)
-            return { duration, isRest: true, isDotted };
+            return { duration, isRest: true, isDotted, dotCount };
         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';
@@ -502,7 +640,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))
@@ -536,17 +674,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')
@@ -556,7 +694,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') {
@@ -568,29 +706,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')
@@ -600,23 +738,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;
@@ -626,33 +764,35 @@ 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') {
@@ -662,13 +802,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] = {
@@ -682,6 +823,7 @@ export class MusicXMLParser {
             duration,
             pitch: { midiNumber, step: this.stepToNumber(step), alter, octave },
             isDotted,
+            dotCount,
             accidental,
             slur,
             tie,
@@ -706,7 +848,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');
@@ -767,11 +909,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');
@@ -796,11 +938,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);
@@ -842,7 +984,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') {
@@ -853,7 +995,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');
@@ -862,7 +1004,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';
@@ -983,7 +1125,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) {