@scorelabs/core 1.0.9 → 1.0.11

package/dist/importers/index.d.ts

@@ -1 +1 @@
-export * from './MusicXMLParser';
+export * from './MusicXMLParser.js';

package/dist/importers/index.js

@@ -1 +1 @@
-export * from './MusicXMLParser';
+export * from './MusicXMLParser.js';

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './models/index.js';
 export * from './importers/index.js';
+export * from './constants.js';

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from './models/index.js';
 export * from './importers/index.js';
+export * from './constants.js';

package/dist/models/Measure.d.ts

@@ -1,6 +1,6 @@
-import { Note, NoteJSON } from './Note';
-import { NoteSet, NoteSetJSON } from './NoteSet';
-import { BarlineStyle, Clef, Duration, KeySignature, Repeat, Tempo, TimeSignature, Volta } from './types';
+import { Note, NoteJSON } from './Note.js';
+import { NoteSet, NoteSetJSON } from './NoteSet.js';
+import { BarlineStyle, Clef, Duration, KeySignature, Repeat, Tempo, TimeSignature, Volta } from './types.js';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -20,16 +20,19 @@ export declare class Measure {
     readonly barlineStyle: BarlineStyle;
     constructor(voices: NoteSet[][], timeSignature?: TimeSignature | undefined, keySignature?: KeySignature | undefined, systemBreak?: boolean, pageBreak?: boolean, repeats?: Repeat[], volta?: Volta | undefined, isPickup?: boolean, clef?: Clef | undefined, tempo?: Tempo | undefined, rehearsalMark?: string | undefined, systemText?: string | undefined, barlineStyle?: BarlineStyle);
     get notes(): NoteSet[];
+    getNoteOffset(voiceIndex: number, noteIndex: number): number;
+    moveNoteToVoice(fromVoiceIndex: number, noteIndex: number, toVoiceIndex: number): Measure;
+    splitNote(voiceIndex: number, noteIndex: number, splitOffset: number): Measure;
     get hasStartRepeat(): boolean;
     get hasEndRepeat(): boolean;
-    changeNoteDuration(noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Measure;
+    changeNoteDuration(noteIndex: number, newDuration: Duration, dotCountOrIsDotted?: number | boolean, voiceIndex?: number): Measure;
     getTotalDuration(voiceIndex?: number): number;
     static fromJSON(data: MeasureJSON): Measure;
     transpose(semitones: number): Measure;
     replaceNoteSet(index: number, newNoteSet: NoteSet, voiceIndex?: number): Measure;
     replaceNote(noteIndex: number, newNote: Note, voiceIndex?: number): Measure;
     deleteNote(noteIndex: number, voiceIndex?: number): Measure;
-    autoBeam(timeSign: TimeSignature): Measure;
+    autoBeam(timeSign?: TimeSignature): Measure;
     withTimeSignature(timeSignature?: TimeSignature): Measure;
     withKeySignature(keySignature?: KeySignature): Measure;
     withClef(clef?: Clef): Measure;
@@ -46,6 +49,8 @@ export declare class Measure {
     withSystemText(text?: string): Measure;
     withBarlineStyle(style: BarlineStyle): Measure;
     fillVoiceWithRests(voiceIndex: number, targetDuration: number): Measure;
+    simplifyRests(voiceIndex?: number): Measure;
+    private decomposeToRests;
     toJSON(): MeasureJSON;
 }
 export interface MeasureJSON {

package/dist/models/Measure.js

@@ -1,6 +1,6 @@
-import { Note } from './Note';
-import { NoteSet } from './NoteSet';
-import { BarlineStyle, DURATION_VALUES, decomposeDuration, } from './types';
+import { Note } from './Note.js';
+import { NoteSet } from './NoteSet.js';
+import { BarlineStyle, Duration, calculateDurationValue, decomposeDuration, } from './types.js';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -39,26 +39,110 @@ export class Measure {
     get notes() {
         return this.voices[0] || [];
     }
+    getNoteOffset(voiceIndex, noteIndex) {
+        const voice = this.voices[voiceIndex];
+        if (!voice)
+            return 0;
+        let offset = 0;
+        for (let i = 0; i < noteIndex && i < voice.length; i++) {
+            offset += voice[i].getDurationValue();
+        }
+        return offset;
+    }
+    moveNoteToVoice(fromVoiceIndex, noteIndex, toVoiceIndex) {
+        if (fromVoiceIndex === toVoiceIndex)
+            return this;
+        const fromVoice = this.voices[fromVoiceIndex];
+        if (!fromVoice || noteIndex < 0 || noteIndex >= fromVoice.length)
+            return this;
+        const noteSetToMove = fromVoice[noteIndex];
+        if (noteSetToMove.isRest)
+            return this;
+        const onset = this.getNoteOffset(fromVoiceIndex, noteIndex);
+        // 1. Replace with rest in fromVoice first to get the source updated
+        let updatedMeasure = this.deleteNote(noteIndex, fromVoiceIndex);
+        // 2. Ensure toVoice exists and has rests up to total duration
+        const targetDur = this.timeSignature
+            ? (this.timeSignature.beats * 4) / this.timeSignature.beatType
+            : this.getTotalDuration(fromVoiceIndex);
+        updatedMeasure = updatedMeasure.fillVoiceWithRests(toVoiceIndex, targetDur);
+        // 3. Find the note/rest at 'onset' in toVoice and split if necessary
+        let toVoice = updatedMeasure.voices[toVoiceIndex];
+        let currentOffset = 0;
+        let targetNoteIndex = -1;
+        for (let i = 0; i < toVoice.length; i++) {
+            const dur = toVoice[i].getDurationValue();
+            if (Math.abs(currentOffset - onset) < 0.001) {
+                targetNoteIndex = i;
+                break;
+            }
+            if (onset > currentOffset + 0.001 && onset < currentOffset + dur - 0.001) {
+                // Need to split
+                updatedMeasure = updatedMeasure.splitNote(toVoiceIndex, i, onset - currentOffset);
+                toVoice = updatedMeasure.voices[toVoiceIndex]; // Update reference
+                // After split, the target should be at i + (number of segments added - 1)
+                // Let's just re-scan to be safe
+                currentOffset = 0;
+                for (let j = 0; j < toVoice.length; j++) {
+                    if (Math.abs(currentOffset - onset) < 0.001) {
+                        targetNoteIndex = j;
+                        break;
+                    }
+                    currentOffset += toVoice[j].getDurationValue();
+                }
+                break;
+            }
+            currentOffset += dur;
+        }
+        if (targetNoteIndex !== -1) {
+            // We found the correct position in the prepared target voice
+            updatedMeasure = updatedMeasure.replaceNoteSet(targetNoteIndex, noteSetToMove, toVoiceIndex);
+        }
+        return updatedMeasure;
+    }
+    splitNote(voiceIndex, noteIndex, splitOffset) {
+        const voice = this.voices[voiceIndex];
+        if (!voice || noteIndex < 0 || noteIndex >= voice.length)
+            return this;
+        const target = voice[noteIndex];
+        const duration = target.getDurationValue();
+        if (splitOffset <= 0 || splitOffset >= duration - 0.001)
+            return this;
+        const leftParts = decomposeDuration(splitOffset);
+        const rightParts = decomposeDuration(duration - splitOffset);
+        const leftNotes = leftParts.map((p) => target.withDuration(p.duration, p.isDotted).withTie(target.isRest ? false : true));
+        const rightNotes = rightParts.map((p, idx) => {
+            const isLast = idx === rightParts.length - 1;
+            return target
+                .withDuration(p.duration, p.isDotted)
+                .withTie(isLast ? !!target.notes[0].tie : !target.isRest);
+        });
+        const newVoice = [...voice];
+        newVoice.splice(noteIndex, 1, ...leftNotes, ...rightNotes);
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = newVoice;
+        return this.withVoices(newVoices);
+    }
     get hasStartRepeat() {
-        return this.repeats.some((r) => r.type === "start");
+        return this.repeats.some((r) => r.type === 'start');
     }
     get hasEndRepeat() {
-        return this.repeats.some((r) => r.type === "end");
+        return this.repeats.some((r) => r.type === 'end');
     }
-    changeNoteDuration(noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+    changeNoteDuration(noteIndex, newDuration, dotCountOrIsDotted = 0, voiceIndex = 0) {
         const voice = this.voices[voiceIndex];
         if (!voice || noteIndex < 0 || noteIndex >= voice.length)
             return this;
         const targetNoteSet = voice[noteIndex];
         const oldVal = targetNoteSet.getDurationValue();
-        const base = DURATION_VALUES[newDuration];
-        const newVal = isDotted ? base * 1.5 : base;
+        const dotCount = typeof dotCountOrIsDotted === 'number' ? dotCountOrIsDotted : (dotCountOrIsDotted ? 1 : 0);
+        const newVal = calculateDurationValue(newDuration, dotCount);
         if (Math.abs(newVal - oldVal) < 0.001)
             return this;
         const updatedVoice = [...voice];
         if (newVal < oldVal) {
             const gap = oldVal - newVal;
-            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, isDotted);
+            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, dotCountOrIsDotted);
             const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
             updatedVoice.splice(noteIndex + 1, 0, ...rests);
         }
@@ -70,7 +154,7 @@ export class Measure {
             }
             if (available < delta - 0.001)
                 return this;
-            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, isDotted);
+            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, dotCountOrIsDotted);
             let consumed = 0;
             let removeCount = 0;
             const replacements = [];
@@ -94,7 +178,11 @@ export class Measure {
         }
         const newVoices = [...this.voices];
         newVoices[voiceIndex] = updatedVoice;
-        return this.withVoices(newVoices);
+        let result = this.withVoices(newVoices).simplifyRests(voiceIndex);
+        if (this.timeSignature) {
+            result = result.autoBeam(this.timeSignature);
+        }
+        return result;
     }
     getTotalDuration(voiceIndex = 0) {
         const voice = this.voices[voiceIndex];
@@ -141,10 +229,56 @@ export class Measure {
         const voice = [...this.voices[voiceIndex]];
         if (index >= voice.length)
             return this;
-        voice[index] = newNoteSet;
+        const oldVal = voice[index].getDurationValue();
+        const newVal = newNoteSet.getDurationValue();
+        // Use a copy for modifications
+        const updatedVoice = [...voice];
+        if (Math.abs(oldVal - newVal) < 0.001) {
+            updatedVoice[index] = newNoteSet;
+        }
+        else if (newVal < oldVal) {
+            const gap = oldVal - newVal;
+            updatedVoice[index] = newNoteSet;
+            const rests = this.decomposeToRests(gap);
+            updatedVoice.splice(index + 1, 0, ...rests);
+        }
+        else {
+            const delta = newVal - oldVal;
+            let available = 0;
+            for (let i = index + 1; i < updatedVoice.length; i++) {
+                available += updatedVoice[i].getDurationValue();
+            }
+            // If there's enough space to consume, do it.
+            // If not, we still replace it but it will overflow (which simplifyRests might fix or layout will handle)
+            updatedVoice[index] = newNoteSet;
+            let consumed = 0;
+            let removeCount = 0;
+            const replacements = [];
+            for (let i = index + 1; i < voice.length; i++) {
+                const ns = voice[i];
+                const val = ns.getDurationValue();
+                if (consumed + val <= delta + 0.001) {
+                    consumed += val;
+                    removeCount++;
+                    if (consumed >= delta - 0.001)
+                        break;
+                }
+                else {
+                    const remaining = consumed + val - delta;
+                    replacements.push(...this.decomposeToRests(remaining));
+                    removeCount++;
+                    break;
+                }
+            }
+            updatedVoice.splice(index + 1, removeCount, ...replacements);
+        }
         const newVoices = [...this.voices];
-        newVoices[voiceIndex] = voice;
-        return this.withVoices(newVoices);
+        newVoices[voiceIndex] = updatedVoice;
+        let result = this.withVoices(newVoices).simplifyRests(voiceIndex);
+        if (this.timeSignature) {
+            result = result.autoBeam(this.timeSignature);
+        }
+        return result;
     }
     replaceNote(noteIndex, newNote, voiceIndex = 0) {
         return this.replaceNoteSet(noteIndex, new NoteSet([newNote]), voiceIndex);
@@ -155,13 +289,20 @@ export class Measure {
         const voice = [...this.voices[voiceIndex]];
         if (noteIndex < 0 || noteIndex >= voice.length)
             return this;
-        voice.splice(noteIndex, 1);
+        // Instead of splicing, replace with a rest of the same duration
+        const target = voice[noteIndex];
+        voice[noteIndex] = target.withRest(true);
         const newVoices = [...this.voices];
         newVoices[voiceIndex] = voice;
-        return this.withVoices(newVoices);
+        return this.withVoices(newVoices).simplifyRests(voiceIndex);
     }
     autoBeam(timeSign) {
+        const ts = timeSign || this.timeSignature;
+        if (!ts)
+            return this;
         const newVoices = this.voices.map((voice) => {
+            if (voice.length === 0)
+                return [];
             let currentOffset = 0;
             let lastGroupId = undefined;
             let lastGroupStartTime = 0;
@@ -171,28 +312,38 @@ export class Measure {
                 const noteDuration = ns.getDurationValue();
                 let groupToAssign = undefined;
                 if (ns.isBeamable()) {
-                    const isSixteenth = noteDuration < 0.5;
-                    let currentBeatLength = 4 / timeSign.beatType;
-                    if (timeSign.beatType === 8 && timeSign.beats % 3 === 0) {
-                        currentBeatLength = 1.5;
+                    const isSixteenth = noteDuration < 0.5 - 0.001;
+                    // Determine the logical "beat length" for beaming purposes
+                    let beamBeatLength = 4 / ts.beatType; // Default is one beat
+                    if (ts.beatType === 4) {
+                        if (ts.beats === 4 || ts.beats === 2) {
+                            // In 4/4 or 2/4, eighth notes are often beamed in groups of 2 beats (length 2.0)
+                            // unless there are sixteenth notes which force 1-beat groupings.
+                            beamBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
+                        }
                     }
-                    else if (timeSign.beatType === 4 && (timeSign.beats === 4 || timeSign.beats === 2)) {
-                        currentBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
+                    else if (ts.beatType === 8) {
+                        if (ts.beats % 3 === 0) {
+                            // Compound meter (6/8, 9/8, 12/8): Beam by 3 eighth notes (1.5 length)
+                            beamBeatLength = 1.5;
+                        }
+                        else {
+                            // Simple meter in 8 (e.g. 2/8, 4/8): Beam by quarter note (1.0 length)
+                            beamBeatLength = 1.0;
+                        }
                     }
-                    else if (timeSign.beatType === 2 && timeSign.beats === 2) {
-                        currentBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
-                    }
-                    const currentBeatId = Math.floor(currentOffset / currentBeatLength + 0.001);
+                    const currentBeatId = Math.floor(currentOffset / beamBeatLength + 0.001);
                     const endOffset = currentOffset + noteDuration;
-                    const crossesBeat = Math.floor(endOffset / currentBeatLength - 0.001) !== currentBeatId;
+                    const crossesBeat = Math.floor(endOffset / beamBeatLength - 0.001) !== currentBeatId;
                     const sameBeatAsLast = lastGroupId !== undefined &&
-                        Math.floor(lastGroupStartTime / currentBeatLength + 0.001) === currentBeatId;
+                        Math.floor(lastGroupStartTime / beamBeatLength + 0.001) === currentBeatId;
                     if (sameBeatAsLast && !crossesBeat) {
                         groupToAssign = lastGroupId;
                         if (isSixteenth)
                             lastGroupHasSixteenths = true;
                     }
                     else {
+                        // Start a new group
                         lastGroupId = Math.floor(Math.random() * 1000000) + 1;
                         lastGroupStartTime = currentOffset;
                         lastGroupHasSixteenths = isSixteenth;
@@ -200,12 +351,14 @@ export class Measure {
                     }
                 }
                 else {
+                    // Non-beamable note (Quarter, Half, etc.) or Rest
                     lastGroupId = undefined;
                     lastGroupHasSixteenths = false;
                 }
                 tempNoteSets.push(ns.withBeamGroup(groupToAssign));
                 currentOffset += noteDuration;
             }
+            // Cleanup: groups of 1 note are not beamed
             const groupCounts = new Map();
             for (const ns of tempNoteSets) {
                 if (ns.beamGroup !== undefined) {
@@ -294,6 +447,46 @@ export class Measure {
         }
         return this.withVoices(newVoices);
     }
+    simplifyRests(voiceIndex = 0) {
+        const voice = this.voices[voiceIndex];
+        if (!voice || voice.length === 0)
+            return this;
+        const totalDur = this.getTotalDuration(voiceIndex);
+        const expectedDur = this.timeSignature
+            ? (this.timeSignature.beats * 4) / this.timeSignature.beatType
+            : 4.0;
+        // Special Case: If the whole measure is rests, just return a single whole rest (or appropriate duration)
+        const allRests = voice.every((ns) => ns.isRest);
+        if (allRests && Math.abs(totalDur - expectedDur) < 0.001) {
+            const newVoice = [new NoteSet([new Note(Duration.Whole, undefined, true)])];
+            const newVoices = [...this.voices];
+            newVoices[voiceIndex] = newVoice;
+            return this.withVoices(newVoices);
+        }
+        const newVoice = [];
+        let currentRestSum = 0;
+        for (const ns of voice) {
+            if (ns.isRest) {
+                currentRestSum += ns.getDurationValue();
+            }
+            else {
+                if (currentRestSum > 0.001) {
+                    newVoice.push(...this.decomposeToRests(currentRestSum));
+                    currentRestSum = 0;
+                }
+                newVoice.push(ns);
+            }
+        }
+        if (currentRestSum > 0.001) {
+            newVoice.push(...this.decomposeToRests(currentRestSum));
+        }
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = newVoice;
+        return this.withVoices(newVoices);
+    }
+    decomposeToRests(value) {
+        return decomposeDuration(value).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+    }
     toJSON() {
         return {
             voices: this.voices.map((v) => v.map((ns) => ns.toJSON())),

package/dist/models/Note.d.ts

@@ -1,13 +1,9 @@
-import { Pitch } from './Pitch';
-import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types';
-/**
- * Represents a single note or rest in a measure.
- */
+import { Pitch } from './Pitch.js';
+import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types.js';
 export declare class Note {
     readonly duration: Duration;
     readonly pitch?: Pitch | undefined;
     readonly isRest: boolean;
-    readonly isDotted: boolean;
     readonly accidental?: Accidental | undefined;
     readonly beamGroup?: number | undefined;
     readonly articulations: Articulation[];
@@ -17,7 +13,7 @@ export declare class Note {
     readonly tuplet?: Tuplet | undefined;
     readonly hairpin?: Hairpin | undefined;
     readonly isGrace: boolean;
-    readonly lyric?: string | undefined;
+    readonly lyric?: Lyric | undefined;
     readonly chord?: string | undefined;
     readonly glissando?: Glissando | undefined;
     readonly arpeggio?: Arpeggio | undefined;
@@ -27,7 +23,7 @@ export declare class Note {
     readonly fret?: number | undefined;
     readonly string?: number | undefined;
     readonly fretboardDiagram?: FretboardDiagram | undefined;
-    readonly lyrics?: (string | Lyric)[] | undefined;
+    readonly lyrics?: Lyric[] | undefined;
     readonly staffText?: string | undefined;
     readonly color?: string | undefined;
     readonly notehead?: NoteheadShape | undefined;
@@ -39,8 +35,10 @@ export declare class Note {
     readonly hammerOn?: "start" | "stop" | undefined;
     readonly pullOff?: "start" | "stop" | undefined;
     constructor(duration: Duration, pitch?: Pitch | undefined, // undefined for rests
-    isRest?: boolean, isDotted?: boolean, accidental?: Accidental | undefined, beamGroup?: number | undefined, // Group ID for beamed notes
-    articulations?: Articulation[], dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, lyric?: string | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: (string | Lyric)[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined, stemDirection?: StemDirection | undefined, isStringCircled?: boolean | undefined, palmMute?: "start" | "stop" | undefined, hammerOn?: "start" | "stop" | undefined, pullOff?: "start" | "stop" | undefined);
+    isRest?: boolean, dotCountOrIsDotted?: number | boolean, accidental?: Accidental | undefined, beamGroup?: number | undefined, // Group ID for beamed notes
+    articulations?: Articulation[], dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, lyric?: Lyric | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: Lyric[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined, stemDirection?: StemDirection | undefined, isStringCircled?: boolean | undefined, palmMute?: "start" | "stop" | undefined, hammerOn?: "start" | "stop" | undefined, pullOff?: "start" | "stop" | undefined);
+    readonly dotCount: number;
+    get isDotted(): boolean;
     /**
      * Get all lyrics as standardized objects
      */
@@ -70,11 +68,11 @@ export declare class Note {
     withTie(tie?: boolean): Note;
     withSlur(slur?: Slur): Note;
     withTuplet(tuplet?: Tuplet): Note;
-    withLyric(lyric?: string): Note;
-    withLyrics(lyrics: (string | Lyric)[]): Note;
+    withLyric(lyric?: Lyric): Note;
+    withLyrics(lyrics: Lyric[]): Note;
     withHairpin(hairpin?: Hairpin): Note;
     withAccidental(accidental?: Accidental): Note;
-    withDuration(duration: Duration, isDotted?: boolean): Note;
+    withDuration(duration: Duration, dotCountOrIsDotted?: number | boolean): Note;
     withRest(isRest: boolean): Note;
     withFretboardDiagram(diagram?: FretboardDiagram): Note;
     withBeamGroup(beamGroup?: number): Note;
@@ -107,6 +105,7 @@ export interface NoteJSON {
     };
     isRest?: boolean;
     isDotted?: boolean;
+    dotCount?: number;
     accidental?: string;
     beamGroup?: number;
     articulation?: string;
@@ -117,7 +116,7 @@ export interface NoteJSON {
     tuplet?: Tuplet;
     hairpin?: Hairpin;
     isGrace?: boolean;
-    lyric?: string;
+    lyric?: Lyric;
     chord?: string;
     glissando?: Glissando;
     arpeggio?: Arpeggio;
@@ -127,7 +126,7 @@ export interface NoteJSON {
     fret?: number;
     string?: number;
     fretboardDiagram?: FretboardDiagram;
-    lyrics?: (string | Lyric)[];
+    lyrics?: Lyric[];
     staffText?: string;
     color?: string;
     notehead?: string;