@scorelabs/core 1.0.7 → 1.0.9

package/dist/importers/MusicXMLParser.d.ts

@@ -12,9 +12,9 @@ export declare class MusicXMLParser {
     private currentSymbol;
     private instrumentPitchMap;
     private _domParser;
-    constructor(domParserInstance?: DOMParser | any);
+    constructor(domParserInstance?: DOMParser | unknown);
     private parseFromString;
-    static getXMLFromBinary(data: ArrayBuffer, domParser?: DOMParser | any): Promise<string>;
+    static getXMLFromBinary(data: ArrayBuffer, domParser?: DOMParser | unknown): Promise<string>;
     parseBinary(data: ArrayBuffer): Promise<ScoreJSON>;
     parse(xmlString: string): ScoreJSON;
     private parseSubtitle;

package/dist/importers/MusicXMLParser.js

@@ -1,6 +1,6 @@
 import JSZip from 'jszip';
-import { getInstrumentByProgram } from '../models/Instrument';
-import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, } from '../models/types';
+import { getInstrumentByProgram, guessInstrumentByName } from '../models/Instrument';
+import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, DURATION_VALUES, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, decomposeDuration, } from '../models/types';
 /**
  * MusicXML Parser
  *
@@ -151,19 +151,28 @@ export class MusicXMLParser {
         for (const scorePart of Array.from(scoreParts)) {
             const id = scorePart.getAttribute('id');
             const name = this.getText(scorePart, 'part-name') || 'Part';
-            let instrument = getInstrumentByProgram(0); // Default Piano
+            let instrument;
             // Find first midi-instrument to determine main instrument
             const firstMidiInst = scorePart.querySelector('midi-instrument');
             if (firstMidiInst) {
                 const programStr = this.getText(firstMidiInst, 'midi-program');
                 if (programStr) {
                     const program = parseInt(programStr);
-                    // MusicXML uses 1-128, MIDI uses 0-127. Adjust if needed.
-                    // Often it's accurate to 1-based, so checking bounds.
-                    // Assuming input is 1-based as per standard
                     instrument = getInstrumentByProgram(Math.max(0, program - 1));
                 }
             }
+            // Fallback: guess by part name
+            if (!instrument || instrument.sound === 'piano') {
+                const guessed = guessInstrumentByName(name);
+                // Only override if the guess is more specific than default piano
+                if (guessed.sound !== 'piano') {
+                    instrument = guessed;
+                }
+            }
+            // Final default
+            if (!instrument) {
+                instrument = getInstrumentByProgram(0);
+            }
             if (id) {
                 partInfo.set(id, { name: name.trim(), instrument });
             }
@@ -242,7 +251,8 @@ export class MusicXMLParser {
                     const sign = this.getText(clef, 'sign');
                     if (sign && number <= numStaves) {
                         const line = this.getNumber(clef, 'line') || 0;
-                        staffClefs[number - 1] = this.mapClef(sign, line);
+                        const octaveChange = this.getNumber(clef, 'clef-octave-change') || 0;
+                        staffClefs[number - 1] = this.mapClef(sign, line, octaveChange);
                     }
                 });
                 const staffDetails = attributes.querySelectorAll('staff-details');
@@ -258,7 +268,10 @@ export class MusicXMLParser {
             let systemText = undefined;
             let contextDynamic = undefined;
             const { repeats, volta, barlineStyle } = this.parseBarlines(measureElement);
-            const measureVoices = Array.from({ length: numStaves }, () => []);
+            // Map of staffIndex -> Map of voiceId -> NoteSetJSON[]
+            const staffVoices = new Map();
+            for (let i = 0; i < numStaves; i++)
+                staffVoices.set(i, new Map());
             const children = Array.from(measureElement.children);
             let pendingChord = undefined;
             let currentNoteSetMap = new Map();
@@ -375,6 +388,11 @@ export class MusicXMLParser {
                             note.pedal = currentPedal;
                             currentPedal = undefined;
                         }
+                        const voiceId = this.getText(child, 'voice') || '1';
+                        const voiceMap = staffVoices.get(staffIdx);
+                        if (!voiceMap.has(voiceId))
+                            voiceMap.set(voiceId, []);
+                        const voiceNoteSets = voiceMap.get(voiceId);
                         if (isChord) {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
@@ -385,26 +403,42 @@ export class MusicXMLParser {
                         else {
                             const existing = currentNoteSetMap.get(staffIdx);
                             if (existing)
-                                measureVoices[staffIdx].push({ notes: existing });
+                                voiceNoteSets.push({ notes: existing });
                             currentNoteSetMap.set(staffIdx, [note]);
                         }
                     }
                 }
                 else if (child.nodeName === 'backup' || child.nodeName === 'forward') {
                     for (const [sIdx, notes] of currentNoteSetMap.entries()) {
-                        if (notes.length > 0)
-                            measureVoices[sIdx].push({ notes });
+                        if (notes.length > 0) {
+                            const voiceId = this.getText(child.previousElementSibling, 'voice') || '1';
+                            const voiceMap = staffVoices.get(sIdx);
+                            if (!voiceMap.has(voiceId))
+                                voiceMap.set(voiceId, []);
+                            voiceMap.get(voiceId).push({ notes });
+                        }
                     }
                     currentNoteSetMap.clear();
                 }
             });
             for (const [sIdx, notes] of currentNoteSetMap.entries()) {
-                if (notes.length > 0)
-                    measureVoices[sIdx].push({ notes });
+                if (notes.length > 0) {
+                    // Last note in measure
+                    const voiceId = '1'; // Defaulting to 1 for final push if not tracked
+                    const voiceMap = staffVoices.get(sIdx);
+                    if (!voiceMap.has(voiceId))
+                        voiceMap.set(voiceId, []);
+                    voiceMap.get(voiceId).push({ notes });
+                }
             }
             for (let i = 0; i < numStaves; i++) {
+                const vMap = staffVoices.get(i);
+                let voicesIndices = Array.from(vMap.keys()).sort();
+                if (voicesIndices.length === 0)
+                    voicesIndices = ['1'];
+                const voices = voicesIndices.map(id => vMap.get(id) || []);
                 const measure = {
-                    voices: [measureVoices[i]],
+                    voices: voices,
                     timeSignature: measureTimeSignature,
                     keySignature: measureKeySignature,
                     isPickup: isPickup || undefined,
@@ -415,6 +449,30 @@ export class MusicXMLParser {
                     systemText: i === 0 ? systemText : undefined,
                     barlineStyle,
                 };
+                // Padding with rests if not a pickup
+                if (!isPickup) {
+                    const targetDur = (this.currentBeats * 4) / this.currentBeatType;
+                    measure.voices = measure.voices.map((v) => {
+                        const currentDur = v.reduce((sum, ns) => {
+                            const base = DURATION_VALUES[ns.notes[0].duration];
+                            return sum + (ns.notes[0].isDotted ? base * 1.5 : base);
+                        }, 0);
+                        if (currentDur < targetDur - 0.001) {
+                            const gap = targetDur - currentDur;
+                            const rests = decomposeDuration(gap).map((d) => ({
+                                notes: [
+                                    {
+                                        duration: d.duration,
+                                        isRest: true,
+                                        isDotted: d.isDotted,
+                                    },
+                                ],
+                            }));
+                            return [...v, ...rests];
+                        }
+                        return v;
+                    });
+                }
                 staves[i].measures.push(measure);
                 staves[i].clef = staffClefs[i];
             }
@@ -891,12 +949,12 @@ export class MusicXMLParser {
         };
         return map[type] ?? Duration.Quarter;
     }
-    mapClef(sign, line = 0) {
+    mapClef(sign, line = 0, octaveChange = 0) {
         switch (sign.toUpperCase()) {
             case 'G':
-                return Clef.Treble;
+                return octaveChange === -1 ? Clef.Treble8vaBassa : Clef.Treble;
             case 'F':
-                return Clef.Bass;
+                return octaveChange === -1 ? Clef.Bass8vaBassa : Clef.Bass;
             case 'C':
                 return line === 4 ? Clef.Tenor : Clef.Alto;
             case 'PERCUSSION':

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;

package/dist/models/Measure.js

@@ -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)

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: (string | 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?: string): 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[];
+    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 allLyrics(): Lyric[];
+    get lyrics(): (string | Lyric)[] | undefined;
     get lyric(): string | 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 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[];

package/dist/models/NoteSet.js

@@ -1,5 +1,5 @@
 import { Note } from './Note';
-import { Duration } from './types';
+import { Duration, } from './types';
 export class NoteSet {
     notes;
     constructor(notes) {
@@ -178,6 +178,9 @@ export class NoteSet {
     get slur() {
         return this.notes[0].slur;
     }
+    get articulations() {
+        return this.notes[0].articulations;
+    }
     get articulation() {
         return this.notes[0].articulation;
     }
@@ -264,7 +267,7 @@ export class NoteSet {
             return new NoteSet([new Note(Duration.Quarter, undefined, true)]);
         }
         let notesArray;
-        if (data.notes && Array.isArray(data.notes)) {
+        if ('notes' in data && Array.isArray(data.notes)) {
             notesArray = data.notes;
         }
         else if (Array.isArray(data)) {

package/dist/models/Pitch.js

@@ -33,7 +33,9 @@ export class Pitch {
     getStaffPosition(clef) {
         const middleLineAbsStep = {
             [Clef.Treble]: 4 * 7 + 6, // B4
+            [Clef.Treble8vaBassa]: 3 * 7 + 6, // B3
             [Clef.Bass]: 3 * 7 + 1, // D3
+            [Clef.Bass8vaBassa]: 2 * 7 + 1, // D2
             [Clef.Alto]: 4 * 7 + 0, // C4
             [Clef.Tenor]: 3 * 7 + 5, // A3
             [Clef.Percussion]: 4 * 7 + 6, // B4
@@ -100,7 +102,9 @@ export class Pitch {
     static fromStaffPosition(clef, staffPosition) {
         const middleLineAbsStep = {
             [Clef.Treble]: 4 * 7 + 6, // B4
+            [Clef.Treble8vaBassa]: 3 * 7 + 6, // B3
             [Clef.Bass]: 3 * 7 + 1, // D3
+            [Clef.Bass8vaBassa]: 2 * 7 + 1, // D2
             [Clef.Alto]: 4 * 7 + 0, // C4
             [Clef.Tenor]: 3 * 7 + 5, // A3
             [Clef.Percussion]: 4 * 7 + 0,

package/dist/models/PreMeasure.d.ts

@@ -0,0 +1,24 @@
+import { Clef, KeySignature, TimeSignature } from './types';
+export interface PreMeasureJSON {
+    clef?: string;
+    keySignature?: KeySignature;
+    timeSignature?: TimeSignature;
+}
+/**
+ * Represents the musical context before the first measure of a system.
+ * This includes the clef, key signature, and time signature.
+ */
+export declare class PreMeasure {
+    readonly clef?: Clef | undefined;
+    readonly keySignature?: KeySignature | undefined;
+    readonly timeSignature?: TimeSignature | undefined;
+    constructor(clef?: Clef | undefined, keySignature?: KeySignature | undefined, timeSignature?: TimeSignature | undefined);
+    /**
+     * Creates a PreMeasure from JSON data.
+     */
+    static fromJSON(data: Partial<PreMeasureJSON>): PreMeasure;
+    /**
+     * Converts the PreMeasure to a JSON-serializable object.
+     */
+    toJSON(): PreMeasureJSON;
+}

package/dist/models/PreMeasure.js

@@ -0,0 +1,30 @@
+/**
+ * Represents the musical context before the first measure of a system.
+ * This includes the clef, key signature, and time signature.
+ */
+export class PreMeasure {
+    clef;
+    keySignature;
+    timeSignature;
+    constructor(clef, keySignature, timeSignature) {
+        this.clef = clef;
+        this.keySignature = keySignature;
+        this.timeSignature = timeSignature;
+    }
+    /**
+     * Creates a PreMeasure from JSON data.
+     */
+    static fromJSON(data) {
+        return new PreMeasure(data.clef, data.keySignature, data.timeSignature);
+    }
+    /**
+     * Converts the PreMeasure to a JSON-serializable object.
+     */
+    toJSON() {
+        return {
+            clef: this.clef,
+            keySignature: this.keySignature,
+            timeSignature: this.timeSignature,
+        };
+    }
+}

package/dist/models/Score.d.ts

@@ -2,7 +2,7 @@ import { Measure } from './Measure';
 import { NoteSet } from './NoteSet';
 import { Part, PartJSON } from './Part';
 import { Staff } from './Staff';
-import { Duration, Genre, KeySignature, TimeSignature } from './types';
+import { Clef, Duration, Genre, KeySignature, TimeSignature } from './types';
 /**
  * Represents a complete musical score.
  */
@@ -38,6 +38,21 @@ export declare class Score {
     static fromJSON(data: ScoreJSON): Score;
     transpose(semitones: number): Score;
     replaceNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newNote: NoteSet, voiceIndex?: number): Score;
+    withKeySignature(keySig: KeySignature): Score;
+    withTimeSignature(timeSig: TimeSignature): Score;
+    updateMeasureSignatures(measureIndex: number, signatures: {
+        keySignature?: KeySignature;
+        timeSignature?: TimeSignature;
+        clef?: Clef;
+    }, autoBeam?: boolean): Score;
+    /**
+     * Reflows the notes starting from a specific measure index.
+     * This is useful when time signatures change and notes need to be redistributed.
+     */
+    reflow(fromMeasureIndex: number, autoBeam?: boolean): Score;
+    private isTied;
+    private areSamePitch;
+    private reflowStaff;
     replaceMeasure(partIndex: number, staffIndex: number, measureIndex: number, newMeasure: Measure, autoBeam?: boolean): Score;
     deleteNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, voiceIndex?: number): Score;
     changeNoteDuration(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Score;