@scorelabs/core 1.0.7 → 1.0.10

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/models/Instrument.d.ts

@@ -1,27 +1,16 @@
-export declare enum InstrumentType {
-    String = "string",
-    Brass = "brass",
-    Woodwind = "woodwind",
-    Percussion = "percussion",
-    Keyboard = "keyboard",
-    Synth = "synth"
-}
-export declare enum InstrumentPreset {
-    Piano = "piano",
-    Violin = "violin",
-    Cello = "cello",
-    Guitar = "guitar",
-    ElectricGuitar = "electric-guitar",
-    Bass = "bass",
-    Flute = "flute",
-    Trumpet = "trumpet",
-    Drums = "drums"
-}
+import { InstrumentPreset } from '../types/InstrumentPreset.js';
+import { InstrumentType } from '../types/InstrumentType.js';
 export interface Instrument {
     name: string;
     midiProgram: number;
+    sound: InstrumentPreset;
     type?: InstrumentType;
     transposition?: number;
 }
 export declare const PRESET_INSTRUMENTS: Record<string, Instrument>;
+export declare const TRANSLATED_INSTRUMENT_NAMES: Record<string, Record<InstrumentPreset, string>>;
 export declare function getInstrumentByProgram(program: number): Instrument;
+/**
+ * Guesses the instrument based on a string (like part name).
+ */
+export declare function guessInstrumentByName(name: string): Instrument;

package/dist/models/Instrument.js

@@ -1,67 +1,121 @@
-export var InstrumentType;
-(function (InstrumentType) {
-    InstrumentType["String"] = "string";
-    InstrumentType["Brass"] = "brass";
-    InstrumentType["Woodwind"] = "woodwind";
-    InstrumentType["Percussion"] = "percussion";
-    InstrumentType["Keyboard"] = "keyboard";
-    InstrumentType["Synth"] = "synth";
-})(InstrumentType || (InstrumentType = {}));
-export var InstrumentPreset;
-(function (InstrumentPreset) {
-    InstrumentPreset["Piano"] = "piano";
-    InstrumentPreset["Violin"] = "violin";
-    InstrumentPreset["Cello"] = "cello";
-    InstrumentPreset["Guitar"] = "guitar";
-    InstrumentPreset["ElectricGuitar"] = "electric-guitar";
-    InstrumentPreset["Bass"] = "bass";
-    InstrumentPreset["Flute"] = "flute";
-    InstrumentPreset["Trumpet"] = "trumpet";
-    InstrumentPreset["Drums"] = "drums";
-})(InstrumentPreset || (InstrumentPreset = {}));
+import { InstrumentPreset } from '../types/InstrumentPreset.js';
+import { InstrumentType } from '../types/InstrumentType.js';
 export const PRESET_INSTRUMENTS = {
     [InstrumentPreset.Piano]: {
         name: 'Acoustic Grand Piano',
         midiProgram: 0,
+        sound: InstrumentPreset.Piano,
         type: InstrumentType.Keyboard,
     },
-    [InstrumentPreset.Violin]: { name: 'Violin', midiProgram: 40, type: InstrumentType.String },
-    [InstrumentPreset.Cello]: { name: 'Cello', midiProgram: 42, type: InstrumentType.String },
+    [InstrumentPreset.Violin]: {
+        name: 'Violin',
+        midiProgram: 40,
+        sound: InstrumentPreset.Violin,
+        type: InstrumentType.String,
+    },
+    [InstrumentPreset.Cello]: {
+        name: 'Cello',
+        midiProgram: 42,
+        sound: InstrumentPreset.Cello,
+        type: InstrumentType.String,
+    },
     [InstrumentPreset.Guitar]: {
         name: 'Acoustic Guitar (nylon)',
         midiProgram: 24,
+        sound: InstrumentPreset.Guitar,
         type: InstrumentType.String,
     },
     [InstrumentPreset.ElectricGuitar]: {
         name: 'Electric Guitar (clean)',
         midiProgram: 27,
+        sound: InstrumentPreset.ElectricGuitar,
         type: InstrumentType.String,
     },
     [InstrumentPreset.Bass]: {
         name: 'Acoustic Bass',
         midiProgram: 32,
+        sound: InstrumentPreset.Bass,
         type: InstrumentType.String,
     },
     [InstrumentPreset.Flute]: {
         name: 'Flute',
         midiProgram: 73,
+        sound: InstrumentPreset.Flute,
         type: InstrumentType.Woodwind,
         transposition: 0,
     },
     [InstrumentPreset.Trumpet]: {
         name: 'Trumpet',
         midiProgram: 56,
+        sound: InstrumentPreset.Trumpet,
         type: InstrumentType.Brass,
         transposition: -2,
     },
     [InstrumentPreset.Drums]: {
         name: 'Drum Kit',
         midiProgram: 118,
+        sound: InstrumentPreset.Drums,
         type: InstrumentType.Percussion,
         transposition: 0,
     },
 };
+export const TRANSLATED_INSTRUMENT_NAMES = {
+    en: {
+        [InstrumentPreset.Piano]: 'Acoustic Grand Piano',
+        [InstrumentPreset.Violin]: 'Violin',
+        [InstrumentPreset.Cello]: 'Cello',
+        [InstrumentPreset.Guitar]: 'Acoustic Guitar',
+        [InstrumentPreset.ElectricGuitar]: 'Electric Guitar',
+        [InstrumentPreset.Bass]: 'Acoustic Bass',
+        [InstrumentPreset.Flute]: 'Flute',
+        [InstrumentPreset.Trumpet]: 'Trumpet',
+        [InstrumentPreset.Drums]: 'Drum Kit',
+    },
+    ca: {
+        [InstrumentPreset.Piano]: 'Piano',
+        [InstrumentPreset.Violin]: 'Violí',
+        [InstrumentPreset.Cello]: 'Violoncel',
+        [InstrumentPreset.Guitar]: 'Guitarra Acústica',
+        [InstrumentPreset.ElectricGuitar]: 'Guitarra Elèctrica',
+        [InstrumentPreset.Bass]: 'Baix',
+        [InstrumentPreset.Flute]: 'Flauta',
+        [InstrumentPreset.Trumpet]: 'Trompeta',
+        [InstrumentPreset.Drums]: 'Bateria',
+    },
+};
 export function getInstrumentByProgram(program) {
     const match = Object.values(PRESET_INSTRUMENTS).find((i) => i.midiProgram === program);
     return match || PRESET_INSTRUMENTS[InstrumentPreset.Piano];
 }
+/**
+ * Guesses the instrument based on a string (like part name).
+ */
+export function guessInstrumentByName(name) {
+    const n = name.toLowerCase();
+    if (n.includes('piano'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Piano];
+    if (n.includes('violin'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Violin];
+    if (n.includes('cello') || n.includes('violoncel'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Cello];
+    if (n.includes('electric guitar'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.ElectricGuitar];
+    if (n.includes('guitar'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Guitar];
+    if (n.includes('bass') || n.includes('baixo') || n.includes('baix'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Bass];
+    if (n.includes('flute') || n.includes('flauta'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Flute];
+    if (n.includes('trumpet') || n.includes('trompeta'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Trumpet];
+    if (n.includes('drum') || n.includes('perc') || n.includes('bateria'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Drums];
+    // Try partial matches for strings, brass, etc.
+    if (n.includes('string'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Violin];
+    if (n.includes('brass'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Trumpet];
+    if (n.includes('wind'))
+        return PRESET_INSTRUMENTS[InstrumentPreset.Flute];
+    return PRESET_INSTRUMENTS[InstrumentPreset.Piano];
+}

package/dist/models/Measure.d.ts

@@ -20,6 +20,8 @@ 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[];
+    get hasStartRepeat(): boolean;
+    get hasEndRepeat(): boolean;
     changeNoteDuration(noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Measure;
     getTotalDuration(voiceIndex?: number): number;
     static fromJSON(data: MeasureJSON): Measure;
@@ -27,7 +29,7 @@ export declare class 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;
@@ -44,6 +46,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 { BarlineStyle, DURATION_VALUES, Duration, decomposeDuration, } from './types';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -39,6 +39,12 @@ export class Measure {
     get notes() {
         return this.voices[0] || [];
     }
+    get hasStartRepeat() {
+        return this.repeats.some((r) => r.type === "start");
+    }
+    get hasEndRepeat() {
+        return this.repeats.some((r) => r.type === "end");
+    }
     changeNoteDuration(noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
         const voice = this.voices[voiceIndex];
         if (!voice || noteIndex < 0 || noteIndex >= voice.length)
@@ -88,7 +94,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];
@@ -135,10 +145,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);
@@ -149,13 +205,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;
@@ -165,28 +228,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;
-                    }
-                    else if (timeSign.beatType === 4 && (timeSign.beats === 4 || timeSign.beats === 2)) {
-                        currentBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
+                    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 === 2 && 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;
+                        }
                     }
-                    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;
@@ -194,12 +267,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) {
@@ -288,6 +363,44 @@ 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

@@ -17,7 +17,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 +27,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;
@@ -40,7 +40,7 @@ export declare class Note {
     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);
+    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);
     /**
      * Get all lyrics as standardized objects
      */
@@ -70,8 +70,8 @@ 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;
@@ -117,7 +117,7 @@ export interface NoteJSON {
     tuplet?: Tuplet;
     hairpin?: Hairpin;
     isGrace?: boolean;
-    lyric?: string;
+    lyric?: Lyric;
     chord?: string;
     glissando?: Glissando;
     arpeggio?: Arpeggio;
@@ -127,7 +127,7 @@ export interface NoteJSON {
     fret?: number;
     string?: number;
     fretboardDiagram?: FretboardDiagram;
-    lyrics?: (string | Lyric)[];
+    lyrics?: Lyric[];
     staffText?: string;
     color?: string;
     notehead?: string;

package/dist/models/Note.js

@@ -81,10 +81,10 @@ export class Note {
      */
     get allLyrics() {
         if (this.lyrics) {
-            return this.lyrics.map((l) => (typeof l === 'string' ? { text: l } : l));
+            return this.lyrics;
         }
         if (this.lyric) {
-            return [{ text: this.lyric }];
+            return [this.lyric];
         }
         return [];
     }

package/dist/models/NoteSet.d.ts

@@ -1,5 +1,6 @@
 import { Note, NoteJSON } from './Note';
-import { Duration } from './types';
+import { Pitch } from './Pitch';
+import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types';
 export declare class NoteSet {
     readonly notes: Note[];
     constructor(notes: Note[]);
@@ -7,16 +8,16 @@ export declare class NoteSet {
     get isDotted(): boolean;
     get isRest(): boolean;
     get beamGroup(): number | undefined;
-    get tuplet(): import("./types").Tuplet | undefined;
+    get tuplet(): Tuplet | undefined;
     getDurationValue(): number;
     isBeamable(): boolean;
     withDuration(duration: Duration, isDotted?: boolean): NoteSet;
     withBeamGroup(group?: number): NoteSet;
     withNotes(notes: Note[]): NoteSet;
-    withLyrics(lyrics: (string | any)[]): NoteSet;
-    withTuplet(tuplet?: any): NoteSet;
-    withPitch(pitch: any): NoteSet;
-    withAccidental(accidental: any): NoteSet;
+    withLyrics(lyrics: Lyric[]): NoteSet;
+    withTuplet(tuplet?: Tuplet): NoteSet;
+    withPitch(pitch: Pitch): NoteSet;
+    withAccidental(accidental?: Accidental): NoteSet;
     withRest(isRest: boolean): NoteSet;
     withGrace(isGrace: boolean): NoteSet;
     toggleEnharmonic(): NoteSet;
@@ -26,58 +27,59 @@ export declare class NoteSet {
     withChord(chord?: string): NoteSet;
     withTab(fret: number, string: number): NoteSet;
     withTie(tie: boolean): NoteSet;
-    withSlur(slur?: any): NoteSet;
-    withArticulation(articulation?: any): NoteSet;
-    withOrnament(ornament?: any): NoteSet;
-    withDynamic(dynamic?: any): NoteSet;
-    withHairpin(hairpin?: any): NoteSet;
-    withGlissando(glissando?: any): NoteSet;
-    withArpeggio(arpeggio?: any): NoteSet;
-    withOttava(ottava?: any): NoteSet;
-    withPedal(pedal?: any): NoteSet;
+    withSlur(slur?: Slur): NoteSet;
+    withArticulation(articulation?: Articulation): NoteSet;
+    withOrnament(ornament?: Ornament): NoteSet;
+    withDynamic(dynamic?: Dynamic): NoteSet;
+    withHairpin(hairpin?: Hairpin): NoteSet;
+    withGlissando(glissando?: Glissando): NoteSet;
+    withArpeggio(arpeggio?: Arpeggio): NoteSet;
+    withOttava(ottava?: Ottava): NoteSet;
+    withPedal(pedal?: Pedal): NoteSet;
     withColor(color?: string): NoteSet;
-    withNotehead(notehead: any): NoteSet;
-    withBowing(bowing?: any): NoteSet;
+    withNotehead(notehead?: NoteheadShape): NoteSet;
+    withBowing(bowing?: Bowing): NoteSet;
     withFingering(fingering?: number): NoteSet;
     withHammerOn(type?: 'start' | 'stop'): NoteSet;
     withPullOff(type?: 'start' | 'stop'): NoteSet;
     withPalmMute(type?: 'start' | 'stop'): NoteSet;
     withStringCircled(isStringCircled?: boolean): NoteSet;
-    withStemDirection(dir?: any): NoteSet;
-    withLyric(lyric?: any): NoteSet;
+    withStemDirection(dir?: StemDirection): NoteSet;
+    withLyric(lyric?: Lyric): NoteSet;
     withStaffText(text?: string): NoteSet;
-    withFretboardDiagram(diagram?: any): NoteSet;
-    get pitch(): import("./Pitch").Pitch | undefined;
-    get accidental(): import("./types").Accidental | undefined;
+    withFretboardDiagram(diagram?: FretboardDiagram): NoteSet;
+    get pitch(): Pitch | undefined;
+    get accidental(): Accidental | undefined;
     get tie(): boolean | undefined;
-    get slur(): import("./types").Slur | undefined;
-    get articulation(): import("./types").Articulation | undefined;
-    get ornament(): import("./types").Ornament | undefined;
-    get dynamic(): import("./types").Dynamic | undefined;
-    get hairpin(): import("./types").Hairpin | undefined;
-    get glissando(): import("./types").Glissando | undefined;
-    get arpeggio(): import("./types").Arpeggio | undefined;
-    get ottava(): import("./types").Ottava | undefined;
-    get pedal(): import("./types").Pedal | undefined;
-    get notehead(): import("./types").NoteheadShape | undefined;
+    get slur(): Slur | undefined;
+    get articulations(): Articulation[] | undefined;
+    get articulation(): Articulation | undefined;
+    get ornament(): Ornament | undefined;
+    get dynamic(): Dynamic | undefined;
+    get hairpin(): Hairpin | undefined;
+    get glissando(): Glissando | undefined;
+    get arpeggio(): Arpeggio | undefined;
+    get ottava(): Ottava | undefined;
+    get pedal(): Pedal | undefined;
+    get notehead(): NoteheadShape | undefined;
     get color(): string | undefined;
     get fret(): number | undefined;
     get string(): number | undefined;
-    get bowing(): import("./types").Bowing | undefined;
+    get bowing(): Bowing | undefined;
     get fingering(): number | undefined;
-    get allLyrics(): import("./types").Lyric[];
-    get lyrics(): (string | import("./types").Lyric)[] | undefined;
-    get lyric(): string | undefined;
+    get allLyrics(): Lyric[];
+    get lyrics(): Lyric[] | undefined;
+    get lyric(): Lyric | undefined;
     get chord(): string | undefined;
-    get fretboardDiagram(): import("./types").FretboardDiagram | undefined;
+    get fretboardDiagram(): FretboardDiagram | undefined;
     get staffText(): string | undefined;
-    get hammerOn(): "start" | "stop" | undefined;
-    get pullOff(): "start" | "stop" | undefined;
-    get palmMute(): "start" | "stop" | undefined;
+    get hammerOn(): 'start' | 'stop' | undefined;
+    get pullOff(): 'start' | 'stop' | undefined;
+    get palmMute(): 'start' | 'stop' | undefined;
     get isStringCircled(): boolean | undefined;
-    get stemDirection(): import("./types").StemDirection | undefined;
+    get stemDirection(): StemDirection | undefined;
     toJSON(): NoteSetJSON;
-    static fromJSON(data: any): NoteSet;
+    static fromJSON(data: Partial<NoteSetJSON> | NoteJSON | NoteJSON[]): NoteSet;
 }
 export interface NoteSetJSON {
     notes: NoteJSON[];