@k-l-lambda/lilylet 0.1.33 → 0.1.35

package/source/lilylet/lilylet.jison

@@ -128,6 +128,7 @@
 	let currentKey = null;
 	let currentTimeSig = null;
 	let currentDuration = { division: 4, dots: 0 }; // default quarter note
+	let numericTimeSignature = false; // When true, 4/4 and 2/2 use numeric display instead of C/C|
 
 	// Reset parser state - call before each parse
 	const resetParserState = () => {
@@ -135,6 +136,7 @@
 		currentKey = null;
 		currentTimeSig = null;
 		currentDuration = { division: 4, dots: 0 };
+		numericTimeSignature = false;
 	};
 
 	// Export reset function
@@ -168,6 +170,8 @@
 "\\clef"						return 'CMD_CLEF'
 "\\key"							return 'CMD_KEY'
 "\\time"						return 'CMD_TIME'
+"\\numericTimeSignature"		return 'CMD_NUMERIC_TIME_SIG'
+"\\defaultTimeSignature"		return 'CMD_DEFAULT_TIME_SIG'
 "\\tempo"						return 'CMD_TEMPO'
 "\\staff"						return 'CMD_STAFF'
 "\\grace"						return 'CMD_GRACE'
@@ -329,7 +333,7 @@ part_voices
 
 voice_events
 	: /* empty */								{ $$ = []; }
-	| voice_events event						{ $$ = $1.concat(Array.isArray($2) ? $2 : [$2]); }
+	| voice_events event						{ $$ = $2 === null ? $1 : $1.concat(Array.isArray($2) ? $2 : [$2]); }
 	;
 
 event
@@ -413,6 +417,8 @@ context_event
 	| staff_cmd									-> contextChange({ staff: $1 })
 	| ottava_cmd								-> contextChange({ ottava: $1 })
 	| stem_cmd									-> contextChange({ stemDirection: $1 })
+	| numeric_time_sig_cmd						-> null
+	| default_time_sig_cmd						-> null
 	;
 
 clef_cmd
@@ -433,7 +439,29 @@ mode
 	;
 
 time_cmd
-	: CMD_TIME NUMBER '/' NUMBER				%{ currentTimeSig = fraction(Number($2), Number($4)); $$ = currentTimeSig; %}
+	: CMD_TIME NUMBER '/' NUMBER				%{
+		const num = Number($2);
+		const den = Number($4);
+		const timeSig = fraction(num, den);
+		// Add symbol for 4/4 (common) and 2/2 (cut) unless numericTimeSignature is set
+		if (!numericTimeSignature) {
+			if (num === 4 && den === 4) {
+				timeSig.symbol = 'common';
+			} else if (num === 2 && den === 2) {
+				timeSig.symbol = 'cut';
+			}
+		}
+		currentTimeSig = timeSig;
+		$$ = currentTimeSig;
+	%}
+	;
+
+numeric_time_sig_cmd
+	: CMD_NUMERIC_TIME_SIG						%{ numericTimeSignature = true; $$ = null; %}
+	;
+
+default_time_sig_cmd
+	: CMD_DEFAULT_TIME_SIG						%{ numericTimeSignature = false; $$ = null; %}
 	;
 
 tempo_cmd

package/source/lilylet/meiEncoder.ts

@@ -609,7 +609,7 @@ interface TupletEventResult {
 }
 
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0): TupletEventResult => {
+const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false): TupletEventResult => {
 	// 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
@@ -618,7 +618,6 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 
 	let xml = `${indent}<tuplet xml:id="${generateId('tuplet')}" num="${num}" numbase="${numbase}">\n`;
 
-	let inBeam = false;
 	const baseIndent = indent + '    ';
 
 	// Effective staff for cross-staff notation
@@ -634,31 +633,18 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	const turns: TurnRef[] = [];
 	const arpeggios: ArpegRef[] = [];
 
-	for (const e of event.events) {
-		// Check for beam marks in note events
-		let beamStart = false;
-		let beamEnd = false;
-		if (e.type === 'note') {
-			const markOptions = extractMarkOptions((e as NoteEvent).marks);
-			beamStart = markOptions.beamStart;
-			beamEnd = markOptions.beamEnd;
-		}
-
-		// Open beam element if beam starts
-		if (beamStart && !inBeam) {
-			xml += `${baseIndent}<beam xml:id="${generateId('beam')}">\n`;
-			inBeam = true;
-		}
-
-		const currentIndent = inBeam ? baseIndent + '    ' : baseIndent;
+	// If we're inside a parent beam, don't create internal beams - notes go directly into tuplet
+	// MEI allows: <beam><tuplet><note/>...</tuplet><tuplet><note/>...</tuplet></beam>
+	// Beam state is managed by encodeLayer, not here.
 
+	for (const e of event.events) {
 		if (e.type === 'note') {
 			// For cross-staff notation: set note's staff if different from layerStaff
 			const noteEvent = e as NoteEvent;
 			const effectiveNoteEvent = effectiveStaff && layerStaff && effectiveStaff !== layerStaff
 				? { ...noteEvent, staff: effectiveStaff }
 				: noteEvent;
-			const result = noteEventToMEI(effectiveNoteEvent, currentIndent, layerStaff, false, undefined, keyFifths, ottavaShift);
+			const result = noteEventToMEI(effectiveNoteEvent, baseIndent, layerStaff, false, undefined, keyFifths, ottavaShift);
 			xml += result.xml;
 
 			// Collect slur info
@@ -673,21 +659,10 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			if (result.turn) turns.push({ startid: result.elementId });
 			if (result.arpeggio) arpeggios.push({ plist: result.elementId });
 		} else if (e.type === 'rest') {
-			xml += restEventToMEI(e as RestEvent, currentIndent, keyFifths, ottavaShift);
-		}
-
-		// Close beam element if beam ends
-		if (beamEnd && inBeam) {
-			xml += `${baseIndent}</beam>\n`;
-			inBeam = false;
+			xml += restEventToMEI(e as RestEvent, baseIndent, keyFifths, ottavaShift);
 		}
 	}
 
-	// Close any unclosed beam
-	if (inBeam) {
-		xml += `${baseIndent}</beam>\n`;
-	}
-
 	xml += `${indent}</tuplet>\n`;
 	return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
 };
@@ -865,12 +840,35 @@ interface LayerResult {
 	endingClef?: Clef;  // For cross-measure clef tracking
 }
 
+
+// Helper: check if an event (or any note inside a tuplet) has beam start/end
+const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
+	if (event.type === 'note') {
+		const markOptions = extractMarkOptions((event as NoteEvent).marks);
+		return { beamStart: markOptions.beamStart, beamEnd: markOptions.beamEnd };
+	}
+	if (event.type === 'tuplet') {
+		const tuplet = event as TupletEvent;
+		let beamStart = false;
+		let beamEnd = false;
+		for (const e of tuplet.events) {
+			if (e.type === 'note') {
+				const markOptions = extractMarkOptions((e as NoteEvent).marks);
+				if (markOptions.beamStart) beamStart = true;
+				if (markOptions.beamEnd) beamEnd = true;
+			}
+		}
+		return { beamStart, beamEnd };
+	}
+	return { beamStart: false, beamEnd: false };
+};
+
 // Encode a layer (voice)
 const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePitches: Pitch[] = [], keyFifths: number = 0, initialClef?: Clef, initialSlur: string | null = null, initialHairpin: { form: 'cres' | 'dim'; startId: string } | null = null): LayerResult => {
 	const layerId = generateId("layer");
 	let xml = `${indent}<layer xml:id="${layerId}" n="${layerN}">\n`;
 
-	let inBeam = false;
+	let beamElementOpen = false;  // Whether actual <beam> element is open (passed to tuplets)
 	const baseIndent = indent + '    ';
 
 	// Track current clef to only emit changes
@@ -928,23 +926,16 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	};
 
 	for (const event of voice.events) {
-		// Check for beam start/end in note events
-		let beamStart = false;
-		let beamEnd = false;
-		if (event.type === 'note') {
-			const noteEvent = event as NoteEvent;
-			const markOptions = extractMarkOptions(noteEvent.marks);
-			beamStart = markOptions.beamStart;
-			beamEnd = markOptions.beamEnd;
-		}
+		// Check for beam start/end in this event (including inside tuplets)
+		const { beamStart, beamEnd } = getEventBeamMarks(event);
 
 		// Open beam element if beam starts
-		if (beamStart && !inBeam) {
+		if (beamStart && !beamElementOpen) {
 			xml += `${baseIndent}<beam xml:id="${generateId('beam')}">\n`;
-			inBeam = true;
+			beamElementOpen = true;
 		}
 
-		const currentIndent = inBeam ? baseIndent + '    ' : baseIndent;
+		const currentIndent = beamElementOpen ? baseIndent + '    ' : baseIndent;
 
 		switch (event.type) {
 			case 'note': {
@@ -1061,7 +1052,9 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift);
 				break;
 			case 'tuplet': {
-				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift);
+				// 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 as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen);
 				xml += tupletResult.xml;
 
 				// Process slur ends first (to close any pending slurs from before this tuplet)
@@ -1158,14 +1151,14 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 		}
 
 		// Close beam element if beam ends
-		if (beamEnd && inBeam) {
+		if (beamEnd && beamElementOpen) {
 			xml += `${baseIndent}</beam>\n`;
-			inBeam = false;
+			beamElementOpen = false;
 		}
 	}
 
 	// Close any unclosed beam
-	if (inBeam) {
+	if (beamElementOpen) {
 		xml += `${baseIndent}</beam>\n`;
 	}
 
@@ -1593,11 +1586,14 @@ const encodeScoreDef = (
 	timeNum: number,
 	timeDen: number,
 	partInfos: PartInfo[],
-	indent: string
+	indent: string,
+	meterSymbol?: 'common' | 'cut'
 ): string => {
 	const scoreDefId = generateId("scoredef");
 
-	let xml = `${indent}<scoreDef xml:id="${scoreDefId}" key.sig="${keySig}" meter.count="${timeNum}" meter.unit="${timeDen}">\n`;
+	// Build meter attributes
+	const meterSymAttr = meterSymbol ? ` meter.sym="${meterSymbol}"` : '';
+	let xml = `${indent}<scoreDef xml:id="${scoreDefId}" key.sig="${keySig}"${meterSymAttr} meter.count="${timeNum}" meter.unit="${timeDen}">\n`;
 	xml += `${indent}    <staffGrp xml:id="${generateId("staffgrp")}">\n`;
 
 	for (let pi = 0; pi < partInfos.length; pi++) {
@@ -1647,6 +1643,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	let currentKey = 0;
 	let currentTimeNum = 4;
 	let currentTimeDen = 4;
+	let currentMeterSymbol: 'common' | 'cut' | undefined = undefined;
 
 	const firstMeasure = doc.measures[0];
 	if (firstMeasure.key) {
@@ -1655,6 +1652,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	if (firstMeasure.timeSig) {
 		currentTimeNum = firstMeasure.timeSig.numerator;
 		currentTimeDen = firstMeasure.timeSig.denominator;
+		currentMeterSymbol = firstMeasure.timeSig.symbol;
 	}
 
 	const keySig = KEY_SIGS[currentKey] || "0";
@@ -1708,7 +1706,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	mei += `${indent}${indent}<body>\n`;
 	mei += `${indent}${indent}${indent}<mdiv xml:id="${generateId("mdiv")}">\n`;
 	mei += `${indent}${indent}${indent}${indent}<score xml:id="${generateId("score")}">\n`;
-	mei += encodeScoreDef(keySig, currentTimeNum, currentTimeDen, partInfos, `${indent}${indent}${indent}${indent}${indent}`);
+	mei += encodeScoreDef(keySig, currentTimeNum, currentTimeDen, partInfos, `${indent}${indent}${indent}${indent}${indent}`, currentMeterSymbol);
 	mei += `${indent}${indent}${indent}${indent}${indent}<section xml:id="${generateId("section")}">\n`;
 
 	// Track tie state across measures for cross-measure ties
@@ -1764,6 +1762,20 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 				mei += `${indent}${indent}${indent}${indent}${indent}${indent}<scoreDef xml:id="${generateId('scoredef')}" key.sig="${newKeySig}" />\n`;
 			}
 		}
+		// Check for time signature change and output scoreDef if needed
+		if (measure.timeSig && mi > 0) {
+			const newTimeNum = measure.timeSig.numerator;
+			const newTimeDen = measure.timeSig.denominator;
+			const newMeterSymbol = measure.timeSig.symbol;
+			if (newTimeNum !== currentTimeNum || newTimeDen !== currentTimeDen || newMeterSymbol !== currentMeterSymbol) {
+				currentTimeNum = newTimeNum;
+				currentTimeDen = newTimeDen;
+				currentMeterSymbol = newMeterSymbol;
+				// Output a scoreDef with the new time signature
+				const meterSymAttr = currentMeterSymbol ? ` meter.sym="${currentMeterSymbol}"` : '';
+				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, currentKey, partInfos, clefState);
 	});
 

package/source/lilylet/musicXmlDecoder.ts

@@ -27,6 +27,7 @@ import {
 	NavigationMarkType,
 	BarlineEvent,
 	HarmonyEvent,
+	TupletEvent,
 } from './types';
 
 import {
@@ -132,6 +133,88 @@ class SpannerTracker {
 	}
 }
 
+// ============ Tuplet Tracker ============
+
+/**
+ * Track tuplet groups by number attribute.
+ * Collects notes between tuplet start and stop to create TupletEvent.
+ */
+class TupletTracker {
+	// Map from tuplet number to collected events and ratio
+	private activeTuplets: Map<number, {
+		events: (NoteEvent | RestEvent)[];
+		ratio?: Fraction;
+	}> = new Map();
+
+	/**
+	 * Start a new tuplet group
+	 */
+	startTuplet(number: number = 1): void {
+		this.activeTuplets.set(number, { events: [] });
+	}
+
+	/**
+	 * Add an event to active tuplet(s)
+	 * Returns true if the event was added to at least one tuplet
+	 */
+	addEvent(event: NoteEvent | RestEvent): boolean {
+		if (this.activeTuplets.size === 0) return false;
+
+		// Add to all active tuplets (in case of nested tuplets)
+		for (const [, tuplet] of this.activeTuplets) {
+			// Set ratio from first event's duration.tuplet
+			if (!tuplet.ratio && event.duration.tuplet) {
+				// In Lilylet, ratio is denominator/numerator (e.g., 2/3 for triplet)
+				tuplet.ratio = {
+					numerator: event.duration.tuplet.denominator,
+					denominator: event.duration.tuplet.numerator,
+				};
+			}
+			// Store event without tuplet info in duration (it's handled at TupletEvent level)
+			const cleanEvent = { ...event, duration: { ...event.duration } };
+			delete cleanEvent.duration.tuplet;
+			tuplet.events.push(cleanEvent);
+		}
+		return true;
+	}
+
+	/**
+	 * Stop a tuplet group and return the TupletEvent
+	 */
+	stopTuplet(number: number = 1): TupletEvent | undefined {
+		const tuplet = this.activeTuplets.get(number);
+		if (!tuplet || tuplet.events.length === 0) {
+			this.activeTuplets.delete(number);
+			return undefined;
+		}
+
+		this.activeTuplets.delete(number);
+
+		// Default ratio if not set (shouldn't happen normally)
+		const ratio = tuplet.ratio || { numerator: 2, denominator: 3 };
+
+		return {
+			type: 'tuplet',
+			ratio,
+			events: tuplet.events,
+		};
+	}
+
+	/**
+	 * Check if any tuplet is active
+	 */
+	isActive(): boolean {
+		return this.activeTuplets.size > 0;
+	}
+
+	/**
+	 * Reset tracker
+	 */
+	reset(): void {
+		this.activeTuplets.clear();
+	}
+}
+
 // ============ Voice Position Tracker ============
 
 /**
@@ -940,7 +1023,8 @@ const convertMeasure = (
 	measureEl: Element,
 	voiceTracker: VoiceTracker,
 	spannerTracker: SpannerTracker,
-	ottavaTracker: { current: number }
+	ottavaTracker: { current: number },
+	tupletTracker: TupletTracker
 ): MeasureConversionResult => {
 	let key: KeySignature | undefined;
 	let timeSig: Fraction | undefined;
@@ -994,6 +1078,12 @@ const convertMeasure = (
 			const staffNum = note.staff || 1;
 			currentVoice = voiceNum;
 
+			// Check for tuplet start BEFORE processing the note
+			const tupletNotation = note.notations?.tuplet;
+			if (tupletNotation?.type === 'start') {
+				tupletTracker.startTuplet(tupletNotation.number);
+			}
+
 			// Add any pending context changes before the note (tempo, ottava)
 			if (pendingContextChanges.length > 0) {
 				for (const ctx of pendingContextChanges) {
@@ -1023,7 +1113,13 @@ const convertMeasure = (
 
 				// Grace notes don't advance time
 				const advanceDuration = note.isGrace ? 0 : note.duration.divisions;
-				voiceTracker.addEvent(voiceNum, restEvent, advanceDuration, staffNum);
+
+				// Check if we're in a tuplet
+				if (tupletTracker.isActive()) {
+					tupletTracker.addEvent(restEvent);
+				} else {
+					voiceTracker.addEvent(voiceNum, restEvent, advanceDuration, staffNum);
+				}
 			} else if (note.pitch) {
 				// Note or chord - convert MusicXmlPitch to Lilylet Pitch
 				const lilyletPitch = musicXmlPitchToLilylet(note.pitch);
@@ -1093,7 +1189,31 @@ const convertMeasure = (
 
 				// Grace notes don't advance time
 				const advanceDuration = note.isGrace ? 0 : note.duration.divisions;
-				voiceTracker.addEvent(voiceNum, noteEvent, advanceDuration, staffNum);
+
+				// Check if we're in a tuplet
+				if (tupletTracker.isActive()) {
+					tupletTracker.addEvent(noteEvent);
+				} else {
+					voiceTracker.addEvent(voiceNum, noteEvent, advanceDuration, staffNum);
+				}
+			}
+
+			// Check for tuplet stop AFTER processing the note
+			if (tupletNotation?.type === 'stop') {
+				const tupletEvent = tupletTracker.stopTuplet(tupletNotation.number);
+				if (tupletEvent) {
+					// Calculate total duration of tuplet for voiceTracker
+					let totalDuration = 0;
+					for (const evt of tupletEvent.events) {
+						if (evt.duration) {
+							// Convert division to duration units (quarter = 1)
+							totalDuration += (4 / evt.duration.division) * voiceTracker.getDivisions();
+						}
+					}
+					// Apply tuplet ratio to get actual duration
+					totalDuration = totalDuration * tupletEvent.ratio.numerator / tupletEvent.ratio.denominator;
+					voiceTracker.addEvent(voiceNum, tupletEvent, totalDuration, staffNum);
+				}
 			}
 		} else if (tagName === 'direction') {
 			const direction = parseDirection(child);
@@ -1158,6 +1278,7 @@ const convertPart = (partEl: Element): { measures: Measure[]; name?: string } =>
 	const voiceTracker = new VoiceTracker();
 	const spannerTracker = new SpannerTracker();
 	const ottavaTracker = { current: 0 };
+	const tupletTracker = new TupletTracker();
 
 	let lastKey: KeySignature | undefined;
 	let lastTimeSig: Fraction | undefined;
@@ -1168,7 +1289,7 @@ const convertPart = (partEl: Element): { measures: Measure[]; name?: string } =>
 
 	for (const measureEl of measureEls) {
 		voiceTracker.reset();
-		const { voiceMap, key, timeSig, barline, harmonies, clefs } = convertMeasure(measureEl, voiceTracker, spannerTracker, ottavaTracker);
+		const { voiceMap, key, timeSig, barline, harmonies, clefs } = convertMeasure(measureEl, voiceTracker, spannerTracker, ottavaTracker, tupletTracker);
 
 		// Update running key/time
 		if (key) lastKey = key;

package/source/lilylet/serializer.ts

@@ -550,7 +550,7 @@ const serializeEvent = (
 // Key/time signature info to inject into first voice
 interface MeasureContext {
 	key?: KeySignature;
-	time?: { numerator: number; denominator: number };
+	time?: { numerator: number; denominator: number; symbol?: 'common' | 'cut' };
 }
 
 // Serialize a voice with pitch environment tracking
@@ -585,7 +585,13 @@ const serializeVoice = (
 			parts.push('\\key ' + keyStr);
 		}
 		if (measureContext.time) {
-			parts.push('\\time ' + measureContext.time.numerator + '/' + measureContext.time.denominator);
+			const { numerator, denominator, symbol } = measureContext.time;
+			// Output \numericTimeSignature before 4/4 or 2/2 if no symbol is set
+			// (meaning numeric display was explicitly requested)
+			if (!symbol && ((numerator === 4 && denominator === 4) || (numerator === 2 && denominator === 2))) {
+				parts.push('\\numericTimeSignature');
+			}
+			parts.push('\\time ' + numerator + '/' + denominator);
 		}
 	}
 

package/source/lilylet/types.ts

@@ -99,6 +99,12 @@ export interface Fraction {
 	denominator: number;
 }
 
+// Time signature with optional symbol display
+// symbol: 'common' for C (4/4), 'cut' for C| (2/2), undefined for numeric
+export interface TimeSig extends Fraction {
+	symbol?: 'common' | 'cut';
+}
+
 export interface Pitch {
 	phonet: Phonet;
 	accidental?: Accidental;
@@ -292,7 +298,7 @@ export interface Part {
 // Measure contains parts separated by \\\
 export interface Measure {
 	key?: KeySignature;
-	timeSig?: Fraction;
+	timeSig?: TimeSig;
 	parts: Part[];
 	partial?: boolean;
 }

package/lib/lilypondDecoder.d.ts

@@ -1,28 +0,0 @@
-/**
- * LilyPond to Lilylet Decoder
- *
- * Converts LilyPond notation files to Lilylet document format using the lotus parser.
- * This module is browser-compatible - it uses pre-compiled parser from lotus.
- */
-import * as lilyParser from "@k-l-lambda/lotus/lib/inc/lilyParser/index.js";
-import { LilyletDoc, Event, Fraction } from "./types";
-interface ParsedMeasure {
-    key: number | null;
-    timeSig: Fraction | null;
-    voices: ParsedVoice[];
-    partial: boolean;
-}
-interface ParsedVoice {
-    staff: number;
-    events: Event[];
-}
-declare const parseLilyDocument: (lilyDocument: lilyParser.LilyDocument) => ParsedMeasure[];
-/**
- * Decode a LilyPond string to LilyletDoc (synchronous, browser-compatible)
- */
-declare const decode: (lilypondSource: string) => LilyletDoc;
-/**
- * Decode from pre-parsed LilyDocument (synchronous, for when you already have parsed data)
- */
-declare const decodeFromDocument: (lilyDocument: lilyParser.LilyDocument) => LilyletDoc;
-export { decode, decodeFromDocument, parseLilyDocument, };