@scorelabs/core 1.0.11 → 1.1.0

package/dist/models/Score.js

@@ -12,7 +12,6 @@ export class Score {
     parts;
     bpm;
     tempoDuration;
-    tempoIsDotted;
     copyright;
     lyricist;
     swing;
@@ -20,7 +19,7 @@ export class Score {
     genre;
     tempoText;
     tempoDotCount;
-    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, tempoIsDotted = false, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown, tempoText = '', tempoDotCount = 0) {
+    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown, tempoText = '', tempoDotCount = 0) {
         this.title = title;
         this.composer = composer;
         this.timeSignature = timeSignature;
@@ -28,7 +27,6 @@ export class Score {
         this.parts = parts;
         this.bpm = bpm;
         this.tempoDuration = tempoDuration;
-        this.tempoIsDotted = tempoIsDotted;
         this.copyright = copyright;
         this.lyricist = lyricist;
         this.swing = swing;
@@ -38,19 +36,19 @@ export class Score {
         this.tempoDotCount = tempoDotCount;
     }
     withTitle(title) {
-        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withComposer(composer) {
-        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withSubtitle(subtitle) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withGenre(genre) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, genre, this.tempoText, this.tempoDotCount);
     }
     withBpm(bpm) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     getMeasureCount() {
         return this.parts[0]?.getMeasureCount() ?? 0;
@@ -93,7 +91,7 @@ export class Score {
     }
     static fromJSON(data) {
         const parts = data.parts.map((p) => Part.fromJSON(p));
-        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.tempoIsDotted ?? false, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown, data.tempoText ?? '', data.tempoDotCount ?? (data.tempoIsDotted ? 1 : 0));
+        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown, data.tempoText ?? '', data.tempoDotCount ?? (data.tempoIsDotted ? 1 : 0));
     }
     transpose(semitones) {
         const semitoneToFifths = {
@@ -117,7 +115,7 @@ export class Score {
             newFifths -= 12;
         while (newFifths < -7)
             newFifths += 12;
-        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     replaceNote(partIndex, staffIndex, measureIndex, noteIndex, newNote, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
@@ -127,16 +125,15 @@ export class Score {
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
     withKeySignature(keySig) {
-        return new Score(this.title, this.composer, this.timeSignature, keySig, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, keySig, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withTimeSignature(timeSig) {
-        return new Score(this.title, this.composer, timeSig, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, timeSig, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     updateMeasureSignatures(measureIndex, signatures, autoBeam = true) {
-        let score = this;
-        for (let pIdx = 0; pIdx < this.parts.length; pIdx++) {
-            for (let sIdx = 0; sIdx < this.parts[pIdx].staves.length; sIdx++) {
-                const currentMsr = score.parts[pIdx].staves[sIdx].measures[measureIndex];
+        const newParts = this.parts.map((part) => {
+            const newStaves = part.staves.map((staff) => {
+                const currentMsr = staff.measures[measureIndex];
                 if (currentMsr) {
                     let updatedMsr = currentMsr;
                     if (signatures.keySignature !== undefined) {
@@ -148,45 +145,51 @@ export class Score {
                     if (signatures.clef !== undefined) {
                         updatedMsr = updatedMsr.withClef(signatures.clef);
                     }
-                    score = score.replaceMeasure(pIdx, sIdx, measureIndex, updatedMsr, autoBeam);
+                    if (autoBeam) {
+                        const ts = signatures.timeSignature ?? this.getTimeSignatureAt(measureIndex);
+                        updatedMsr = updatedMsr.autoBeam(ts);
+                    }
+                    const newMeasures = [...staff.measures];
+                    newMeasures[measureIndex] = updatedMsr;
+                    return staff.withMeasures(newMeasures);
                 }
-            }
-        }
+                return staff;
+            });
+            return part.withStaves(newStaves);
+        });
+        const newScore = this.withParts(newParts);
         if (signatures.timeSignature !== undefined) {
-            score = score.reflow(measureIndex, autoBeam);
+            return newScore.reflow(measureIndex, autoBeam);
         }
-        return score;
+        return newScore;
     }
     /**
      * Reflows the notes starting from a specific measure index.
      * This is useful when time signatures change and notes need to be redistributed.
      */
     reflow(fromMeasureIndex, autoBeam = true) {
-        let currentScore = this;
         const allStaves = this.getAllStaves();
-        for (const { partIndex, staffIndex } of allStaves) {
-            currentScore = currentScore.reflowStaff(partIndex, staffIndex, fromMeasureIndex, autoBeam);
-        }
+        const scoreAfterReflow = allStaves.reduce((accScore, { partIndex, staffIndex }) => accScore.reflowStaff(partIndex, staffIndex, fromMeasureIndex, autoBeam), this);
         // Harmonize measure count across all staves
-        const maxMeasures = Math.max(...currentScore.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
-        const minMeasures = Math.min(...currentScore.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
+        const maxMeasures = Math.max(...scoreAfterReflow.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
+        const minMeasures = Math.min(...scoreAfterReflow.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
         if (maxMeasures !== minMeasures) {
-            for (let pIdx = 0; pIdx < currentScore.parts.length; pIdx++) {
-                for (let sIdx = 0; sIdx < currentScore.parts[pIdx].staves.length; sIdx++) {
-                    const staff = currentScore.parts[pIdx].staves[sIdx];
+            return scoreAfterReflow.parts.reduce((accScore1, part, pIdx) => {
+                return part.staves.reduce((accScore2, staff, sIdx) => {
                     if (staff.measures.length < maxMeasures) {
                         const updatedMsrs = [...staff.measures];
                         for (let i = staff.measures.length; i < maxMeasures; i++) {
-                            const ts = currentScore.getTimeSignatureAt(i);
+                            const ts = accScore2.getTimeSignatureAt(i);
                             const targetDur = ts.beats * (4 / ts.beatType);
                             updatedMsrs.push(new Measure([[]]).fillVoiceWithRests(0, targetDur));
                         }
-                        currentScore = currentScore.replaceStaff(pIdx, sIdx, staff.withMeasures(updatedMsrs));
+                        return accScore2.replaceStaff(pIdx, sIdx, staff.withMeasures(updatedMsrs));
                     }
-                }
-            }
+                    return accScore2;
+                }, accScore1);
+            }, scoreAfterReflow);
         }
-        return currentScore;
+        return scoreAfterReflow;
     }
     isTied(ns) {
         return !!ns.notes[0].tie;
@@ -256,7 +259,7 @@ export class Score {
                     const newNoteSets = parts.map((p, idx) => {
                         const isLastOfLogical = Math.abs(toTake - logicalNote.duration) < 0.001 && idx === parts.length - 1;
                         return logicalNote.ns
-                            .withDuration(p.duration, p.isDotted)
+                            .withDuration(p.duration, p.dotCount)
                             .withTie(isLastOfLogical ? !!logicalNote.ns.notes[0].tie : true);
                     });
                     msr = msr.withVoices(msr.voices.map((v, i) => (i === vIdx ? [...v, ...newNoteSets] : v)));
@@ -300,7 +303,7 @@ export class Score {
         }
         const newParts = [...this.parts];
         newParts[partIndex] = newParts[partIndex].replaceMeasure(staffIndex, measureIndex, measureToUse);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     deleteNote(partIndex, staffIndex, measureIndex, noteIndex, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
@@ -309,11 +312,11 @@ export class Score {
         const updatedMeasure = measure.deleteNote(noteIndex, voiceIndex);
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
-    changeNoteDuration(partIndex, staffIndex, measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+    changeNoteDuration(partIndex, staffIndex, measureIndex, noteIndex, newDuration, dotCount = 0, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const measure = this.parts[partIndex].staves[staffIndex].measures[measureIndex];
-        const updatedMeasure = measure.changeNoteDuration(noteIndex, newDuration, isDotted, voiceIndex);
+        const updatedMeasure = measure.changeNoteDuration(noteIndex, newDuration, dotCount, voiceIndex);
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
     moveNoteToVoice(partIndex, staffIndex, measureIndex, noteIndex, fromVoiceIndex, toVoiceIndex) {
@@ -328,78 +331,80 @@ export class Score {
     pasteNotes(partIndex, staffIndex, measureIndex, noteIndex, notesToPaste) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
-        let newScore = this;
-        let currentMeasureIdx = measureIndex;
-        let currentNoteIdx = noteIndex;
-        const queue = [...notesToPaste];
-        while (queue.length > 0) {
-            const noteToPaste = queue.shift();
-            const part = newScore.parts[partIndex];
+        const state = {
+            score: this,
+            mIdx: measureIndex,
+            nIdx: noteIndex,
+            queue: [...notesToPaste],
+        };
+        while (state.queue.length > 0) {
+            const noteToPaste = state.queue.shift();
+            const part = state.score.parts[partIndex];
             if (!part)
                 break;
             const staff = part.staves[staffIndex];
-            if (!staff || currentMeasureIdx >= staff.measures.length)
+            if (!staff || state.mIdx >= staff.measures.length)
                 break;
-            const measure = staff.measures[currentMeasureIdx];
-            if (currentNoteIdx >= measure.notes.length) {
-                currentMeasureIdx++;
-                currentNoteIdx = 0;
-                queue.unshift(noteToPaste);
+            const measure = staff.measures[state.mIdx];
+            if (state.nIdx >= measure.notes.length) {
+                state.mIdx++;
+                state.nIdx = 0;
+                state.queue.unshift(noteToPaste);
                 continue;
             }
             let available = 0;
-            for (let i = currentNoteIdx; i < measure.notes.length; i++)
+            for (let i = state.nIdx; i < measure.notes.length; i++)
                 available += measure.notes[i].getDurationValue();
             const needed = noteToPaste.getDurationValue();
             if (needed <= available + 0.001) {
-                newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, noteToPaste.duration, noteToPaste.isDotted);
-                newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, noteToPaste);
-                currentNoteIdx++;
+                state.score = state.score.changeNoteDuration(partIndex, staffIndex, state.mIdx, state.nIdx, noteToPaste.duration, noteToPaste.dotCount);
+                state.score = state.score.replaceNote(partIndex, staffIndex, state.mIdx, state.nIdx, noteToPaste);
+                state.nIdx++;
             }
             else {
                 const parts = decomposeDuration(available);
                 if (parts.length === 0) {
-                    currentMeasureIdx++;
-                    currentNoteIdx = 0;
-                    queue.unshift(noteToPaste);
+                    state.mIdx++;
+                    state.nIdx = 0;
+                    state.queue.unshift(noteToPaste);
                     continue;
                 }
                 const fillPart = parts[0];
                 const filledNote = noteToPaste
-                    .withDuration(fillPart.duration, fillPart.isDotted)
+                    .withDuration(fillPart.duration, fillPart.dotCount)
                     .withTie(true);
-                newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, fillPart.duration, fillPart.isDotted);
-                newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, filledNote);
+                state.score = state.score.changeNoteDuration(partIndex, staffIndex, state.mIdx, state.nIdx, fillPart.duration, fillPart.dotCount);
+                state.score = state.score.replaceNote(partIndex, staffIndex, state.mIdx, state.nIdx, filledNote);
                 const remainderParts = decomposeDuration(needed - fillPart.val);
                 const remainderNotes = remainderParts.map((p, idx) => {
                     const isLast = idx === remainderParts.length - 1;
                     return noteToPaste
-                        .withDuration(p.duration, p.isDotted)
-                        .withTie(isLast ? !!noteToPaste.tie : true);
+                        .withDuration(p.duration, p.dotCount)
+                        .withTie(isLast ? !!noteToPaste.notes[0].tie : true);
                 });
-                queue.unshift(...remainderNotes);
-                currentNoteIdx++;
+                state.queue.unshift(...remainderNotes);
+                state.nIdx++;
             }
         }
-        return newScore;
+        return state.score;
     }
-    withTempo(bpm, duration, isDotted) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, isDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+    withTempo(bpm, duration, dotCount = 0) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, dotCount);
     }
     withTempoText(text) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, text);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, text, this.tempoDotCount);
     }
     withSwing(swing) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withLyricist(lyricist) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withCopyright(copyright) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withParts(parts) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     toJSON() {
         return {
@@ -410,7 +415,6 @@ export class Score {
             parts: this.parts.map((p) => p.toJSON()),
             bpm: this.bpm,
             tempoDuration: this.tempoDuration,
-            tempoIsDotted: this.tempoIsDotted,
             copyright: this.copyright,
             lyricist: this.lyricist,
             swing: this.swing,
@@ -425,92 +429,111 @@ export class Score {
             return this;
         const newParts = [...this.parts];
         newParts[partIndex] = newPart;
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     addPart(newPart) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     removePart(partIndex) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const newParts = this.parts.filter((_, i) => i !== partIndex);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     replaceStaff(partIndex, staffIndex, newStaff) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const newParts = [...this.parts];
         newParts[partIndex] = newParts[partIndex].replaceStaff(staffIndex, newStaff);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     addMeasure(index, measure) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     deleteMeasure(index) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+    }
+    deleteMeasures(startIndex, endIndex) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let currentScore = this;
+        const start = Math.min(startIndex, endIndex);
+        const end = Math.max(startIndex, endIndex);
+        for (let i = end; i >= start; i--) {
+            currentScore = currentScore.deleteMeasure(i);
+        }
+        return currentScore;
     }
     getPlaybackSequence() {
         const measures = this.parts[0]?.staves[0]?.measures || [];
         const sequence = [];
         let i = 0;
         const startRepeatStack = [0]; // Implicit start at 0
-        let justJumpedTo = -1;
-        const repeatCount = new Map();
+        const iterationMap = new Map(); // startMeasureIndex -> currentIteration
+        iterationMap.set(0, 1);
+        const repeatJumpCount = new Map(); // endMeasureIndex -> count
         let safetyCounter = 0;
         const MAX_SEQUENCE = 10000;
+        let activeVoltaNumbers = [];
+        let pendingPop = false;
         while (i < measures.length && safetyCounter < MAX_SEQUENCE) {
             safetyCounter++;
             const m = measures[i];
-            // Handle Start Repeats
+            // If we finished a repeat pass but the next measure still has a volta, 
+            // we delay popping the stack so the volta logic can see the correct iteration count.
+            if (pendingPop && !m.volta) {
+                if (startRepeatStack.length > 1) {
+                    startRepeatStack.pop();
+                }
+                pendingPop = false;
+            }
+            // 1. Handle Start Repeat
             if (m.repeats.some((r) => r.type === 'start')) {
-                // Only push if we didn't just jump here (avoid re-pushing on loop reentry)
-                if (i !== justJumpedTo) {
+                if (startRepeatStack[startRepeatStack.length - 1] !== i) {
                     startRepeatStack.push(i);
+                    iterationMap.set(i, 1);
                 }
             }
-            // Reset jump flag after processing start repeats check
-            if (i !== justJumpedTo)
-                justJumpedTo = -1;
-            const endRepeat = m.repeats.find((r) => r.type === 'end');
-            let iteration = 1;
-            // Calculate current iteration for Volta logic
-            if (endRepeat)
-                iteration = (repeatCount.get(i) || 0) + 1;
-            else {
-                let nextEndIdx = -1;
-                for (let j = i; j < measures.length; j++) {
-                    if (measures[j].repeats.some((r) => r.type === 'end')) {
-                        nextEndIdx = j;
-                        break;
-                    }
+            // 2. Identify current repetition context
+            const currentStartIdx = startRepeatStack[startRepeatStack.length - 1];
+            const iteration = iterationMap.get(currentStartIdx) || 1;
+            // 3. Volta Logic
+            if (m.volta) {
+                if (m.volta.type === 'start' || m.volta.type === 'both') {
+                    activeVoltaNumbers = m.volta.numbers;
                 }
-                if (nextEndIdx !== -1)
-                    iteration = (repeatCount.get(nextEndIdx) || 0) + 1;
             }
-            if (m.volta && !m.volta.numbers.includes(iteration)) {
-                i++;
-                continue;
+            const effectiveNumbers = (m.volta && m.volta.numbers.length > 0)
+                ? m.volta.numbers
+                : activeVoltaNumbers;
+            const hasVoltaContext = m.volta || activeVoltaNumbers.length > 0;
+            const shouldSkip = hasVoltaContext &&
+                effectiveNumbers.length > 0 &&
+                !effectiveNumbers.includes(iteration);
+            if (!shouldSkip) {
+                sequence.push(i);
+            }
+            // 4. Reset volta if stopped
+            if (m.volta && (m.volta.type === 'stop' || m.volta.type === 'both')) {
+                activeVoltaNumbers = [];
             }
-            sequence.push(i);
+            // 5. Handle End Repeat
+            const endRepeat = m.repeats.find((r) => r.type === 'end');
             if (endRepeat) {
                 const maxTimes = endRepeat.times || 2;
-                const currentCount = repeatCount.get(i) || 0;
+                const currentCount = repeatJumpCount.get(i) || 0;
                 if (currentCount + 1 < maxTimes) {
-                    repeatCount.set(i, currentCount + 1);
-                    // Jump to the nearest start repeat
-                    const target = startRepeatStack[startRepeatStack.length - 1];
-                    i = target;
-                    justJumpedTo = target;
-                    continue;
+                    repeatJumpCount.set(i, currentCount + 1);
+                    iterationMap.set(currentStartIdx, iteration + 1);
+                    i = currentStartIdx;
+                    activeVoltaNumbers = []; // Reset volta context when jumping back
+                    pendingPop = false;
+                    continue; // Jump back
                 }
                 else {
-                    // Finished loop
-                    repeatCount.set(i, 0);
-                    // Pop the start repeat if we have one (keeping the implicit 0)
-                    if (startRepeatStack.length > 1) {
-                        startRepeatStack.pop();
-                    }
-                    // Do not pop 0, so unmatched repeats will default to 0
+                    // Finished this repeat group
+                    repeatJumpCount.set(i, 0);
+                    pendingPop = true;
+                    activeVoltaNumbers = [];
                 }
             }
             i++;

package/dist/models/Staff.d.ts

@@ -17,7 +17,7 @@ export declare class Staff {
     replaceNote(measureIndex: number, noteIndex: number, newNote: Note, voiceIndex?: number): Staff;
     replaceMeasure(measureIndex: number, newMeasure: Measure): Staff;
     deleteNote(measureIndex: number, noteIndex: number, voiceIndex?: number): Staff;
-    changeNoteDuration(measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Staff;
+    changeNoteDuration(measureIndex: number, noteIndex: number, newDuration: Duration, dotCount?: number, voiceIndex?: number): Staff;
     toJSON(): StaffJSON;
     withClef(clef: Clef): Staff;
     withLineCount(lineCount: number): Staff;

package/dist/models/Staff.js

@@ -46,11 +46,11 @@ export class Staff {
         newMeasures[measureIndex] = newMeasures[measureIndex].deleteNote(noteIndex, voiceIndex);
         return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
     }
-    changeNoteDuration(measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+    changeNoteDuration(measureIndex, noteIndex, newDuration, dotCount = 0, voiceIndex = 0) {
         if (measureIndex < 0 || measureIndex >= this.measures.length)
             return this;
         const newMeasures = [...this.measures];
-        newMeasures[measureIndex] = newMeasures[measureIndex].changeNoteDuration(noteIndex, newDuration, isDotted, voiceIndex);
+        newMeasures[measureIndex] = newMeasures[measureIndex].changeNoteDuration(noteIndex, newDuration, dotCount, voiceIndex);
         return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
     }
     toJSON() {

package/dist/types/AccidentalDisplay.d.ts

@@ -0,0 +1,6 @@
+export interface AccidentalDisplay {
+    cautionary?: boolean;
+    editorial?: boolean;
+    parenthesized?: boolean;
+    bracketed?: boolean;
+}

package/dist/types/AccidentalDisplay.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Arpeggio.d.ts

@@ -1,5 +1,6 @@
 export declare enum Arpeggio {
     Normal = "normal",
     Up = "up",
-    Down = "down"
+    Down = "down",
+    NonArpeggiate = "non-arpeggiate"
 }

package/dist/types/Arpeggio.js

@@ -3,4 +3,5 @@ export var Arpeggio;
     Arpeggio["Normal"] = "normal";
     Arpeggio["Up"] = "up";
     Arpeggio["Down"] = "down";
+    Arpeggio["NonArpeggiate"] = "non-arpeggiate";
 })(Arpeggio || (Arpeggio = {}));

package/dist/types/Articulation.d.ts

@@ -6,5 +6,7 @@ export declare enum Articulation {
     Fermata = "fermata",
     Staccatissimo = "staccatissimo",
     Caesura = "caesura",
-    BreathMark = "breath-mark"
+    BreathMark = "breath-mark",
+    Legato = "legato",
+    Portato = "portato"
 }

package/dist/types/Articulation.js

@@ -8,4 +8,6 @@ export var Articulation;
     Articulation["Staccatissimo"] = "staccatissimo";
     Articulation["Caesura"] = "caesura";
     Articulation["BreathMark"] = "breath-mark";
+    Articulation["Legato"] = "legato";
+    Articulation["Portato"] = "portato";
 })(Articulation || (Articulation = {}));

package/dist/types/Beam.d.ts

@@ -0,0 +1,4 @@
+export type BeamValue = 'begin' | 'continue' | 'end' | 'forward hook' | 'backward hook';
+export interface BeamLevels {
+    [level: number]: BeamValue;
+}

package/dist/types/Beam.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Duration.d.ts

@@ -19,6 +19,6 @@ export declare function calculateDurationValue(duration: Duration, dotCount?: nu
  */
 export declare function decomposeDuration(value: number): {
     duration: Duration;
-    isDotted: boolean;
+    dotCount: number;
     val: number;
 }[];

package/dist/types/Duration.js

@@ -42,26 +42,26 @@ export function decomposeDuration(value) {
     const result = [];
     let remaining = value;
     const options = [
-        { val: 4, dur: Duration.Whole, dot: false },
-        { val: 3, dur: Duration.Half, dot: true },
-        { val: 2, dur: Duration.Half, dot: false },
-        { val: 1.5, dur: Duration.Quarter, dot: true },
-        { val: 1, dur: Duration.Quarter, dot: false },
-        { val: 0.75, dur: Duration.Eighth, dot: true },
-        { val: 0.5, dur: Duration.Eighth, dot: false },
-        { val: 0.375, dur: Duration.Sixteenth, dot: true },
-        { val: 0.25, dur: Duration.Sixteenth, dot: false },
-        { val: 0.1875, dur: Duration.ThirtySecond, dot: true },
-        { val: 0.125, dur: Duration.ThirtySecond, dot: false },
-        { val: 0.09375, dur: Duration.SixtyFourth, dot: true },
-        { val: 0.0625, dur: Duration.SixtyFourth, dot: false },
+        { val: 4, dur: Duration.Whole, dot: 0 },
+        { val: 3, dur: Duration.Half, dot: 1 },
+        { val: 2, dur: Duration.Half, dot: 0 },
+        { val: 1.5, dur: Duration.Quarter, dot: 1 },
+        { val: 1, dur: Duration.Quarter, dot: 0 },
+        { val: 0.75, dur: Duration.Eighth, dot: 1 },
+        { val: 0.5, dur: Duration.Eighth, dot: 0 },
+        { val: 0.375, dur: Duration.Sixteenth, dot: 1 },
+        { val: 0.25, dur: Duration.Sixteenth, dot: 0 },
+        { val: 0.1875, dur: Duration.ThirtySecond, dot: 1 },
+        { val: 0.125, dur: Duration.ThirtySecond, dot: 0 },
+        { val: 0.09375, dur: Duration.SixtyFourth, dot: 1 },
+        { val: 0.0625, dur: Duration.SixtyFourth, dot: 0 },
     ];
     // Protect against infinite loop with max iterations
     let loops = 0;
     while (remaining > 0.001 && loops < 100) {
         const match = options.find((o) => o.val <= remaining + 0.001);
         if (match) {
-            result.push({ duration: match.dur, isDotted: match.dot, val: match.val });
+            result.push({ duration: match.dur, dotCount: match.dot, val: match.val });
             remaining -= match.val;
         }
         else {

package/dist/types/Grace.d.ts

@@ -0,0 +1,7 @@
+export interface GraceNote {
+    slash?: boolean;
+    stealTimePrevious?: number;
+    stealTimeFollowing?: number;
+    makeTime?: number;
+    cueSize?: boolean;
+}

package/dist/types/Grace.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Hairpin.d.ts

@@ -1,8 +1,9 @@
+import { Placement } from './Placement.js';
 export declare enum HairpinType {
     Crescendo = "crescendo",
     Decrescendo = "decrescendo"
 }
-export interface Hairpin {
+export interface Hairpin extends Placement {
     type: HairpinType;
     placement: 'start' | 'stop';
 }