@scorelabs/core 1.0.1

package/dist/models/Note.js

@@ -0,0 +1,259 @@
+import { Duration, Accidental, DURATION_VALUES, } from './types';
+import { Pitch } from './Pitch';
+/**
+ * Represents a single note or rest in a measure.
+ */
+export class Note {
+    duration;
+    pitch;
+    isRest;
+    isDotted;
+    accidental;
+    beamGroup;
+    articulation;
+    dynamic;
+    tie;
+    slur;
+    tuplet;
+    hairpin;
+    isGrace;
+    lyric;
+    chord;
+    glissando;
+    arpeggio;
+    ottava;
+    pedal;
+    ornament;
+    fret;
+    string;
+    fretboardDiagram;
+    lyrics;
+    staffText;
+    color;
+    notehead;
+    bowing;
+    fingering;
+    constructor(duration, pitch, // undefined for rests
+    isRest = false, isDotted = false, accidental, beamGroup, // Group ID for beamed notes
+    articulation, dynamic, tie, slur, tuplet, hairpin, isGrace = false, lyric, chord, glissando, arpeggio, ottava, pedal, ornament, fret, string, fretboardDiagram, lyrics, staffText, color, notehead, bowing, fingering) {
+        this.duration = duration;
+        this.pitch = pitch;
+        this.isRest = isRest;
+        this.isDotted = isDotted;
+        this.accidental = accidental;
+        this.beamGroup = beamGroup;
+        this.articulation = articulation;
+        this.dynamic = dynamic;
+        this.tie = tie;
+        this.slur = slur;
+        this.tuplet = tuplet;
+        this.hairpin = hairpin;
+        this.isGrace = isGrace;
+        this.lyric = lyric;
+        this.chord = chord;
+        this.glissando = glissando;
+        this.arpeggio = arpeggio;
+        this.ottava = ottava;
+        this.pedal = pedal;
+        this.ornament = ornament;
+        this.fret = fret;
+        this.string = string;
+        this.fretboardDiagram = fretboardDiagram;
+        this.lyrics = lyrics;
+        this.staffText = staffText;
+        this.color = color;
+        this.notehead = notehead;
+        this.bowing = bowing;
+        this.fingering = fingering;
+    }
+    /**
+     * Get the duration value (quarter note = 1)
+     */
+    getDurationValue() {
+        if (this.isGrace)
+            return 0;
+        const base = DURATION_VALUES[this.duration];
+        let val = this.isDotted ? base * 1.5 : base;
+        if (this.tuplet) {
+            val = val * (this.tuplet.normal / this.tuplet.actual);
+        }
+        return val;
+    }
+    /**
+     * Check if this note should be beamed (eighth or shorter)
+     */
+    isBeamable() {
+        return (!this.isRest &&
+            (this.duration === Duration.Eighth ||
+                this.duration === Duration.Sixteenth ||
+                this.duration === Duration.ThirtySecond ||
+                this.duration === Duration.SixtyFourth ||
+                this.duration === Duration.OneHundredTwentyEighth ||
+                this.duration === Duration.TwoHundredFiftySixth));
+    }
+    withGrace(isGrace) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withChord(chord) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    transpose(semitones) {
+        if (this.isRest || !this.pitch) {
+            return this;
+        }
+        const newPitch = new Pitch(this.pitch.midiNumber + semitones);
+        const chromaticIdx = newPitch.midiNumber % 12;
+        const hasSharp = [1, 3, 6, 8, 10].includes(chromaticIdx);
+        const newAccidental = hasSharp ? Accidental.Sharp : undefined;
+        return new Note(this.duration, newPitch, this.isRest, this.isDotted, newAccidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    transposeOctave(octaves) {
+        if (!this.pitch || this.isRest)
+            return this;
+        const newPitch = new Pitch(this.pitch.midiNumber + octaves * 12, this.pitch.step, this.pitch.alter, this.pitch.octave + octaves);
+        return this.withPitch(newPitch);
+    }
+    transposeDiatonic(steps) {
+        if (this.isRest || !this.pitch) {
+            return this;
+        }
+        const newPitch = this.pitch.transposeDiatonic(steps);
+        return this.withPitch(newPitch).withAccidental(undefined);
+    }
+    toggleEnharmonic() {
+        if (!this.pitch || this.isRest)
+            return this;
+        const newPitch = this.pitch.withEnharmonicNext();
+        let newAccidental = undefined;
+        if (newPitch.alter === 1)
+            newAccidental = Accidental.Sharp;
+        else if (newPitch.alter === -1)
+            newAccidental = Accidental.Flat;
+        else if (newPitch.alter === 2)
+            newAccidental = Accidental.DoubleSharp;
+        else if (newPitch.alter === -2)
+            newAccidental = Accidental.DoubleFlat;
+        else if (newPitch.alter === 0)
+            newAccidental = undefined;
+        return this.withPitch(newPitch).withAccidental(newAccidental);
+    }
+    withPitch(pitch) {
+        return new Note(this.duration, pitch, false, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withArticulation(articulation) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withDynamic(dynamic) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withTie(tie) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withSlur(slur) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withTuplet(tuplet) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withLyric(lyric) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withLyrics(lyrics) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withHairpin(hairpin) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withAccidental(accidental) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withDuration(duration, isDotted = false) {
+        return new Note(duration, this.pitch, this.isRest, isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withRest(isRest) {
+        return new Note(this.duration, this.pitch, isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withFretboardDiagram(diagram) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, diagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withBeamGroup(beamGroup) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withGlissando(glissando) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withArpeggio(arpeggio) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withOttava(ottava) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withPedal(pedal) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withOrnament(ornament) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withTab(fret, string) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, fret, string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withStaffText(text) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, text, this.color, this.notehead, this.bowing, this.fingering);
+    }
+    withColor(color) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, color, this.notehead, this.bowing, this.fingering);
+    }
+    withNotehead(notehead) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, notehead, this.bowing, this.fingering);
+    }
+    withBowing(bowing) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, bowing, this.fingering);
+    }
+    withFingering(fingering) {
+        return new Note(this.duration, this.pitch, this.isRest, this.isDotted, this.accidental, this.beamGroup, this.articulation, this.dynamic, this.tie, this.slur, this.tuplet, this.hairpin, this.isGrace, this.lyric, this.chord, this.glissando, this.arpeggio, this.ottava, this.pedal, this.ornament, this.fret, this.string, this.fretboardDiagram, this.lyrics, this.staffText, this.color, this.notehead, this.bowing, fingering);
+    }
+    toJSON() {
+        return {
+            duration: this.duration,
+            pitch: this.isRest ? undefined : this.pitch ? {
+                midiNumber: this.pitch.midiNumber,
+                step: this.pitch.step,
+                alter: this.pitch.alter,
+                octave: this.pitch.octave,
+            } : undefined,
+            isRest: this.isRest || undefined,
+            isDotted: this.isDotted || undefined,
+            accidental: this.accidental,
+            beamGroup: this.beamGroup,
+            articulation: this.articulation,
+            dynamic: this.dynamic,
+            tie: this.tie,
+            slur: this.slur,
+            tuplet: this.tuplet,
+            hairpin: this.hairpin,
+            isGrace: this.isGrace || undefined,
+            lyric: this.lyric,
+            chord: this.chord,
+            glissando: this.glissando,
+            arpeggio: this.arpeggio,
+            ottava: this.ottava,
+            pedal: this.pedal,
+            ornament: this.ornament,
+            fret: this.fret,
+            string: this.string,
+            fretboardDiagram: this.fretboardDiagram,
+            lyrics: this.lyrics,
+            staffText: this.staffText,
+            color: this.color,
+            notehead: this.notehead,
+            bowing: this.bowing,
+            fingering: this.fingering,
+        };
+    }
+    static fromJSON(data) {
+        const pitch = data.pitch
+            ? new Pitch(data.pitch.midiNumber, data.pitch.step, data.pitch.alter, data.pitch.octave)
+            : undefined;
+        return new Note(data.duration, pitch, data.isRest ?? false, data.isDotted ?? false, data.accidental, data.beamGroup, data.articulation, data.dynamic, data.tie, data.slur, data.tuplet, data.hairpin, data.isGrace ?? false, data.lyric, data.chord, data.glissando, data.arpeggio, data.ottava, data.pedal, data.ornament, data.fret, data.string, data.fretboardDiagram, data.lyrics, data.staffText, data.color, data.notehead, data.bowing, data.fingering);
+    }
+}

package/dist/models/NoteSet.d.ts

@@ -0,0 +1,73 @@
+import { Note, NoteJSON } from './Note';
+import { Duration } from './types';
+export declare class NoteSet {
+    readonly notes: Note[];
+    constructor(notes: Note[]);
+    get duration(): Duration;
+    get isDotted(): boolean;
+    get isRest(): boolean;
+    get beamGroup(): number | undefined;
+    get tuplet(): import("./types").Tuplet | undefined;
+    getDurationValue(): number;
+    isBeamable(): boolean;
+    withDuration(duration: Duration, isDotted?: boolean): NoteSet;
+    withBeamGroup(group?: number): NoteSet;
+    withNotes(notes: Note[]): NoteSet;
+    withLyrics(lyrics: string[]): NoteSet;
+    withTuplet(tuplet?: any): NoteSet;
+    withPitch(pitch: any): NoteSet;
+    withAccidental(accidental: any): NoteSet;
+    withRest(isRest: boolean): NoteSet;
+    withGrace(isGrace: boolean): NoteSet;
+    toggleEnharmonic(): NoteSet;
+    transpose(semitones: number): NoteSet;
+    transposeOctave(octaves: number): NoteSet;
+    transposeDiatonic(steps: number): 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;
+    withColor(color?: string): NoteSet;
+    withNotehead(notehead: any): NoteSet;
+    withBowing(bowing?: any): NoteSet;
+    withFingering(fingering?: number): NoteSet;
+    withLyric(lyric?: any): NoteSet;
+    withStaffText(text?: string): NoteSet;
+    withFretboardDiagram(diagram?: any): NoteSet;
+    get pitch(): import("./Pitch").Pitch | undefined;
+    get accidental(): import("./types").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 color(): string | undefined;
+    get fret(): number | undefined;
+    get string(): number | undefined;
+    get bowing(): import("./types").Bowing | undefined;
+    get fingering(): number | undefined;
+    get lyrics(): string[] | undefined;
+    get lyric(): string | undefined;
+    get chord(): string | undefined;
+    get fretboardDiagram(): import("./types").FretboardDiagram | undefined;
+    get staffText(): string | undefined;
+    toJSON(): NoteSetJSON;
+    static fromJSON(data: NoteSetJSON): NoteSet;
+}
+export interface NoteSetJSON {
+    notes: NoteJSON[];
+}

package/dist/models/NoteSet.js

@@ -0,0 +1,184 @@
+import { Note } from './Note';
+export class NoteSet {
+    notes;
+    constructor(notes) {
+        this.notes = notes;
+        if (notes.length === 0) {
+            throw new Error('NoteSet must have at least one note');
+        }
+    }
+    get duration() {
+        return this.notes[0].duration;
+    }
+    get isDotted() {
+        return this.notes[0].isDotted;
+    }
+    get isRest() {
+        return this.notes[0].isRest;
+    }
+    get beamGroup() {
+        return this.notes[0].beamGroup;
+    }
+    get tuplet() {
+        return this.notes[0].tuplet;
+    }
+    getDurationValue() {
+        return this.notes[0].getDurationValue();
+    }
+    isBeamable() {
+        return this.notes[0].isBeamable();
+    }
+    withDuration(duration, isDotted = false) {
+        return new NoteSet(this.notes.map((n) => n.withDuration(duration, isDotted)));
+    }
+    withBeamGroup(group) {
+        return new NoteSet(this.notes.map((n) => n.withBeamGroup(group)));
+    }
+    withNotes(notes) {
+        return new NoteSet(notes);
+    }
+    withLyrics(lyrics) {
+        const newNotes = [...this.notes];
+        if (newNotes.length > 0) {
+            newNotes[0] = newNotes[0].withLyrics(lyrics);
+        }
+        return new NoteSet(newNotes);
+    }
+    withTuplet(tuplet) {
+        const newNotes = [...this.notes];
+        newNotes.forEach((n, i) => {
+            newNotes[i] = n.withTuplet(tuplet);
+        });
+        return new NoteSet(newNotes);
+    }
+    withPitch(pitch) {
+        const newNotes = [...this.notes];
+        if (newNotes.length > 0) {
+            newNotes[0] = newNotes[0].withPitch(pitch);
+        }
+        return new NoteSet(newNotes);
+    }
+    withAccidental(accidental) {
+        const newNotes = [...this.notes];
+        if (newNotes.length > 0) {
+            newNotes[0] = newNotes[0].withAccidental(accidental);
+        }
+        return new NoteSet(newNotes);
+    }
+    withRest(isRest) {
+        if (isRest) {
+            const first = this.notes[0];
+            return new NoteSet([first.withRest(true)]);
+        }
+        else {
+            return new NoteSet(this.notes.map(n => n.withRest(false)));
+        }
+    }
+    withGrace(isGrace) {
+        return new NoteSet(this.notes.map(n => n.withGrace(isGrace)));
+    }
+    toggleEnharmonic() {
+        const newNotes = [...this.notes];
+        if (newNotes.length > 0) {
+            newNotes[0] = newNotes[0].toggleEnharmonic();
+        }
+        return new NoteSet(newNotes);
+    }
+    transpose(semitones) {
+        return new NoteSet(this.notes.map((n) => n.transpose(semitones)));
+    }
+    transposeOctave(octaves) {
+        return new NoteSet(this.notes.map((n) => n.transposeOctave(octaves)));
+    }
+    transposeDiatonic(steps) {
+        return new NoteSet(this.notes.map((n) => n.transposeDiatonic(steps)));
+    }
+    withChord(chord) {
+        return new NoteSet(this.notes.map((n) => n.withChord(chord)));
+    }
+    withTab(fret, string) {
+        return new NoteSet(this.notes.map((n) => n.withTab(fret, string)));
+    }
+    withTie(tie) {
+        return new NoteSet(this.notes.map((n) => n.withTie(tie)));
+    }
+    withSlur(slur) {
+        return new NoteSet(this.notes.map((n) => n.withSlur(slur)));
+    }
+    withArticulation(articulation) {
+        return new NoteSet(this.notes.map((n) => n.withArticulation(articulation)));
+    }
+    withOrnament(ornament) {
+        return new NoteSet(this.notes.map((n) => n.withOrnament(ornament)));
+    }
+    withDynamic(dynamic) {
+        return new NoteSet(this.notes.map((n) => n.withDynamic(dynamic)));
+    }
+    withHairpin(hairpin) {
+        return new NoteSet(this.notes.map((n) => n.withHairpin(hairpin)));
+    }
+    withGlissando(glissando) {
+        return new NoteSet(this.notes.map((n) => n.withGlissando(glissando)));
+    }
+    withArpeggio(arpeggio) {
+        return new NoteSet(this.notes.map((n) => n.withArpeggio(arpeggio)));
+    }
+    withOttava(ottava) {
+        return new NoteSet(this.notes.map((n) => n.withOttava(ottava)));
+    }
+    withPedal(pedal) {
+        return new NoteSet(this.notes.map((n) => n.withPedal(pedal)));
+    }
+    withColor(color) {
+        return new NoteSet(this.notes.map((n) => n.withColor(color)));
+    }
+    withNotehead(notehead) {
+        return new NoteSet(this.notes.map((n) => n.withNotehead(notehead)));
+    }
+    withBowing(bowing) {
+        return new NoteSet(this.notes.map((n) => n.withBowing(bowing)));
+    }
+    withFingering(fingering) {
+        return new NoteSet(this.notes.map((n) => n.withFingering(fingering)));
+    }
+    withLyric(lyric) {
+        return new NoteSet(this.notes.map((n) => n.withLyric(lyric)));
+    }
+    withStaffText(text) {
+        return new NoteSet(this.notes.map((n) => n.withStaffText(text)));
+    }
+    withFretboardDiagram(diagram) {
+        return new NoteSet(this.notes.map((n) => n.withFretboardDiagram(diagram)));
+    }
+    get pitch() { return this.notes[0].pitch; }
+    get accidental() { return this.notes[0].accidental; }
+    get tie() { return this.notes[0].tie; }
+    get slur() { return this.notes[0].slur; }
+    get articulation() { return this.notes[0].articulation; }
+    get ornament() { return this.notes[0].ornament; }
+    get dynamic() { return this.notes[0].dynamic; }
+    get hairpin() { return this.notes[0].hairpin; }
+    get glissando() { return this.notes[0].glissando; }
+    get arpeggio() { return this.notes[0].arpeggio; }
+    get ottava() { return this.notes[0].ottava; }
+    get pedal() { return this.notes[0].pedal; }
+    get notehead() { return this.notes[0].notehead; }
+    get color() { return this.notes[0].color; }
+    get fret() { return this.notes[0].fret; }
+    get string() { return this.notes[0].string; }
+    get bowing() { return this.notes[0].bowing; }
+    get fingering() { return this.notes[0].fingering; }
+    get lyrics() { return this.notes[0].lyrics; }
+    get lyric() { return this.notes[0].lyric; }
+    get chord() { return this.notes[0].chord; }
+    get fretboardDiagram() { return this.notes[0].fretboardDiagram; }
+    get staffText() { return this.notes[0].staffText; }
+    toJSON() {
+        return {
+            notes: this.notes.map((n) => n.toJSON()),
+        };
+    }
+    static fromJSON(data) {
+        return new NoteSet(data.notes.map((n) => Note.fromJSON(n)));
+    }
+}

package/dist/models/Part.d.ts

@@ -0,0 +1,36 @@
+import { Staff, StaffJSON } from './Staff';
+import { Instrument } from './Instrument';
+import { Note } from './Note';
+import { Measure } from './Measure';
+import { Duration } from './types';
+/**
+ * Represents a musical part (instrument/voice) which can have multiple staves.
+ */
+export declare class Part {
+    readonly name: string;
+    readonly staves: Staff[];
+    readonly abbreviation: string;
+    readonly instrument: Instrument;
+    constructor(name: string, staves: Staff[], abbreviation?: string, instrument?: Instrument);
+    isMultiStaff(): boolean;
+    getMeasureCount(): number;
+    static fromJSON(data: PartJSON): Part;
+    transpose(semitones: number): Part;
+    replaceNote(staffIndex: number, measureIndex: number, noteIndex: number, newNote: Note, voiceIndex?: number): Part;
+    replaceMeasure(staffIndex: number, measureIndex: number, newMeasure: Measure): Part;
+    deleteNote(staffIndex: number, measureIndex: number, noteIndex: number, voiceIndex?: number): Part;
+    changeNoteDuration(staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Part;
+    toJSON(): PartJSON;
+    withInstrument(instrument: Instrument): Part;
+    replaceStaff(staffIndex: number, newStaff: Staff): Part;
+    withStaves(staves: Staff[]): Part;
+    withName(name: string): Part;
+    addMeasure(index: number, measure: Measure): Part;
+    deleteMeasure(index: number): Part;
+}
+export interface PartJSON {
+    name: string;
+    staves: StaffJSON[];
+    abbreviation?: string;
+    instrument?: Instrument;
+}

package/dist/models/Part.js

@@ -0,0 +1,89 @@
+import { Staff } from './Staff';
+import { PRESET_INSTRUMENTS } from './Instrument';
+/**
+ * Represents a musical part (instrument/voice) which can have multiple staves.
+ */
+export class Part {
+    name;
+    staves;
+    abbreviation;
+    instrument;
+    constructor(name, staves, abbreviation = name.substring(0, Math.min(name.length, 3)) + '.', instrument = PRESET_INSTRUMENTS['piano']) {
+        this.name = name;
+        this.staves = staves;
+        this.abbreviation = abbreviation;
+        this.instrument = instrument;
+    }
+    isMultiStaff() {
+        return this.staves.length > 1;
+    }
+    getMeasureCount() {
+        return this.staves[0]?.getMeasureCount() ?? 0;
+    }
+    static fromJSON(data) {
+        const staves = data.staves.map((s) => Staff.fromJSON(s));
+        const instrument = data.instrument || PRESET_INSTRUMENTS['piano'];
+        return new Part(data.name, staves, data.abbreviation, instrument);
+    }
+    transpose(semitones) {
+        return new Part(this.name, this.staves.map((s) => s.transpose(semitones)), this.abbreviation, this.instrument);
+    }
+    replaceNote(staffIndex, measureIndex, noteIndex, newNote, voiceIndex = 0) {
+        if (staffIndex < 0 || staffIndex >= this.staves.length)
+            return this;
+        const newStaves = [...this.staves];
+        newStaves[staffIndex] = newStaves[staffIndex].replaceNote(measureIndex, noteIndex, newNote, voiceIndex);
+        return new Part(this.name, newStaves, this.abbreviation, this.instrument);
+    }
+    replaceMeasure(staffIndex, measureIndex, newMeasure) {
+        if (staffIndex < 0 || staffIndex >= this.staves.length)
+            return this;
+        const newStaves = [...this.staves];
+        newStaves[staffIndex] = newStaves[staffIndex].replaceMeasure(measureIndex, newMeasure);
+        return new Part(this.name, newStaves, this.abbreviation, this.instrument);
+    }
+    deleteNote(staffIndex, measureIndex, noteIndex, voiceIndex = 0) {
+        if (staffIndex < 0 || staffIndex >= this.staves.length)
+            return this;
+        const newStaves = [...this.staves];
+        newStaves[staffIndex] = newStaves[staffIndex].deleteNote(measureIndex, noteIndex, voiceIndex);
+        return new Part(this.name, newStaves, this.abbreviation, this.instrument);
+    }
+    changeNoteDuration(staffIndex, measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+        if (staffIndex < 0 || staffIndex >= this.staves.length)
+            return this;
+        const newStaves = [...this.staves];
+        newStaves[staffIndex] = newStaves[staffIndex].changeNoteDuration(measureIndex, noteIndex, newDuration, isDotted, voiceIndex);
+        return new Part(this.name, newStaves, this.abbreviation, this.instrument);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            staves: this.staves.map((s) => s.toJSON()),
+            abbreviation: this.abbreviation,
+            instrument: this.instrument,
+        };
+    }
+    withInstrument(instrument) {
+        return new Part(this.name, this.staves, this.abbreviation, instrument);
+    }
+    replaceStaff(staffIndex, newStaff) {
+        if (staffIndex < 0 || staffIndex >= this.staves.length)
+            return this;
+        const newStaves = [...this.staves];
+        newStaves[staffIndex] = newStaff;
+        return new Part(this.name, newStaves, this.abbreviation, this.instrument);
+    }
+    withStaves(staves) {
+        return new Part(this.name, staves, this.abbreviation, this.instrument);
+    }
+    withName(name) {
+        return new Part(name, this.staves, this.abbreviation, this.instrument);
+    }
+    addMeasure(index, measure) {
+        return new Part(this.name, this.staves.map((s) => s.addMeasure(index, measure)), this.abbreviation, this.instrument);
+    }
+    deleteMeasure(index) {
+        return new Part(this.name, this.staves.map((s) => s.deleteMeasure(index)), this.abbreviation, this.instrument);
+    }
+}

package/dist/models/Pitch.d.ts

@@ -0,0 +1,20 @@
+import { Clef } from './types';
+/**
+ * Pitch representation using MIDI numbers and explicit spelling (step, alter, octave).
+ */
+export declare class Pitch {
+    readonly midiNumber: number;
+    readonly step: number;
+    readonly alter: number;
+    readonly octave: number;
+    constructor(midiNumber: number, step?: number, alter?: number, octave?: number);
+    getNoteName(): string;
+    getOctave(): number;
+    getStaffPosition(clef: Clef): number;
+    getAbsoluteDiatonicStep(): number;
+    getDiatonicStep(): number;
+    transposeDiatonic(steps: number): Pitch;
+    withEnharmonicNext(): Pitch;
+    static fromNoteName(note: string, octave: number): Pitch;
+    static fromStaffPosition(clef: Clef, staffPosition: number): Pitch;
+}