@k-l-lambda/lilylet 0.1.62 → 0.1.64

package/lib/lilylet/abcDecoder.js

@@ -695,13 +695,13 @@ const convertEventTerm = (eventTerm, unitLength, pendingMarks, pendingContextCha
         return undefined;
     const firstPitch = chord.pitches[0];
     // Check if rest
-    if (firstPitch.phonet === "z" || firstPitch.phonet === "Z" || firstPitch.phonet === "x") {
+    if (firstPitch.phonet === "z" || firstPitch.phonet === "Z" || firstPitch.phonet === "x" || firstPitch.phonet === "y") {
         const duration = convertDuration(eventData.duration, unitLength);
         const rest = {
             type: "rest",
             duration,
         };
-        if (firstPitch.phonet === "x") {
+        if (firstPitch.phonet === "x" || firstPitch.phonet === "y") {
             rest.invisible = true;
         }
         if (firstPitch.phonet === "Z") {
@@ -712,7 +712,7 @@ const convertEventTerm = (eventTerm, unitLength, pendingMarks, pendingContextCha
         return rest;
     }
     // Note or chord
-    const pitches = chord.pitches.filter(p => p.phonet !== "z" && p.phonet !== "Z" && p.phonet !== "x").map(convertPitch);
+    const pitches = chord.pitches.filter(p => p.phonet !== "z" && p.phonet !== "Z" && p.phonet !== "x" && p.phonet !== "y").map(convertPitch);
     if (pitches.length === 0)
         return undefined;
     const duration = convertDuration(eventData.duration, unitLength);
@@ -781,6 +781,14 @@ const decodeTune = (tune) => {
     let tempo;
     const voiceConfigs = new Map();
     const voiceClefs = new Map();
+    // Pre-scan for unit length (needed for bare Q: tempo)
+    for (const h of headers) {
+        const hdr = h;
+        if (hdr.name === "L" && hdr.value?.numerator && hdr.value?.denominator) {
+            unitLength = hdr.value;
+            break;
+        }
+    }
     for (const h of headers) {
         if (h.comment)
             continue;
@@ -822,25 +830,45 @@ const decodeTune = (tune) => {
                     tempo = { beat: beatDuration, bpm: header.value.bpm };
                 }
                 else if (typeof header.value === "number") {
-                    tempo = { bpm: header.value };
+                    const beat = convertDuration({ numerator: 1, denominator: 1 }, unitLength);
+                    tempo = { beat, bpm: header.value };
                 }
                 break;
             case "V": {
                 const voiceValue = header.value;
                 if (voiceValue) {
-                    const voiceNum = typeof voiceValue === "number" ? voiceValue :
-                        (voiceValue.name || 1);
-                    const clefStr = typeof voiceValue === "string" ? voiceValue :
-                        (voiceValue.clef || undefined);
-                    voiceConfigs.set(voiceNum, {
-                        name: voiceNum,
+                    let voiceId;
+                    let clefStr;
+                    if (typeof voiceValue === "number") {
+                        voiceId = voiceValue;
+                    }
+                    else if (typeof voiceValue === "string") {
+                        voiceId = voiceValue;
+                    }
+                    else {
+                        const rawClef = (voiceValue.clef || "").replace(/,+$/, "").trim();
+                        const isKnownClef = !!convertClef(rawClef);
+                        if (isKnownClef) {
+                            // V:1 treble  → voiceId=number, clef=treble
+                            voiceId = voiceValue.name || 1;
+                            clefStr = rawClef;
+                        }
+                        else {
+                            // V:S clef=treble  → voiceId=voiceName, clef from properties
+                            voiceId = rawClef || voiceValue.name || 1;
+                            const propClef = (voiceValue.properties?.clef || "").replace(/,+$/, "").trim();
+                            clefStr = propClef || undefined;
+                        }
+                    }
+                    voiceConfigs.set(voiceId, {
+                        name: typeof voiceId === "number" ? voiceId : 1,
                         clef: clefStr,
-                        properties: voiceValue.properties,
+                        properties: voiceValue?.properties,
                     });
                     if (clefStr) {
                         const clef = convertClef(clefStr);
                         if (clef)
-                            voiceClefs.set(voiceNum, clef);
+                            voiceClefs.set(voiceId, clef);
                     }
                 }
                 break;

package/lib/lilylet/lilypondEncoder.js

@@ -469,6 +469,9 @@ const encodeTupletEvent = (event, env, lastDuration) => {
             newEnv = ne;
             newDuration = nd;
         }
+        else if (subEvent.type === 'context') {
+            result += encodeContextChange(subEvent) + ' ';
+        }
     }
     result += '}';
     return { str: result, newEnv, newDuration };

package/lib/lilylet/meiEncoder.js

@@ -538,7 +538,7 @@ const tupletHasInternalBeams = (event) => {
     return starts > 0 && starts === ends;
 };
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff, ottavaShift = 0, inParentBeam = false, measureAccidentals) => {
+const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff, ottavaShift = 0, inParentBeam = false, measureAccidentals, currentClef) => {
     // LilyPond \times 2/3 means "multiply duration by 2/3"
     // So 3 notes × 2/3 = 2 beats worth (3 in time of 2)
     // MEI: num = number of notes written, numbase = normal equivalent
@@ -561,6 +561,8 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
     // Handle internal beam groups: if notes have manual beam marks, respect them
     const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
     let beamOpen = false;
+    let activeClef = currentClef;
+    let endingClef;
     for (const e of event.events) {
         if (e.type === 'note') {
             const noteEvent = e;
@@ -607,13 +609,27 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
             const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
             xml += restEventToMEI(e, restIndent, keyFifths, ottavaShift, measureAccidentals);
         }
+        else if (e.type === 'context') {
+            const ctx = e;
+            if (ctx.clef && ctx.clef !== activeClef) {
+                const layerStaffNum = layerStaff || 1;
+                const effectiveStaffNum = effectiveStaff ?? layerStaffNum;
+                if (effectiveStaffNum === layerStaffNum) {
+                    const clefIndent = beamOpen ? baseIndent + '    ' : baseIndent;
+                    const clefInfo = CLEF_SHAPES[ctx.clef] || CLEF_SHAPES.treble;
+                    xml += `${clefIndent}<clef xml:id="${generateId('clef')}" shape="${clefInfo.shape}" line="${clefInfo.line}" />\n`;
+                }
+                activeClef = ctx.clef;
+                endingClef = ctx.clef;
+            }
+        }
     }
     // Close any unclosed beam
     if (beamOpen) {
         xml += `${baseIndent}</beam>\n`;
     }
     xml += `${indent}</tuplet>\n`;
-    return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+    return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, endingClef };
 };
 // Convert TremoloEvent to MEI (fingered tremolo - alternating between two notes)
 const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
@@ -688,7 +704,7 @@ const getEventBeamMarks = (event) => {
         const markOptions = extractMarkOptions(event.marks);
         return { beamStart: markOptions.beamStart, beamEnd: markOptions.beamEnd };
     }
-    if (event.type === 'tuplet') {
+    if (event.type === 'tuplet' || event.type === 'times') {
         const tuplet = event;
         // If the tuplet has internal beam groups, don't report beam marks to the parent
         // so the parent won't wrap the tuplet in an external <beam>
@@ -725,7 +741,8 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     const pedals = [];
     // Track octave spans - initialize from previous measure if continuing
     const octaves = [];
-    let currentOctave = initialOctave ? { dis: initialOctave.dis, disPlace: initialOctave.disPlace, startId: initialOctave.startId } : null;
+    const octaveEndReplacements = {};
+    let currentOctave = initialOctave ? { dis: initialOctave.dis, disPlace: initialOctave.disPlace, startId: initialOctave.startId, continued: initialOctave.continued, emitted: initialOctave.emitted, endToken: initialOctave.endToken, endFallbackId: initialOctave.endFallbackId } : null;
     let pendingOttava = null; // Track ottava to apply to next note
     let currentOttavaShift = initialOctave?.shift || 0; // Track current ottava shift for pitch encoding
     let lastNoteId = null; // Track last note id for ending ottava spans
@@ -817,6 +834,9 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
                 xml += result.xml;
                 lastNoteId = result.elementId;
+                if (currentOctave?.endToken) {
+                    octaveEndReplacements[currentOctave.endToken] = result.elementId;
+                }
                 // Flush any pending markups onto this note
                 flushPendingMarkups(result.elementId);
                 // If there's a pending ottava, start the span on this note
@@ -825,9 +845,14 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     const disPlace = pendingOttava > 0 ? 'above' : 'below';
                     // Close existing span first if it has a different value
                     if (currentOctave && (currentOctave.dis !== dis || currentOctave.disPlace !== disPlace)) {
-                        // Different value - close the old span
-                        // Use the lastNoteId from before this note (which we saved before processing)
-                        // Note: The span from previous measure will be closed by encodeMeasure
+                        if (lastNoteId) {
+                            octaves.push({
+                                dis: currentOctave.dis,
+                                disPlace: currentOctave.disPlace,
+                                startId: currentOctave.startId,
+                                endId: lastNoteId,
+                            });
+                        }
                         currentOctave = null;
                     }
                     // Start new span if we don't already have one with the same value
@@ -836,6 +861,12 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     }
                     pendingOttava = null;
                 }
+                else if (currentOctave?.continued) {
+                    if (!currentOctave.endToken) {
+                        currentOctave.startId = result.elementId;
+                    }
+                    currentOctave.continued = false;
+                }
                 // Update pending tie pitches
                 if (result.hasTieStart) {
                     pendingTiePitches = result.pitches;
@@ -923,11 +954,16 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 xml += restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
                 break;
             }
-            case 'tuplet': {
+            case 'tuplet':
+            case 'times': {
                 // Tuplet can be nested inside beam in MEI: <beam><tuplet>...</tuplet></beam>
                 // Pass beamElementOpen to tuplet so it knows not to create its own beam
-                const tupletResult = tupletEventToMEI(event, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals);
+                const tupletResult = tupletEventToMEI(event, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals, currentClef);
                 xml += tupletResult.xml;
+                // Propagate clef change from inside the tuplet to the parent tracker
+                if (tupletResult.endingClef) {
+                    currentClef = tupletResult.endingClef;
+                }
                 // Flush any pending markups onto the first note of the tuplet
                 if (tupletResult.firstNoteId) {
                     flushPendingMarkups(tupletResult.firstNoteId);
@@ -976,12 +1012,14 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     if (ctx.ottava === 0) {
                         // End current ottava span
                         if (currentOctave && lastNoteId) {
-                            octaves.push({
-                                dis: currentOctave.dis,
-                                disPlace: currentOctave.disPlace,
-                                startId: currentOctave.startId,
-                                endId: lastNoteId,
-                            });
+                            if (!currentOctave.emitted) {
+                                octaves.push({
+                                    dis: currentOctave.dis,
+                                    disPlace: currentOctave.disPlace,
+                                    startId: currentOctave.startId,
+                                    endId: lastNoteId,
+                                });
+                            }
                             currentOctave = null;
                             ottavaExplicitlyClosed = true; // Mark that we explicitly closed the span
                         }
@@ -994,7 +1032,7 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                         const dis = Math.abs(ctx.ottava) === 2 ? 15 : 8;
                         const disPlace = ctx.ottava > 0 ? 'above' : 'below';
                         if (currentOctave && currentOctave.dis === dis && currentOctave.disPlace === disPlace) {
-                            // Continuation - restore the shift but don't change the span
+                            // Continuation - restore the shift and let the existing 8va line reach this measure's first note
                             currentOttavaShift = ctx.ottava;
                         }
                         else {
@@ -1070,13 +1108,24 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     if (beamElementOpen) {
         xml += `${baseIndent}</beam>\n`;
     }
-    // Don't close ottava span at measure end - it may continue in the next measure
-    // Build pending octave state to return
+    // Emit one visible octave span for a continuing ottava; a repeated same-value command can extend it to the next measure.
+    if (currentOctave && lastNoteId && !currentOctave.emitted) {
+        const endToken = `__OTTAVA_END_${generateId('octaveEnd')}__`;
+        octaves.push({
+            dis: currentOctave.dis,
+            disPlace: currentOctave.disPlace,
+            startId: currentOctave.startId,
+            endId: endToken,
+        });
+        currentOctave.emitted = true;
+        currentOctave.endToken = endToken;
+        currentOctave.endFallbackId = lastNoteId;
+    }
     const pendingOctave = currentOctave
-        ? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift }
+        ? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift, continued: true, emitted: currentOctave.emitted, endToken: currentOctave.endToken, endFallbackId: currentOctave.endFallbackId }
         : null;
     xml += `${indent}</layer>\n`;
-    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: currentSlur?.startId || null, pendingHairpin: currentHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift };
+    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: currentSlur?.startId || null, pendingHairpin: currentHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
 };
 // Encode a staff
 const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hairpinState = {}, ottavaState = {}, keyFifths = 0, initialClef) => {
@@ -1103,6 +1152,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
     const pendingOctaves = {};
     const ottavaExplicitlyClosed = {};
     const lastNoteIds = {};
+    const octaveEndReplacements = {};
     let endingClef = initialClef;
     if (voices.length === 0) {
         xml += `${indent}    <layer xml:id="${generateId('layer')}" n="1" />\n`;
@@ -1132,6 +1182,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
             allHarmonies.push(...result.harmonies);
             allBarlines.push(...result.barlines);
             allMarkups.push(...result.markups);
+            Object.assign(octaveEndReplacements, result.octaveEndReplacements);
             // Track pending ties for this layer
             if (result.pendingTiePitches.length > 0) {
                 pendingTies[tieKey] = result.pendingTiePitches;
@@ -1184,6 +1235,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
         pendingOctaves,
         ottavaExplicitlyClosed,
         lastNoteIds,
+        octaveEndReplacements,
         endingClef,
     };
 };
@@ -1259,7 +1311,7 @@ const BARLINE_TO_MEI = {
 };
 // Encode a measure
 // encodeMeasure accepts mutable tieState, slurState, hairpinState, ottavaState and clefState that persist across measures
-const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}) => {
+const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}, octaveEndReplacements = {}) => {
     const measureId = generateId("measure");
     let staffContent = ''; // Build staff content first, then add measure tag with barline
     const allHairpins = [];
@@ -1332,39 +1384,22 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
         allHarmonies.push(...result.harmonies);
         allBarlines.push(...result.barlines);
         allMarkups.push(...result.markups);
+        Object.assign(octaveEndReplacements, result.octaveEndReplacements);
         // Update tie state with pending ties from this staff
         Object.assign(tieState, result.pendingTies);
         // Update slur state with pending slurs from this staff
         Object.assign(slurState, result.pendingSlurs);
         // Update hairpin state with pending hairpins from this staff
         Object.assign(hairpinState, result.pendingHairpins);
-        // Update ottava state with pending octaves from this staff
-        // Also handle closing spans when ottava ends
+        // Update ottava state with pending octaves from this staff.
+        // encodeLayer already emits measure-local octave spans, so keep the next measure's start independent.
         const currentStaffPrefix = `${si}-`;
         for (const [key, pending] of Object.entries(result.pendingOctaves)) {
             if (pending) {
-                // Check if this is a continuation or a new span
-                const prevPending = ottavaState[key];
-                if (prevPending && prevPending.shift === pending.shift) {
-                    // Same ottava value continues - keep the original startId
-                    ottavaState[key] = { ...pending, startId: prevPending.startId };
-                }
-                else {
-                    // Different ottava value - close the old span first if exists
-                    if (prevPending) {
-                        const lastNoteId = result.lastNoteIds[key];
-                        if (lastNoteId) {
-                            allOctaves.push({
-                                dis: prevPending.dis,
-                                disPlace: prevPending.disPlace,
-                                startId: prevPending.startId,
-                                endId: lastNoteId,
-                            });
-                        }
-                    }
-                    // Start new span
-                    ottavaState[key] = pending;
+                if (pending.endToken && pending.endFallbackId && !octaveEndReplacements[pending.endToken]) {
+                    octaveEndReplacements[pending.endToken] = pending.endFallbackId;
                 }
+                ottavaState[key] = pending;
             }
         }
         // For layers in this staff that had pending octaves but didn't in this measure, close the spans
@@ -1566,7 +1601,7 @@ const docHasBeamMarks = (doc) => {
                             }
                         }
                     }
-                    else if (event.type === 'tuplet') {
+                    else if (event.type === 'tuplet' || event.type === 'times') {
                         const tuplet = event;
                         for (const e of tuplet.events) {
                             if (e.type === 'note') {
@@ -1729,7 +1764,7 @@ const applyAutoBeamToVoice = (events, beamGroups) => {
             flushRun();
             position += dur;
         }
-        else if (event.type === 'tuplet') {
+        else if (event.type === 'tuplet' || event.type === 'times') {
             const tuplet = event;
             const ratio = tuplet.ratio; // LilyPond ratio: num/den
             // Check if all inner notes are beamable (division >= 8)
@@ -1891,6 +1926,7 @@ const encode = (doc, options = {}) => {
     const hairpinState = {};
     // Track ottava state across measures for cross-measure ottava spans
     const ottavaState = {};
+    const octaveEndReplacements = {};
     // Initialize clef state from partInfos (convert local staff to global staff)
     const clefState = {};
     for (let pi = 0; pi < partInfos.length; pi++) {
@@ -1907,7 +1943,7 @@ const encode = (doc, options = {}) => {
                 for (const event of voice.events) {
                     // Check for actual musical content (not just context changes or pitch resets)
                     if (event.type === 'note' || event.type === 'rest' ||
-                        event.type === 'tuplet' || event.type === 'tremolo') {
+                        event.type === 'tuplet' || event.type === 'times' || event.type === 'tremolo') {
                         return true;
                     }
                 }
@@ -1946,7 +1982,7 @@ const encode = (doc, options = {}) => {
                 mei += `${indent}${indent}${indent}${indent}${indent}${indent}<scoreDef xml:id="${generateId('scoredef')}"${meterSymAttr} meter.count="${currentTimeNum}" meter.unit="${currentTimeDen}" />\n`;
             }
         }
-        mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState);
+        mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements);
     });
     mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;
     mei += `${indent}${indent}${indent}${indent}</score>\n`;
@@ -1954,6 +1990,9 @@ const encode = (doc, options = {}) => {
     mei += `${indent}${indent}</body>\n`;
     mei += `${indent}</music>\n`;
     mei += '</mei>\n';
+    for (const [token, endId] of Object.entries(octaveEndReplacements)) {
+        mei = mei.replaceAll(token, endId);
+    }
     return mei;
 };
 // Escape XML special characters

package/lib/source/abc/abc.d.ts

@@ -0,0 +1,102 @@
+interface Fraction {
+    numerator: number;
+    denominator: number;
+}
+declare namespace ABC {
+    type Token = string;
+    interface KeyValue {
+        name: string;
+        value: any;
+    }
+    export interface ControlTerm {
+        control: KeyValue;
+    }
+    export interface Triplet {
+        triplet: number;
+        multiplier?: number;
+        n?: number;
+    }
+    export interface OctaveShift {
+        octaveShift: number;
+    }
+    export interface Fingering {
+        fingering: string;
+    }
+    export interface Tremolo {
+        tremolo: number;
+    }
+    interface Grace {
+        grace: boolean;
+        acciaccatura: Token;
+        events: GraceMusicTerm[];
+    }
+    interface Comment {
+        comment: string;
+    }
+    export interface Articulation {
+        articulation: Token;
+        scope?: '(' | ')';
+    }
+    export type Expressive = Articulation | {
+        express: Token;
+    };
+    export interface TextTerm {
+        text: string;
+    }
+    export interface Pitch {
+        acc: number | null;
+        phonet: Token;
+        quotes: number;
+        tie?: boolean;
+    }
+    export interface Chord {
+        pitches: Pitch[];
+        tie?: any;
+    }
+    export interface EventData {
+        chord: Chord;
+        duration?: Fraction;
+    }
+    export interface EventTerm {
+        event: EventData;
+        broken?: number;
+    }
+    export type MusicTerm = Expressive | TextTerm | EventTerm | Grace | ControlTerm | Triplet | OctaveShift | Fingering | Tremolo;
+    export type GraceMusicTerm = Expressive | EventTerm | Fingering;
+    type Header = KeyValue | Comment;
+    export interface BarPatch {
+        control: {
+            [k: string]: any;
+        };
+        terms: MusicTerm[];
+        bar: Token;
+    }
+    export interface StaffGroup {
+        items: (StaffGroup | string)[];
+        bound?: 'arc' | 'square' | 'curly';
+    }
+    export interface StaffLayout {
+        staffLayout: StaffGroup[];
+    }
+    export interface KeySignature {
+        root: string;
+        mode?: string;
+    }
+    export interface ClefValue {
+        clef: string;
+    }
+    interface Measure {
+        index: number;
+        voices: BarPatch[];
+    }
+    interface Body {
+        measures: Measure[];
+    }
+    export interface Tune {
+        header: Header[];
+        body: Body;
+    }
+    export type Document = Tune[];
+    export {};
+}
+export { ABC, };

package/lib/source/abc/abc.js

@@ -0,0 +1,25 @@
+var ABC;
+(function (ABC) {
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+})(ABC || (ABC = {}));
+export { ABC, };

package/lib/source/abc/parser.d.ts

@@ -0,0 +1,3 @@
+import { ABC } from "./abc";
+export declare const parse: (code: string) => ABC.Document;
+export default parse;

package/lib/source/abc/parser.js

@@ -0,0 +1,6 @@
+// @ts-ignore - jison generated file
+import grammar from "./grammar.jison.js";
+export const parse = (code) => {
+    return grammar.parse(code);
+};
+export default parse;

package/lib/source/lilylet/abcDecoder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ABC Notation Decoder for Lilylet
+ *
+ * Converts ABC notation files to Lilylet's internal LilyletDoc format.
+ */
+import { LilyletDoc } from "./types";
+/**
+ * Decode ABC notation string to LilyletDoc.
+ * If the ABC contains multiple tunes, only the first is decoded.
+ */
+export declare const decode: (abcString: string) => LilyletDoc;
+/**
+ * Decode ABC notation string to multiple LilyletDocs (one per tune).
+ */
+export declare const decodeAll: (abcString: string) => LilyletDoc[];
+/**
+ * Decode an ABC file to LilyletDoc
+ */
+export declare const decodeFile: (filePath: string) => Promise<LilyletDoc>;
+declare const _default: {
+    decode: (abcString: string) => LilyletDoc;
+    decodeAll: (abcString: string) => LilyletDoc[];
+    decodeFile: (filePath: string) => Promise<LilyletDoc>;
+};
+export default _default;