@k-l-lambda/lilylet 0.1.37 → 0.1.38

package/source/lilylet/musicXmlEncoder.ts

@@ -0,0 +1,858 @@
+/**
+ * Lilylet to MusicXML Encoder
+ *
+ * Converts LilyletDoc to MusicXML format.
+ * Produces valid MusicXML 4.0 partwise documents.
+ */
+
+import {
+	LilyletDoc,
+	Measure,
+	Part,
+	Voice,
+	Event,
+	NoteEvent,
+	RestEvent,
+	ContextChange,
+	TupletEvent,
+	TremoloEvent,
+	BarlineEvent,
+	HarmonyEvent,
+	MarkupEvent,
+	Pitch,
+	Duration,
+	Mark,
+	KeySignature,
+	Clef,
+	StemDirection,
+	Accidental,
+	Phonet,
+	ArticulationType,
+	OrnamentType,
+	DynamicType,
+	HairpinType,
+	PedalType,
+	Tempo,
+	Metadata,
+	Fraction,
+} from "./types";
+
+
+// === Constants and Reverse Mappings ===
+
+// Standard divisions per quarter note
+const DIVISIONS = 4;
+
+// Phonet to MusicXML step
+const PHONET_TO_STEP: Record<string, string> = {
+	c: 'C',
+	d: 'D',
+	e: 'E',
+	f: 'F',
+	g: 'G',
+	a: 'A',
+	b: 'B',
+};
+
+// Accidental to MusicXML alter
+const ACCIDENTAL_TO_ALTER: Record<string, number> = {
+	sharp: 1,
+	flat: -1,
+	doubleSharp: 2,
+	doubleFlat: -2,
+	natural: 0,
+};
+
+// Division to MusicXML note type
+const DIVISION_TO_TYPE: Record<number, string> = {
+	0.5: 'breve',
+	1: 'whole',
+	2: 'half',
+	4: 'quarter',
+	8: 'eighth',
+	16: '16th',
+	32: '32nd',
+	64: '64th',
+	128: '128th',
+};
+
+// Key signature to fifths (major keys)
+const KEY_TO_FIFTHS: Record<string, number> = {
+	'c': 0,
+	'g': 1,
+	'd': 2,
+	'a': 3,
+	'e': 4,
+	'b': 5,
+	'f#': 6, 'fs': 6,
+	'c#': 7, 'cs': 7,
+	'f': -1,
+	'bb': -2, 'bf': -2,
+	'eb': -3, 'ef': -3,
+	'ab': -4, 'af': -4,
+	'db': -5, 'df': -5,
+	'gb': -6, 'gf': -6,
+	'cb': -7, 'cf': -7,
+};
+
+// Clef to MusicXML sign
+const CLEF_TO_SIGN: Record<string, { sign: string; line: number }> = {
+	treble: { sign: 'G', line: 2 },
+	bass: { sign: 'F', line: 4 },
+	alto: { sign: 'C', line: 3 },
+};
+
+// Articulation to MusicXML element name
+const ARTICULATION_TO_XML: Record<string, string> = {
+	staccato: 'staccato',
+	staccatissimo: 'staccatissimo',
+	tenuto: 'tenuto',
+	accent: 'accent',
+	marcato: 'strong-accent',
+	portato: 'detached-legato',
+};
+
+// Ornament to MusicXML element name
+const ORNAMENT_TO_XML: Record<string, string> = {
+	trill: 'trill-mark',
+	turn: 'turn',
+	mordent: 'mordent',
+	prall: 'inverted-mordent',
+};
+
+// Dynamic to MusicXML element name
+const DYNAMIC_TO_XML: Record<string, string> = {
+	ppp: 'ppp',
+	pp: 'pp',
+	p: 'p',
+	mp: 'mp',
+	mf: 'mf',
+	f: 'f',
+	ff: 'ff',
+	fff: 'fff',
+	sfz: 'sfz',
+	rfz: 'rfz',
+};
+
+// Barline style to MusicXML
+const BARLINE_TO_XML: Record<string, { barStyle: string; repeat?: string }> = {
+	'|': { barStyle: 'regular' },
+	'||': { barStyle: 'light-light' },
+	'|.': { barStyle: 'light-heavy' },
+	'.|:': { barStyle: 'heavy-light', repeat: 'forward' },
+	':|.': { barStyle: 'light-heavy', repeat: 'backward' },
+	':..:': { barStyle: 'light-heavy', repeat: 'backward' },  // Will need special handling
+};
+
+
+// === XML Helper Functions ===
+
+const escapeXml = (text: string): string => {
+	return text
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&apos;');
+};
+
+const indent = (level: number): string => '  '.repeat(level);
+
+
+// === Encoding Functions ===
+
+/**
+ * Calculate duration in MusicXML divisions
+ */
+const calculateDuration = (duration: Duration): number => {
+	// Base duration: DIVISIONS * (4 / division)
+	// e.g., quarter (4) = DIVISIONS * 1 = 4
+	//       half (2) = DIVISIONS * 2 = 8
+	//       eighth (8) = DIVISIONS * 0.5 = 2
+	let dur = DIVISIONS * (4 / duration.division);
+
+	// Apply dots
+	if (duration.dots) {
+		let dotValue = dur / 2;
+		for (let i = 0; i < duration.dots; i++) {
+			dur += dotValue;
+			dotValue /= 2;
+		}
+	}
+
+	// Apply tuplet ratio
+	if (duration.tuplet) {
+		dur = dur * duration.tuplet.denominator / duration.tuplet.numerator;
+	}
+
+	return Math.round(dur);
+};
+
+
+/**
+ * Encode pitch to MusicXML
+ */
+const encodePitch = (pitch: Pitch, level: number): string => {
+	const step = PHONET_TO_STEP[pitch.phonet] || 'C';
+	const octave = pitch.octave + 4;  // Lilylet octave 0 = MusicXML octave 4
+	const alter = pitch.accidental ? ACCIDENTAL_TO_ALTER[pitch.accidental] : undefined;
+
+	let xml = `${indent(level)}<pitch>\n`;
+	xml += `${indent(level + 1)}<step>${step}</step>\n`;
+	if (alter !== undefined && alter !== 0) {
+		xml += `${indent(level + 1)}<alter>${alter}</alter>\n`;
+	}
+	xml += `${indent(level + 1)}<octave>${octave}</octave>\n`;
+	xml += `${indent(level)}</pitch>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode duration elements
+ */
+const encodeDuration = (duration: Duration, level: number): string => {
+	const dur = calculateDuration(duration);
+	const type = DIVISION_TO_TYPE[duration.division] || 'quarter';
+
+	let xml = `${indent(level)}<duration>${dur}</duration>\n`;
+	xml += `${indent(level)}<type>${type}</type>\n`;
+
+	for (let i = 0; i < duration.dots; i++) {
+		xml += `${indent(level)}<dot/>\n`;
+	}
+
+	if (duration.tuplet) {
+		xml += `${indent(level)}<time-modification>\n`;
+		xml += `${indent(level + 1)}<actual-notes>${duration.tuplet.numerator}</actual-notes>\n`;
+		xml += `${indent(level + 1)}<normal-notes>${duration.tuplet.denominator}</normal-notes>\n`;
+		xml += `${indent(level)}</time-modification>\n`;
+	}
+
+	return xml;
+};
+
+
+/**
+ * Encode key signature to fifths
+ */
+const getKeyFifths = (key: KeySignature): number => {
+	let keyStr = key.pitch as string;
+	if (key.accidental === Accidental.sharp) {
+		keyStr += 's';
+	} else if (key.accidental === Accidental.flat) {
+		keyStr += 'f';
+	}
+
+	let fifths = KEY_TO_FIFTHS[keyStr.toLowerCase()] ?? 0;
+
+	// Adjust for minor mode (relative minor is 3 fifths down)
+	if (key.mode === 'minor') {
+		// Minor keys have same fifths as their relative major
+		// e.g., A minor = C major = 0 fifths
+	}
+
+	return fifths;
+};
+
+
+/**
+ * Encode attributes element (key, time, clef, divisions)
+ */
+const encodeAttributes = (
+	level: number,
+	options: {
+		divisions?: boolean;
+		key?: KeySignature;
+		time?: Fraction;
+		clef?: Clef;
+		staves?: number;
+	}
+): string => {
+	let xml = `${indent(level)}<attributes>\n`;
+
+	if (options.divisions) {
+		xml += `${indent(level + 1)}<divisions>${DIVISIONS}</divisions>\n`;
+	}
+
+	if (options.key) {
+		const fifths = getKeyFifths(options.key);
+		xml += `${indent(level + 1)}<key>\n`;
+		xml += `${indent(level + 2)}<fifths>${fifths}</fifths>\n`;
+		xml += `${indent(level + 2)}<mode>${options.key.mode}</mode>\n`;
+		xml += `${indent(level + 1)}</key>\n`;
+	}
+
+	if (options.time) {
+		xml += `${indent(level + 1)}<time>\n`;
+		xml += `${indent(level + 2)}<beats>${options.time.numerator}</beats>\n`;
+		xml += `${indent(level + 2)}<beat-type>${options.time.denominator}</beat-type>\n`;
+		xml += `${indent(level + 1)}</time>\n`;
+	}
+
+	if (options.staves && options.staves > 1) {
+		xml += `${indent(level + 1)}<staves>${options.staves}</staves>\n`;
+	}
+
+	if (options.clef) {
+		const clefInfo = CLEF_TO_SIGN[options.clef];
+		if (clefInfo) {
+			xml += `${indent(level + 1)}<clef>\n`;
+			xml += `${indent(level + 2)}<sign>${clefInfo.sign}</sign>\n`;
+			xml += `${indent(level + 2)}<line>${clefInfo.line}</line>\n`;
+			xml += `${indent(level + 1)}</clef>\n`;
+		}
+	}
+
+	xml += `${indent(level)}</attributes>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode notations (articulations, ornaments, ties, slurs, etc.)
+ */
+const encodeNotations = (marks: Mark[], level: number): string => {
+	const articulations: string[] = [];
+	const ornaments: string[] = [];
+	const otherNotations: string[] = [];
+
+	for (const mark of marks) {
+		switch (mark.markType) {
+			case 'articulation':
+				const artXml = ARTICULATION_TO_XML[mark.type];
+				if (artXml) {
+					articulations.push(`<${artXml}/>`);
+				}
+				break;
+
+			case 'ornament':
+				const ornXml = ORNAMENT_TO_XML[mark.type];
+				if (ornXml) {
+					if (mark.type === 'fermata') {
+						otherNotations.push('<fermata/>');
+					} else if (mark.type === 'arpeggio') {
+						otherNotations.push('<arpeggiate/>');
+					} else {
+						ornaments.push(`<${ornXml}/>`);
+					}
+				}
+				break;
+
+			case 'tie':
+				otherNotations.push(`<tied type="${mark.start ? 'start' : 'stop'}"/>`);
+				break;
+
+			case 'slur':
+				otherNotations.push(`<slur type="${mark.start ? 'start' : 'stop'}" number="1"/>`);
+				break;
+
+			case 'fingering':
+				// Fingering goes in technical
+				break;
+		}
+	}
+
+	if (articulations.length === 0 && ornaments.length === 0 && otherNotations.length === 0) {
+		return '';
+	}
+
+	let xml = `${indent(level)}<notations>\n`;
+
+	for (const notation of otherNotations) {
+		xml += `${indent(level + 1)}${notation}\n`;
+	}
+
+	if (articulations.length > 0) {
+		xml += `${indent(level + 1)}<articulations>\n`;
+		for (const art of articulations) {
+			xml += `${indent(level + 2)}${art}\n`;
+		}
+		xml += `${indent(level + 1)}</articulations>\n`;
+	}
+
+	if (ornaments.length > 0) {
+		xml += `${indent(level + 1)}<ornaments>\n`;
+		for (const orn of ornaments) {
+			xml += `${indent(level + 2)}${orn}\n`;
+		}
+		xml += `${indent(level + 1)}</ornaments>\n`;
+	}
+
+	xml += `${indent(level)}</notations>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode a note event
+ */
+const encodeNote = (
+	event: NoteEvent,
+	voice: number,
+	staff: number,
+	level: number,
+	isChord: boolean = false
+): string => {
+	let xml = `${indent(level)}<note>\n`;
+
+	if (isChord) {
+		xml += `${indent(level + 1)}<chord/>\n`;
+	}
+
+	if (event.grace) {
+		xml += `${indent(level + 1)}<grace/>\n`;
+	}
+
+	// Pitch (use first pitch, additional pitches become chord notes)
+	const pitch = isChord ? event.pitches[0] : event.pitches[0];
+	xml += encodePitch(pitch, level + 1);
+
+	// Duration (not for grace notes)
+	if (!event.grace) {
+		xml += encodeDuration(event.duration, level + 1);
+	} else {
+		// Grace notes still need type
+		const type = DIVISION_TO_TYPE[event.duration.division] || 'eighth';
+		xml += `${indent(level + 1)}<type>${type}</type>\n`;
+	}
+
+	// Tie notation in note element
+	const hasTieStart = event.marks?.some(m => m.markType === 'tie' && m.start);
+	const hasTieStop = event.marks?.some(m => m.markType === 'tie' && !m.start);
+	if (hasTieStart) {
+		xml += `${indent(level + 1)}<tie type="start"/>\n`;
+	}
+	if (hasTieStop) {
+		xml += `${indent(level + 1)}<tie type="stop"/>\n`;
+	}
+
+	// Voice
+	xml += `${indent(level + 1)}<voice>${voice}</voice>\n`;
+
+	// Staff (for grand staff)
+	if (staff > 0) {
+		xml += `${indent(level + 1)}<staff>${staff}</staff>\n`;
+	}
+
+	// Stem direction
+	if (event.stemDirection && event.stemDirection !== StemDirection.auto) {
+		xml += `${indent(level + 1)}<stem>${event.stemDirection}</stem>\n`;
+	}
+
+	// Beam marks
+	const beamStart = event.marks?.find(m => m.markType === 'beam' && m.start);
+	const beamEnd = event.marks?.find(m => m.markType === 'beam' && !m.start);
+	if (beamStart) {
+		xml += `${indent(level + 1)}<beam number="1">begin</beam>\n`;
+	} else if (beamEnd) {
+		xml += `${indent(level + 1)}<beam number="1">end</beam>\n`;
+	}
+
+	// Notations
+	if (event.marks && event.marks.length > 0) {
+		xml += encodeNotations(event.marks, level + 1);
+	}
+
+	xml += `${indent(level)}</note>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode a rest event
+ */
+const encodeRest = (
+	event: RestEvent,
+	voice: number,
+	staff: number,
+	level: number
+): string => {
+	let xml = `${indent(level)}<note>\n`;
+
+	xml += `${indent(level + 1)}<rest`;
+	if (event.fullMeasure) {
+		xml += ' measure="yes"';
+	}
+	xml += '/>\n';
+
+	xml += encodeDuration(event.duration, level + 1);
+
+	xml += `${indent(level + 1)}<voice>${voice}</voice>\n`;
+
+	if (staff > 0) {
+		xml += `${indent(level + 1)}<staff>${staff}</staff>\n`;
+	}
+
+	xml += `${indent(level)}</note>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode direction element (dynamics, tempo, etc.)
+ */
+const encodeDirection = (
+	marks: Mark[],
+	level: number
+): string => {
+	let xml = '';
+
+	for (const mark of marks) {
+		if (mark.markType === 'dynamic') {
+			const dynXml = DYNAMIC_TO_XML[mark.type];
+			if (dynXml) {
+				xml += `${indent(level)}<direction placement="below">\n`;
+				xml += `${indent(level + 1)}<direction-type>\n`;
+				xml += `${indent(level + 2)}<dynamics>\n`;
+				xml += `${indent(level + 3)}<${dynXml}/>\n`;
+				xml += `${indent(level + 2)}</dynamics>\n`;
+				xml += `${indent(level + 1)}</direction-type>\n`;
+				xml += `${indent(level)}</direction>\n`;
+			}
+		} else if (mark.markType === 'hairpin') {
+			let wedgeType = '';
+			if (mark.type === HairpinType.crescendoStart) {
+				wedgeType = 'crescendo';
+			} else if (mark.type === HairpinType.diminuendoStart) {
+				wedgeType = 'diminuendo';
+			} else if (mark.type === HairpinType.crescendoEnd || mark.type === HairpinType.diminuendoEnd) {
+				wedgeType = 'stop';
+			}
+			if (wedgeType) {
+				xml += `${indent(level)}<direction>\n`;
+				xml += `${indent(level + 1)}<direction-type>\n`;
+				xml += `${indent(level + 2)}<wedge type="${wedgeType}"/>\n`;
+				xml += `${indent(level + 1)}</direction-type>\n`;
+				xml += `${indent(level)}</direction>\n`;
+			}
+		} else if (mark.markType === 'pedal') {
+			let pedalType = '';
+			if (mark.type === PedalType.sustainOn) {
+				pedalType = 'start';
+			} else if (mark.type === PedalType.sustainOff) {
+				pedalType = 'stop';
+			}
+			if (pedalType) {
+				xml += `${indent(level)}<direction>\n`;
+				xml += `${indent(level + 1)}<direction-type>\n`;
+				xml += `${indent(level + 2)}<pedal type="${pedalType}"/>\n`;
+				xml += `${indent(level + 1)}</direction-type>\n`;
+				xml += `${indent(level)}</direction>\n`;
+			}
+		}
+	}
+
+	return xml;
+};
+
+
+/**
+ * Encode tempo marking
+ */
+const encodeTempo = (tempo: Tempo, level: number): string => {
+	let xml = `${indent(level)}<direction placement="above">\n`;
+	xml += `${indent(level + 1)}<direction-type>\n`;
+
+	if (tempo.beat && tempo.bpm) {
+		xml += `${indent(level + 2)}<metronome>\n`;
+		const beatUnit = DIVISION_TO_TYPE[tempo.beat.division] || 'quarter';
+		xml += `${indent(level + 3)}<beat-unit>${beatUnit}</beat-unit>\n`;
+		if (tempo.beat.dots) {
+			for (let i = 0; i < tempo.beat.dots; i++) {
+				xml += `${indent(level + 3)}<beat-unit-dot/>\n`;
+			}
+		}
+		xml += `${indent(level + 3)}<per-minute>${tempo.bpm}</per-minute>\n`;
+		xml += `${indent(level + 2)}</metronome>\n`;
+	}
+
+	if (tempo.text) {
+		xml += `${indent(level + 2)}<words>${escapeXml(tempo.text)}</words>\n`;
+	}
+
+	xml += `${indent(level + 1)}</direction-type>\n`;
+
+	if (tempo.bpm) {
+		xml += `${indent(level + 1)}<sound tempo="${tempo.bpm}"/>\n`;
+	}
+
+	xml += `${indent(level)}</direction>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode barline
+ */
+const encodeBarline = (event: BarlineEvent, level: number): string => {
+	const barInfo = BARLINE_TO_XML[event.style];
+	if (!barInfo || event.style === '|') {
+		return '';  // Regular barline, no need to encode
+	}
+
+	let xml = `${indent(level)}<barline location="right">\n`;
+	xml += `${indent(level + 1)}<bar-style>${barInfo.barStyle}</bar-style>\n`;
+
+	if (barInfo.repeat) {
+		xml += `${indent(level + 1)}<repeat direction="${barInfo.repeat}"/>\n`;
+	}
+
+	xml += `${indent(level)}</barline>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode harmony (chord symbol)
+ */
+const encodeHarmony = (event: HarmonyEvent, level: number): string => {
+	// Simple text-based harmony for now
+	let xml = `${indent(level)}<harmony>\n`;
+	xml += `${indent(level + 1)}<root>\n`;
+	xml += `${indent(level + 2)}<root-step>C</root-step>\n`;  // Placeholder
+	xml += `${indent(level + 1)}</root>\n`;
+	xml += `${indent(level + 1)}<kind text="${escapeXml(event.text)}">major</kind>\n`;
+	xml += `${indent(level)}</harmony>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode a complete measure
+ */
+const encodeMeasure = (
+	measure: Measure,
+	measureNumber: number,
+	isFirst: boolean,
+	prevKey: KeySignature | undefined,
+	prevTime: Fraction | undefined,
+	level: number
+): string => {
+	let xml = `${indent(level)}<measure number="${measureNumber}">\n`;
+
+	// Determine if we need attributes
+	const needAttributes = isFirst ||
+		(measure.key && JSON.stringify(measure.key) !== JSON.stringify(prevKey)) ||
+		(measure.timeSig && JSON.stringify(measure.timeSig) !== JSON.stringify(prevTime));
+
+	// Find max staff number
+	let maxStaff = 1;
+	for (const part of measure.parts) {
+		for (const voice of part.voices) {
+			maxStaff = Math.max(maxStaff, voice.staff || 1);
+		}
+	}
+
+	// Encode attributes if needed
+	if (needAttributes) {
+		// Find clef from first voice
+		let clef: Clef | undefined;
+		for (const part of measure.parts) {
+			for (const voice of part.voices) {
+				for (const event of voice.events) {
+					if (event.type === 'context' && event.clef) {
+						clef = event.clef;
+						break;
+					}
+				}
+				if (clef) break;
+			}
+			if (clef) break;
+		}
+
+		xml += encodeAttributes(level + 1, {
+			divisions: isFirst,
+			key: measure.key || prevKey,
+			time: measure.timeSig || prevTime,
+			clef: clef,
+			staves: maxStaff > 1 ? maxStaff : undefined,
+		});
+	}
+
+	// Encode voices
+	let voiceNum = 1;
+	let currentPosition = 0;
+
+	for (const part of measure.parts) {
+		for (const voice of part.voices) {
+			const staff = voice.staff || 1;
+			let voicePosition = 0;
+
+			// Backup if needed
+			if (currentPosition > 0 && voiceNum > 1) {
+				xml += `${indent(level + 1)}<backup>\n`;
+				xml += `${indent(level + 2)}<duration>${currentPosition}</duration>\n`;
+				xml += `${indent(level + 1)}</backup>\n`;
+				voicePosition = 0;
+			}
+
+			for (const event of voice.events) {
+				switch (event.type) {
+					case 'note': {
+						// Check for direction marks (dynamics, hairpins, pedals)
+						const directionMarks = event.marks?.filter(m =>
+							m.markType === 'dynamic' || m.markType === 'hairpin' || m.markType === 'pedal'
+						) || [];
+						if (directionMarks.length > 0) {
+							xml += encodeDirection(directionMarks, level + 1);
+						}
+
+						// Encode main note
+						xml += encodeNote(event, voiceNum, staff, level + 1);
+						const dur = calculateDuration(event.duration);
+						voicePosition += dur;
+
+						// Encode chord notes
+						for (let i = 1; i < event.pitches.length; i++) {
+							const chordEvent: NoteEvent = {
+								...event,
+								pitches: [event.pitches[i]],
+							};
+							xml += encodeNote(chordEvent, voiceNum, staff, level + 1, true);
+						}
+						break;
+					}
+
+					case 'rest': {
+						xml += encodeRest(event, voiceNum, staff, level + 1);
+						const dur = calculateDuration(event.duration);
+						voicePosition += dur;
+						break;
+					}
+
+					case 'context': {
+						if (event.tempo) {
+							xml += encodeTempo(event.tempo, level + 1);
+						}
+						// Other context changes are handled in attributes
+						break;
+					}
+
+					case 'tuplet': {
+						for (const subEvent of event.events) {
+							if (subEvent.type === 'note') {
+								xml += encodeNote(subEvent, voiceNum, staff, level + 1);
+								const dur = calculateDuration(subEvent.duration);
+								voicePosition += dur;
+							} else if (subEvent.type === 'rest') {
+								xml += encodeRest(subEvent, voiceNum, staff, level + 1);
+								const dur = calculateDuration(subEvent.duration);
+								voicePosition += dur;
+							}
+						}
+						break;
+					}
+
+					case 'barline': {
+						xml += encodeBarline(event, level + 1);
+						break;
+					}
+
+					case 'harmony': {
+						xml += encodeHarmony(event, level + 1);
+						break;
+					}
+				}
+			}
+
+			currentPosition = Math.max(currentPosition, voicePosition);
+			voiceNum++;
+		}
+	}
+
+	xml += `${indent(level)}</measure>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode metadata to MusicXML elements
+ */
+const encodeMetadata = (metadata: Metadata, level: number): string => {
+	let xml = '';
+
+	if (metadata.title) {
+		xml += `${indent(level)}<work>\n`;
+		xml += `${indent(level + 1)}<work-title>${escapeXml(metadata.title)}</work-title>\n`;
+		xml += `${indent(level)}</work>\n`;
+	}
+
+	xml += `${indent(level)}<identification>\n`;
+
+	if (metadata.composer) {
+		xml += `${indent(level + 1)}<creator type="composer">${escapeXml(metadata.composer)}</creator>\n`;
+	}
+	if (metadata.arranger) {
+		xml += `${indent(level + 1)}<creator type="arranger">${escapeXml(metadata.arranger)}</creator>\n`;
+	}
+	if (metadata.lyricist) {
+		xml += `${indent(level + 1)}<creator type="lyricist">${escapeXml(metadata.lyricist)}</creator>\n`;
+	}
+
+	xml += `${indent(level + 1)}<encoding>\n`;
+	xml += `${indent(level + 2)}<software>Lilylet</software>\n`;
+	xml += `${indent(level + 2)}<encoding-date>${new Date().toISOString().split('T')[0]}</encoding-date>\n`;
+	xml += `${indent(level + 1)}</encoding>\n`;
+
+	xml += `${indent(level)}</identification>\n`;
+
+	return xml;
+};
+
+
+/**
+ * Encode complete LilyletDoc to MusicXML
+ */
+export const encode = (doc: LilyletDoc): string => {
+	let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+	xml += '<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">\n';
+	xml += '<score-partwise version="4.0">\n';
+
+	// Metadata
+	if (doc.metadata) {
+		xml += encodeMetadata(doc.metadata, 1);
+	}
+
+	// Part list (single part for now)
+	xml += `${indent(1)}<part-list>\n`;
+	xml += `${indent(2)}<score-part id="P1">\n`;
+	xml += `${indent(3)}<part-name>${doc.metadata?.title ? escapeXml(doc.metadata.title) : 'Music'}</part-name>\n`;
+	xml += `${indent(2)}</score-part>\n`;
+	xml += `${indent(1)}</part-list>\n`;
+
+	// Part content
+	xml += `${indent(1)}<part id="P1">\n`;
+
+	let prevKey: KeySignature | undefined;
+	let prevTime: Fraction | undefined;
+
+	for (let i = 0; i < doc.measures.length; i++) {
+		const measure = doc.measures[i];
+		const isFirst = i === 0;
+
+		xml += encodeMeasure(measure, i + 1, isFirst, prevKey, prevTime, 2);
+
+		if (measure.key) prevKey = measure.key;
+		if (measure.timeSig) prevTime = measure.timeSig;
+	}
+
+	xml += `${indent(1)}</part>\n`;
+	xml += '</score-partwise>\n';
+
+	return xml;
+};
+
+
+export default {
+	encode,
+};