@scorelabs/core 1.0.7 → 1.0.9

package/dist/models/Score.js

@@ -1,3 +1,4 @@
+import { Measure } from './Measure';
 import { Part } from './Part';
 import { Duration, Genre, decomposeDuration } from './types';
 /**
@@ -120,6 +121,170 @@ export class Score {
         const updatedMeasure = measure.replaceNoteSet(noteIndex, newNote, voiceIndex);
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
+    withKeySignature(keySig) {
+        return new Score(this.title, this.composer, this.timeSignature, keySig, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+    }
+    withTimeSignature(timeSig) {
+        return new Score(this.title, this.composer, timeSig, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+    }
+    updateMeasureSignatures(measureIndex, signatures, autoBeam = true) {
+        let score = this;
+        for (let pIdx = 0; pIdx < this.parts.length; pIdx++) {
+            for (let sIdx = 0; sIdx < this.parts[pIdx].staves.length; sIdx++) {
+                const currentMsr = score.parts[pIdx].staves[sIdx].measures[measureIndex];
+                if (currentMsr) {
+                    let updatedMsr = currentMsr;
+                    if (signatures.keySignature !== undefined) {
+                        updatedMsr = updatedMsr.withKeySignature(signatures.keySignature);
+                    }
+                    if (signatures.timeSignature !== undefined) {
+                        updatedMsr = updatedMsr.withTimeSignature(signatures.timeSignature);
+                    }
+                    if (signatures.clef !== undefined) {
+                        updatedMsr = updatedMsr.withClef(signatures.clef);
+                    }
+                    score = score.replaceMeasure(pIdx, sIdx, measureIndex, updatedMsr, autoBeam);
+                }
+            }
+        }
+        if (signatures.timeSignature !== undefined) {
+            score = score.reflow(measureIndex, autoBeam);
+        }
+        return 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, autoBeam = true) {
+        let currentScore = this;
+        const allStaves = this.getAllStaves();
+        for (const { partIndex, staffIndex } of allStaves) {
+            currentScore = currentScore.reflowStaff(partIndex, staffIndex, fromMeasureIndex, autoBeam);
+        }
+        // Harmonize measure count across all staves
+        const maxMeasures = Math.max(...currentScore.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
+        const minMeasures = Math.min(...currentScore.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
+        if (maxMeasures !== minMeasures) {
+            for (let pIdx = 0; pIdx < currentScore.parts.length; pIdx++) {
+                for (let sIdx = 0; sIdx < currentScore.parts[pIdx].staves.length; sIdx++) {
+                    const staff = currentScore.parts[pIdx].staves[sIdx];
+                    if (staff.measures.length < maxMeasures) {
+                        let updatedMsrs = [...staff.measures];
+                        for (let i = staff.measures.length; i < maxMeasures; i++) {
+                            const ts = currentScore.getTimeSignatureAt(i);
+                            const targetDur = ts.beats * (4 / ts.beatType);
+                            updatedMsrs.push(new Measure([[]]).fillVoiceWithRests(0, targetDur));
+                        }
+                        currentScore = currentScore.replaceStaff(pIdx, sIdx, staff.withMeasures(updatedMsrs));
+                    }
+                }
+            }
+        }
+        return currentScore;
+    }
+    isTied(ns) {
+        return !!ns.notes[0].tie;
+    }
+    areSamePitch(ns1, ns2) {
+        if (ns1.isRest !== ns2.isRest)
+            return false;
+        if (ns1.isRest)
+            return true;
+        if (ns1.notes.length !== ns2.notes.length)
+            return false;
+        const p1 = ns1.notes.map((n) => n.pitch?.midiNumber || -1).sort((a, b) => a - b);
+        const p2 = ns2.notes.map((n) => n.pitch?.midiNumber || -1).sort((a, b) => a - b);
+        return p1.every((v, i) => v === p2[i]);
+    }
+    reflowStaff(pIdx, sIdx, fromMeasureIndex, autoBeam) {
+        const staff = this.parts[pIdx].staves[sIdx];
+        const measures = staff.measures;
+        const maxVoices = Math.max(...measures.map((m) => m.voices.length), 1);
+        let updatedMeasures = [...measures];
+        for (let vIdx = 0; vIdx < maxVoices; vIdx++) {
+            // 1. Collect notes and merge tied notes into logical streams
+            let stream = [];
+            for (let mIdx = fromMeasureIndex; mIdx < measures.length; mIdx++) {
+                const msr = measures[mIdx];
+                const voice = msr.voices[vIdx] || [];
+                for (const ns of voice) {
+                    const d = ns.getDurationValue();
+                    if (stream.length > 0 &&
+                        this.isTied(stream[stream.length - 1].ns) &&
+                        this.areSamePitch(stream[stream.length - 1].ns, ns)) {
+                        stream[stream.length - 1].duration += d;
+                    }
+                    else {
+                        stream.push({ ns, duration: d });
+                    }
+                }
+            }
+            // 2. Redistribute logical notes into measures according to time signatures
+            let currentMIdx = fromMeasureIndex;
+            let streamIdx = 0;
+            while (streamIdx < stream.length) {
+                if (currentMIdx >= updatedMeasures.length) {
+                    updatedMeasures.push(new Measure([[]]));
+                }
+                let msr = updatedMeasures[currentMIdx];
+                const ts = this.getTimeSignatureAt(currentMIdx);
+                const targetDur = ts.beats * (4 / ts.beatType);
+                const newVoices = [...msr.voices];
+                while (newVoices.length <= vIdx)
+                    newVoices.push([]);
+                newVoices[vIdx] = [];
+                msr = msr.withVoices(newVoices);
+                let currentDur = 0;
+                while (streamIdx < stream.length &&
+                    (currentDur < targetDur - 0.001 || stream[streamIdx].duration === 0)) {
+                    const logicalNote = stream[streamIdx];
+                    if (logicalNote.duration === 0) {
+                        // Grace note or zero-duration element
+                        msr = msr.withVoices(msr.voices.map((v, i) => (i === vIdx ? [...v, logicalNote.ns] : v)));
+                        streamIdx++;
+                        continue;
+                    }
+                    const remainingRoom = targetDur - currentDur;
+                    const toTake = Math.min(logicalNote.duration, remainingRoom);
+                    const parts = decomposeDuration(toTake);
+                    const newNoteSets = parts.map((p, idx) => {
+                        const isLastOfLogical = Math.abs(toTake - logicalNote.duration) < 0.001 && idx === parts.length - 1;
+                        return logicalNote.ns
+                            .withDuration(p.duration, p.isDotted)
+                            .withTie(isLastOfLogical ? !!logicalNote.ns.notes[0].tie : true);
+                    });
+                    msr = msr.withVoices(msr.voices.map((v, i) => (i === vIdx ? [...v, ...newNoteSets] : v)));
+                    logicalNote.duration -= toTake;
+                    currentDur += toTake;
+                    if (logicalNote.duration < 0.001) {
+                        streamIdx++;
+                    }
+                }
+                // Fill with rests if score is not full
+                if (currentDur < targetDur - 0.001) {
+                    msr = msr.fillVoiceWithRests(vIdx, targetDur);
+                }
+                if (autoBeam) {
+                    msr = msr.autoBeam(ts);
+                }
+                updatedMeasures[currentMIdx] = msr;
+                currentMIdx++;
+            }
+            // Ensure any remaining measures in this staff are also cleared/filled with rests for this voice
+            for (let mIdx = currentMIdx; mIdx < updatedMeasures.length; mIdx++) {
+                const ts = this.getTimeSignatureAt(mIdx);
+                const targetDur = ts.beats * (4 / ts.beatType);
+                updatedMeasures[mIdx] = updatedMeasures[mIdx]
+                    .withVoices(updatedMeasures[mIdx].voices.map((v, i) => (i === vIdx ? [] : v)))
+                    .fillVoiceWithRests(vIdx, targetDur);
+                if (autoBeam) {
+                    updatedMeasures[mIdx] = updatedMeasures[mIdx].autoBeam(ts);
+                }
+            }
+        }
+        return this.replaceStaff(pIdx, sIdx, staff.withMeasures(updatedMeasures));
+    }
     replaceMeasure(partIndex, staffIndex, measureIndex, newMeasure, autoBeam = true) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
@@ -273,17 +438,27 @@ export class Score {
         const measures = this.parts[0]?.staves[0]?.measures || [];
         const sequence = [];
         let i = 0;
-        let blockStart = 0;
+        const startRepeatStack = [0]; // Implicit start at 0
+        let justJumpedTo = -1;
         const repeatCount = new Map();
         let safetyCounter = 0;
         const MAX_SEQUENCE = 10000;
         while (i < measures.length && safetyCounter < MAX_SEQUENCE) {
             safetyCounter++;
             const m = measures[i];
-            if (m.repeats.some((r) => r.type === 'start'))
-                blockStart = i;
+            // Handle Start Repeats
+            if (m.repeats.some((r) => r.type === 'start')) {
+                // Only push if we didn't just jump here (avoid re-pushing on loop reentry)
+                if (i !== justJumpedTo) {
+                    startRepeatStack.push(i);
+                }
+            }
+            // Reset jump flag after processing start repeats check
+            if (i !== justJumpedTo)
+                justJumpedTo = -1;
             const endRepeat = m.repeats.find((r) => r.type === 'end');
             let iteration = 1;
+            // Calculate current iteration for Volta logic
             if (endRepeat)
                 iteration = (repeatCount.get(i) || 0) + 1;
             else {
@@ -307,11 +482,21 @@ export class Score {
                 const currentCount = repeatCount.get(i) || 0;
                 if (currentCount + 1 < maxTimes) {
                     repeatCount.set(i, currentCount + 1);
-                    i = blockStart;
+                    // Jump to the nearest start repeat
+                    const target = startRepeatStack[startRepeatStack.length - 1];
+                    i = target;
+                    justJumpedTo = target;
                     continue;
                 }
-                else
+                else {
+                    // Finished loop
                     repeatCount.set(i, 0);
+                    // Pop the start repeat if we have one (keeping the implicit 0)
+                    if (startRepeatStack.length > 1) {
+                        startRepeatStack.pop();
+                    }
+                    // Do not pop 0, so unmatched repeats will default to 0
+                }
             }
             i++;
         }

package/dist/models/index.d.ts

@@ -7,3 +7,4 @@ export * from './Staff';
 export * from './Part';
 export * from './Score';
 export * from './Instrument';
+export * from './PreMeasure';

package/dist/models/index.js

@@ -7,3 +7,4 @@ export * from './Staff';
 export * from './Part';
 export * from './Score';
 export * from './Instrument';
+export * from './PreMeasure';

package/dist/models/types.d.ts

@@ -1,216 +1,5 @@
 /**
  * Shared types and enums for ScoreLabs
+ * All types have been moved to ../types/ for better organization.
  */
-export declare enum StemDirection {
-    Up = "up",
-    Down = "down"
-}
-export declare enum Clef {
-    Treble = "treble",
-    Bass = "bass",
-    Alto = "alto",
-    Tenor = "tenor",
-    Percussion = "percussion",
-    Tab = "tab"
-}
-export declare enum Duration {
-    Whole = "whole",
-    Half = "half",
-    Quarter = "quarter",
-    Eighth = "eighth",
-    Sixteenth = "sixteenth",
-    ThirtySecond = "thirty-second",
-    SixtyFourth = "sixty-fourth",
-    OneHundredTwentyEighth = "one-hundred-twenty-eighth",
-    TwoHundredFiftySixth = "two-hundred-fifty-sixth"
-}
-export declare enum Accidental {
-    Sharp = "sharp",
-    Flat = "flat",
-    Natural = "natural",
-    DoubleSharp = "double-sharp",
-    DoubleFlat = "double-flat"
-}
-export declare enum Articulation {
-    Staccato = "staccato",
-    Accent = "accent",
-    Tenuto = "tenuto",
-    Marcato = "marcato",
-    Fermata = "fermata",
-    Staccatissimo = "staccatissimo",
-    Caesura = "caesura",
-    BreathMark = "breath-mark"
-}
-export declare enum Bowing {
-    DownBow = "down-bow",
-    UpBow = "up-bow"
-}
-export declare enum Syllabic {
-    Single = "single",
-    Begin = "begin",
-    Middle = "middle",
-    End = "end"
-}
-export interface Lyric {
-    text: string;
-    syllabic?: Syllabic;
-    isExtension?: boolean;
-}
-export declare enum NoteheadShape {
-    Normal = "normal",
-    Cross = "cross",// X shape (percussion, spoken)
-    Diamond = "diamond",// Harmonics
-    Slash = "slash",// Rhythmic notation
-    Triangle = "triangle",// Percussion
-    Square = "square"
-}
-export declare enum Dynamic {
-    PPP = "ppp",
-    PP = "pp",
-    P = "p",
-    MP = "mp",
-    MF = "mf",
-    F = "f",
-    FF = "ff",
-    FFF = "fff",
-    SFZ = "sfz",
-    FP = "fp"
-}
-export declare enum Genre {
-    Blues = "Blues",
-    Children = "Children",
-    Christian = "Christian",
-    Christmas = "Christmas",
-    Classical = "Classical",
-    ContestFestival = "Contest/Festival",
-    Country = "Country",
-    Educational = "Educational",
-    FilmTV = "Film/TV",
-    Folk = "Folk",
-    Games = "Games",
-    Gospel = "Gospel",
-    Holiday = "Holiday",
-    Jazz = "Jazz",
-    Latin = "Latin",
-    Musicals = "Musicals",
-    Pop = "Pop",
-    RBHipHop = "R&B/Hip-Hop",
-    Rock = "Rock",
-    Standards = "Standards",
-    Traditional = "Traditional",
-    Wedding = "Wedding",
-    World = "World",
-    Worship = "Worship",
-    Unknown = "unknown"
-}
-export interface TimeSignature {
-    beats: number;
-    beatType: number;
-    symbol?: 'common' | 'cut' | 'normal';
-}
-export interface KeySignature {
-    fifths: number;
-}
-export interface Tempo {
-    bpm: number;
-    duration: Duration;
-    isDotted: boolean;
-    text?: string;
-}
-export interface Slur {
-    placement: 'start' | 'stop';
-    direction?: 'up' | 'down';
-}
-export interface Tuplet {
-    actual: number;
-    normal: number;
-    type: 'start' | 'stop' | 'middle';
-}
-export declare enum HairpinType {
-    Crescendo = "crescendo",
-    Decrescendo = "decrescendo"
-}
-export interface Hairpin {
-    type: HairpinType;
-    placement: 'start' | 'stop';
-}
-export interface Repeat {
-    type: 'start' | 'end';
-    times?: number;
-}
-export interface Volta {
-    type: 'start' | 'stop' | 'both';
-    numbers: number[];
-}
-export declare enum BarlineStyle {
-    Regular = "regular",
-    Double = "light-light",// Double barline (often used for key changes)
-    Final = "light-heavy",
-    Dotted = "dotted",
-    Dashed = "dashed",
-    Heavy = "heavy",
-    None = "none"
-}
-export declare enum GlissandoType {
-    Wavy = "wavy",
-    Straight = "straight"
-}
-export interface Glissando {
-    type: GlissandoType;
-    placement: 'start' | 'stop';
-}
-export declare enum Arpeggio {
-    Normal = "normal",
-    Up = "up",
-    Down = "down"
-}
-export declare enum OttavaType {
-    OttavaAlta = "8va",
-    OttavaBassa = "8vb",
-    QuindicesimaAlta = "15ma",
-    QuindicesimaBassa = "15mb"
-}
-export interface Ottava {
-    type: OttavaType;
-    placement: 'start' | 'stop';
-}
-export interface Pedal {
-    type: 'sustain' | 'una-corda';
-    placement: 'start' | 'stop';
-}
-export declare enum Ornament {
-    Trill = "trill",
-    Mordent = "mordent",
-    InvertedMordent = "inverted-mordent",
-    Turn = "turn",
-    InvertedTurn = "inverted-turn",
-    Tremolo = "tremolo"
-}
-export declare const DURATION_VALUES: Record<Duration, number>;
-/**
- * Decomposes a duration value (quarter = 1) into a list of duration/dot pairs.
- */
-export declare function decomposeDuration(value: number): {
-    duration: Duration;
-    isDotted: boolean;
-    val: number;
-}[];
-export interface FretboardDot {
-    string: number;
-    fret: number;
-    label?: string;
-}
-export interface FretboardBarre {
-    fret: number;
-    startString: number;
-    endString: number;
-}
-export interface FretboardDiagram {
-    strings: number;
-    frets: number;
-    startingFret?: number;
-    dots: FretboardDot[];
-    barres?: FretboardBarre[];
-    openStrings?: number[];
-    mutedStrings?: number[];
-}
+export * from '../types/index.js';

package/dist/models/types.js

@@ -1,216 +1,5 @@
 /**
  * Shared types and enums for ScoreLabs
+ * All types have been moved to ../types/ for better organization.
  */
-// Stem direction
-export var StemDirection;
-(function (StemDirection) {
-    StemDirection["Up"] = "up";
-    StemDirection["Down"] = "down";
-})(StemDirection || (StemDirection = {}));
-// Clef types supported
-export var Clef;
-(function (Clef) {
-    Clef["Treble"] = "treble";
-    Clef["Bass"] = "bass";
-    Clef["Alto"] = "alto";
-    Clef["Tenor"] = "tenor";
-    Clef["Percussion"] = "percussion";
-    Clef["Tab"] = "tab";
-})(Clef || (Clef = {}));
-// Note duration types
-export var Duration;
-(function (Duration) {
-    Duration["Whole"] = "whole";
-    Duration["Half"] = "half";
-    Duration["Quarter"] = "quarter";
-    Duration["Eighth"] = "eighth";
-    Duration["Sixteenth"] = "sixteenth";
-    Duration["ThirtySecond"] = "thirty-second";
-    Duration["SixtyFourth"] = "sixty-fourth";
-    Duration["OneHundredTwentyEighth"] = "one-hundred-twenty-eighth";
-    Duration["TwoHundredFiftySixth"] = "two-hundred-fifty-sixth";
-})(Duration || (Duration = {}));
-// Accidental types
-export var Accidental;
-(function (Accidental) {
-    Accidental["Sharp"] = "sharp";
-    Accidental["Flat"] = "flat";
-    Accidental["Natural"] = "natural";
-    Accidental["DoubleSharp"] = "double-sharp";
-    Accidental["DoubleFlat"] = "double-flat";
-})(Accidental || (Accidental = {}));
-// Articulation types
-export var Articulation;
-(function (Articulation) {
-    Articulation["Staccato"] = "staccato";
-    Articulation["Accent"] = "accent";
-    Articulation["Tenuto"] = "tenuto";
-    Articulation["Marcato"] = "marcato";
-    Articulation["Fermata"] = "fermata";
-    Articulation["Staccatissimo"] = "staccatissimo";
-    Articulation["Caesura"] = "caesura";
-    Articulation["BreathMark"] = "breath-mark";
-})(Articulation || (Articulation = {}));
-// Bowing markings
-export var Bowing;
-(function (Bowing) {
-    Bowing["DownBow"] = "down-bow";
-    Bowing["UpBow"] = "up-bow";
-})(Bowing || (Bowing = {}));
-// Lyrics Syllabic types
-export var Syllabic;
-(function (Syllabic) {
-    Syllabic["Single"] = "single";
-    Syllabic["Begin"] = "begin";
-    Syllabic["Middle"] = "middle";
-    Syllabic["End"] = "end";
-})(Syllabic || (Syllabic = {}));
-// Notehead shapes
-export var NoteheadShape;
-(function (NoteheadShape) {
-    NoteheadShape["Normal"] = "normal";
-    NoteheadShape["Cross"] = "cross";
-    NoteheadShape["Diamond"] = "diamond";
-    NoteheadShape["Slash"] = "slash";
-    NoteheadShape["Triangle"] = "triangle";
-    NoteheadShape["Square"] = "square";
-})(NoteheadShape || (NoteheadShape = {}));
-// Dynamic markings
-export var Dynamic;
-(function (Dynamic) {
-    Dynamic["PPP"] = "ppp";
-    Dynamic["PP"] = "pp";
-    Dynamic["P"] = "p";
-    Dynamic["MP"] = "mp";
-    Dynamic["MF"] = "mf";
-    Dynamic["F"] = "f";
-    Dynamic["FF"] = "ff";
-    Dynamic["FFF"] = "fff";
-    Dynamic["SFZ"] = "sfz";
-    Dynamic["FP"] = "fp";
-})(Dynamic || (Dynamic = {}));
-// Genre types
-export var Genre;
-(function (Genre) {
-    Genre["Blues"] = "Blues";
-    Genre["Children"] = "Children";
-    Genre["Christian"] = "Christian";
-    Genre["Christmas"] = "Christmas";
-    Genre["Classical"] = "Classical";
-    Genre["ContestFestival"] = "Contest/Festival";
-    Genre["Country"] = "Country";
-    Genre["Educational"] = "Educational";
-    Genre["FilmTV"] = "Film/TV";
-    Genre["Folk"] = "Folk";
-    Genre["Games"] = "Games";
-    Genre["Gospel"] = "Gospel";
-    Genre["Holiday"] = "Holiday";
-    Genre["Jazz"] = "Jazz";
-    Genre["Latin"] = "Latin";
-    Genre["Musicals"] = "Musicals";
-    Genre["Pop"] = "Pop";
-    Genre["RBHipHop"] = "R&B/Hip-Hop";
-    Genre["Rock"] = "Rock";
-    Genre["Standards"] = "Standards";
-    Genre["Traditional"] = "Traditional";
-    Genre["Wedding"] = "Wedding";
-    Genre["World"] = "World";
-    Genre["Worship"] = "Worship";
-    Genre["Unknown"] = "unknown";
-})(Genre || (Genre = {}));
-// Hairpin (Crescendo/Decrescendo)
-export var HairpinType;
-(function (HairpinType) {
-    HairpinType["Crescendo"] = "crescendo";
-    HairpinType["Decrescendo"] = "decrescendo";
-})(HairpinType || (HairpinType = {}));
-// Barline styles
-export var BarlineStyle;
-(function (BarlineStyle) {
-    BarlineStyle["Regular"] = "regular";
-    BarlineStyle["Double"] = "light-light";
-    BarlineStyle["Final"] = "light-heavy";
-    BarlineStyle["Dotted"] = "dotted";
-    BarlineStyle["Dashed"] = "dashed";
-    BarlineStyle["Heavy"] = "heavy";
-    BarlineStyle["None"] = "none";
-})(BarlineStyle || (BarlineStyle = {}));
-// Glissando
-export var GlissandoType;
-(function (GlissandoType) {
-    GlissandoType["Wavy"] = "wavy";
-    GlissandoType["Straight"] = "straight";
-})(GlissandoType || (GlissandoType = {}));
-// Arpeggio (rolled chords)
-export var Arpeggio;
-(function (Arpeggio) {
-    Arpeggio["Normal"] = "normal";
-    Arpeggio["Up"] = "up";
-    Arpeggio["Down"] = "down";
-})(Arpeggio || (Arpeggio = {}));
-// Ottava (8va, 8vb, etc.)
-export var OttavaType;
-(function (OttavaType) {
-    OttavaType["OttavaAlta"] = "8va";
-    OttavaType["OttavaBassa"] = "8vb";
-    OttavaType["QuindicesimaAlta"] = "15ma";
-    OttavaType["QuindicesimaBassa"] = "15mb";
-})(OttavaType || (OttavaType = {}));
-// Ornaments
-export var Ornament;
-(function (Ornament) {
-    Ornament["Trill"] = "trill";
-    Ornament["Mordent"] = "mordent";
-    Ornament["InvertedMordent"] = "inverted-mordent";
-    Ornament["Turn"] = "turn";
-    Ornament["InvertedTurn"] = "inverted-turn";
-    Ornament["Tremolo"] = "tremolo";
-})(Ornament || (Ornament = {}));
-// Duration values in terms of quarter note = 1
-export const DURATION_VALUES = {
-    [Duration.Whole]: 4,
-    [Duration.Half]: 2,
-    [Duration.Quarter]: 1,
-    [Duration.Eighth]: 0.5,
-    [Duration.Sixteenth]: 0.25,
-    [Duration.ThirtySecond]: 0.125,
-    [Duration.SixtyFourth]: 0.0625,
-    [Duration.OneHundredTwentyEighth]: 0.03125,
-    [Duration.TwoHundredFiftySixth]: 0.015625,
-};
-/**
- * Decomposes a duration value (quarter = 1) into a list of duration/dot pairs.
- */
-export function decomposeDuration(value) {
-    const result = [];
-    let remaining = value;
-    const options = [
-        { val: 4, dur: Duration.Whole, dot: false },
-        { val: 3, dur: Duration.Half, dot: true },
-        { val: 2, dur: Duration.Half, dot: false },
-        { val: 1.5, dur: Duration.Quarter, dot: true },
-        { val: 1, dur: Duration.Quarter, dot: false },
-        { val: 0.75, dur: Duration.Eighth, dot: true },
-        { val: 0.5, dur: Duration.Eighth, dot: false },
-        { val: 0.375, dur: Duration.Sixteenth, dot: true },
-        { val: 0.25, dur: Duration.Sixteenth, dot: false },
-        { val: 0.1875, dur: Duration.ThirtySecond, dot: true },
-        { val: 0.125, dur: Duration.ThirtySecond, dot: false },
-        { val: 0.09375, dur: Duration.SixtyFourth, dot: true },
-        { val: 0.0625, dur: Duration.SixtyFourth, dot: false },
-    ];
-    // Protect against infinite loop with max iterations
-    let loops = 0;
-    while (remaining > 0.001 && loops < 100) {
-        const match = options.find((o) => o.val <= remaining + 0.001);
-        if (match) {
-            result.push({ duration: match.dur, isDotted: match.dot, val: match.val });
-            remaining -= match.val;
-        }
-        else {
-            break;
-        }
-        loops++;
-    }
-    return result;
-}
+export * from '../types/index.js';

package/dist/types/Accidental.d.ts

@@ -0,0 +1,7 @@
+export declare enum Accidental {
+    Sharp = "sharp",
+    Flat = "flat",
+    Natural = "natural",
+    DoubleSharp = "double-sharp",
+    DoubleFlat = "double-flat"
+}