@k-l-lambda/lilylet 0.1.48 → 0.1.50

package/lib/lilylet/lilypondEncoder.js

@@ -0,0 +1,759 @@
+/**
+ * Lilylet to LilyPond Encoder
+ *
+ * Converts LilyletDoc to LilyPond (.ly) format.
+ * Uses relative pitch mode matching LilyPond's default behavior.
+ */
+import { Accidental, } from "./types.js";
+// === Constants and Mappings ===
+const PHONETS = "cdefgab";
+// Key signature to LilyPond notation (using English note names)
+const KEY_MAP = {
+    c: { major: "c \\major", minor: "c \\minor" },
+    d: { major: "d \\major", minor: "d \\minor" },
+    e: { major: "e \\major", minor: "e \\minor" },
+    f: { major: "f \\major", minor: "f \\minor" },
+    g: { major: "g \\major", minor: "g \\minor" },
+    a: { major: "a \\major", minor: "a \\minor" },
+    b: { major: "b \\major", minor: "b \\minor" },
+};
+// Accidentals for key signatures
+const KEY_ACCIDENTAL_MAP = {
+    sharp: "s",
+    flat: "f",
+    doubleSharp: "ss",
+    doubleFlat: "ff",
+};
+// Clef names
+const CLEF_MAP = {
+    treble: "treble",
+    bass: "bass",
+    alto: "alto",
+};
+// Accidental to LilyPond notation
+const ACCIDENTAL_MAP = {
+    natural: "!",
+    sharp: "s",
+    flat: "f",
+    doubleSharp: "ss",
+    doubleFlat: "ff",
+};
+// Articulation to LilyPond notation
+const ARTICULATION_MAP = {
+    staccato: "-.",
+    staccatissimo: "-!",
+    tenuto: "--",
+    marcato: "-^",
+    accent: "->",
+    portato: "-_",
+};
+// Ornament to LilyPond notation
+const ORNAMENT_MAP = {
+    trill: "\\trill",
+    turn: "\\turn",
+    mordent: "\\mordent",
+    prall: "\\prall",
+    fermata: "\\fermata",
+    shortFermata: "\\shortfermata",
+    arpeggio: "\\arpeggio",
+};
+// Dynamic to LilyPond notation
+const DYNAMIC_MAP = {
+    ppp: "\\ppp",
+    pp: "\\pp",
+    p: "\\p",
+    mp: "\\mp",
+    mf: "\\mf",
+    f: "\\f",
+    ff: "\\ff",
+    fff: "\\fff",
+    sfz: "\\sfz",
+    rfz: "\\rfz",
+};
+// Hairpin to LilyPond notation
+const HAIRPIN_MAP = {
+    crescendoStart: "\\<",
+    crescendoEnd: "\\!",
+    diminuendoStart: "\\>",
+    diminuendoEnd: "\\!",
+};
+// Pedal to LilyPond notation
+const PEDAL_MAP = {
+    sustainOn: "\\sustainOn",
+    sustainOff: "\\sustainOff",
+    sostenutoOn: "\\sostenutoOn",
+    sostenutoOff: "\\sostenutoOff",
+    unaCordaOn: "\\unaCorda",
+    unaCordaOff: "\\treCorde",
+};
+// Stem direction
+const STEM_MAP = {
+    up: "\\stemUp",
+    down: "\\stemDown",
+    auto: "\\stemNeutral",
+};
+// Barline styles
+const BARLINE_MAP = {
+    "|": "|",
+    "||": "||",
+    "|.": "|.",
+    ".|:": ".|:",
+    ":|.": ":|.",
+    ":..:": ":..:",
+    ":..:|": ":..:|",
+};
+// === Helper Functions ===
+/**
+ * Generate a spacer rest that fills a measure based on time signature.
+ * Uses multiplication syntax: s{denominator}*{numerator}
+ * @param timeSig - Time signature { numerator, denominator }
+ * @returns LilyPond spacer rest string (e.g., "s4*3" for 3/4, "s8*6" for 6/8)
+ */
+const getSpacerRest = (timeSig) => {
+    if (!timeSig)
+        return 's1';
+    const { numerator, denominator } = timeSig;
+    return `s${denominator}*${numerator}`;
+};
+/**
+ * Calculate the octave markers needed to serialize a pitch in relative mode.
+ */
+const getRelativeOctaveMarkers = (env, pitch) => {
+    const step = PHONETS.indexOf(pitch.phonet);
+    if (step === -1) {
+        return { markers: '', newEnv: env };
+    }
+    const interval = step - env.step;
+    // Parser's octave adjustment calculation
+    const octInc = Math.floor(Math.abs(interval) / 4) * -Math.sign(interval);
+    // Without any markers, parser would calculate:
+    const baseOctave = env.octave + octInc;
+    // We need markers to reach pitch.octave from baseOctave
+    const markerCount = pitch.octave - baseOctave;
+    let markers = '';
+    if (markerCount > 0) {
+        markers = "'".repeat(markerCount);
+    }
+    else if (markerCount < 0) {
+        markers = ",".repeat(-markerCount);
+    }
+    // Update environment
+    const newEnv = {
+        step: step,
+        octave: pitch.octave
+    };
+    return { markers, newEnv };
+};
+const DEFAULT_OPTIONS = {
+    paper: { width: 210, height: 297 }, // A4 size in mm
+    fontSize: 20,
+    withMIDI: false,
+    autoBeaming: false,
+};
+// === Encoding Functions ===
+/**
+ * Encode key signature to LilyPond
+ */
+const encodeKey = (key) => {
+    let keyStr = key.pitch;
+    if (key.accidental) {
+        keyStr += KEY_ACCIDENTAL_MAP[key.accidental] || '';
+    }
+    return `\\key ${keyStr} \\${key.mode}`;
+};
+/**
+ * Encode time signature to LilyPond
+ */
+const encodeTimeSig = (timeSig) => {
+    if (timeSig.symbol === 'common') {
+        return "\\time 4/4"; // LilyPond handles C automatically
+    }
+    if (timeSig.symbol === 'cut') {
+        return "\\time 2/2"; // LilyPond handles C| automatically
+    }
+    return `\\time ${timeSig.numerator}/${timeSig.denominator}`;
+};
+/**
+ * Encode clef to LilyPond
+ */
+const encodeClef = (clef) => {
+    return `\\clef ${CLEF_MAP[clef] || clef}`;
+};
+/**
+ * Encode tempo to LilyPond
+ */
+const encodeTempo = (tempo) => {
+    let result = "\\tempo";
+    if (tempo.text) {
+        result += ` "${tempo.text}"`;
+    }
+    if (tempo.beat && tempo.bpm) {
+        const beatValue = tempo.beat.division;
+        let dots = "";
+        if (tempo.beat.dots) {
+            dots = ".".repeat(tempo.beat.dots);
+        }
+        result += ` ${beatValue}${dots} = ${tempo.bpm}`;
+    }
+    return result;
+};
+/**
+ * Encode a single pitch in relative mode
+ */
+const encodePitch = (pitch, env) => {
+    let result = pitch.phonet;
+    // Add accidental
+    if (pitch.accidental && pitch.accidental !== Accidental.natural) {
+        result += ACCIDENTAL_MAP[pitch.accidental] || '';
+    }
+    else if (pitch.accidental === Accidental.natural) {
+        result += '!';
+    }
+    // Calculate relative octave markers
+    const { markers, newEnv } = getRelativeOctaveMarkers(env, pitch);
+    result += markers;
+    return { str: result, newEnv };
+};
+/**
+ * Encode duration to LilyPond
+ */
+const encodeDuration = (duration) => {
+    let result = String(duration.division);
+    if (duration.dots) {
+        result += ".".repeat(duration.dots);
+    }
+    return result;
+};
+/**
+ * Encode marks (articulations, dynamics, etc.) to LilyPond
+ */
+const encodeMarks = (marks) => {
+    let result = '';
+    for (const mark of marks) {
+        switch (mark.markType) {
+            case 'articulation':
+                result += ARTICULATION_MAP[mark.type] || '';
+                break;
+            case 'ornament':
+                result += ORNAMENT_MAP[mark.type] || '';
+                break;
+            case 'dynamic':
+                result += DYNAMIC_MAP[mark.type] || '';
+                break;
+            case 'hairpin':
+                result += HAIRPIN_MAP[mark.type] || '';
+                break;
+            case 'tie':
+                if (mark.start) {
+                    result += '~';
+                }
+                break;
+            case 'slur':
+                result += mark.start ? '(' : ')';
+                break;
+            case 'beam':
+                result += mark.start ? '[' : ']';
+                break;
+            case 'pedal':
+                result += PEDAL_MAP[mark.type] || '';
+                break;
+            case 'fingering':
+                result += `-${mark.finger}`;
+                break;
+            case 'navigation':
+                if (mark.type === 'coda') {
+                    result += '\\coda';
+                }
+                else if (mark.type === 'segno') {
+                    result += '\\segno';
+                }
+                break;
+            case 'markup':
+                const placement = mark.placement === 'below' ? '_' : '^';
+                result += `${placement}\\markup { ${mark.content} }`;
+                break;
+        }
+    }
+    return result;
+};
+/**
+ * Encode a note event
+ */
+const encodeNoteEvent = (event, env, lastDuration) => {
+    let result = '';
+    let newEnv = env;
+    // Grace note
+    if (event.grace) {
+        result += '\\grace ';
+    }
+    // Stem direction
+    if (event.stemDirection) {
+        result += STEM_MAP[event.stemDirection] + ' ';
+    }
+    // Pitches (chord or single note)
+    if (event.pitches.length > 1) {
+        result += '<';
+        const pitchStrs = [];
+        for (const pitch of event.pitches) {
+            const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+            pitchStrs.push(str);
+            newEnv = ne;
+        }
+        result += pitchStrs.join(' ');
+        result += '>';
+    }
+    else if (event.pitches.length === 1) {
+        const { str, newEnv: ne } = encodePitch(event.pitches[0], newEnv);
+        result += str;
+        newEnv = ne;
+    }
+    // Duration (only if different from last)
+    const needDuration = !lastDuration ||
+        lastDuration.division !== event.duration.division ||
+        lastDuration.dots !== event.duration.dots;
+    if (needDuration) {
+        result += encodeDuration(event.duration);
+    }
+    // Tremolo
+    if (event.tremolo) {
+        result += `:${event.tremolo}`;
+    }
+    // Marks
+    if (event.marks) {
+        result += encodeMarks(event.marks);
+    }
+    return { str: result, newEnv, newDuration: event.duration };
+};
+/**
+ * Encode a rest event
+ */
+const encodeRestEvent = (event, env, lastDuration) => {
+    let result = '';
+    // Rest type
+    if (event.fullMeasure) {
+        result += 'R';
+    }
+    else if (event.invisible) {
+        result += 's';
+    }
+    else {
+        result += 'r';
+    }
+    // Duration
+    const needDuration = !lastDuration ||
+        lastDuration.division !== event.duration.division ||
+        lastDuration.dots !== event.duration.dots;
+    if (needDuration) {
+        result += encodeDuration(event.duration);
+    }
+    // Positioned rest
+    if (event.pitch && !event.fullMeasure && !event.invisible) {
+        const { str } = encodePitch(event.pitch, env);
+        result = str + result.slice(1); // Replace 'r' with pitch
+        result += '\\rest';
+    }
+    return { str: result, newEnv: env, newDuration: event.duration };
+};
+/**
+ * Encode a context change event
+ */
+const encodeContextChange = (event) => {
+    const parts = [];
+    if (event.key) {
+        parts.push(encodeKey(event.key));
+    }
+    if (event.time) {
+        parts.push(encodeTimeSig(event.time));
+    }
+    if (event.clef) {
+        parts.push(encodeClef(event.clef));
+    }
+    if (event.ottava !== undefined) {
+        parts.push(`\\ottava #${event.ottava}`);
+    }
+    if (event.stemDirection) {
+        parts.push(STEM_MAP[event.stemDirection]);
+    }
+    if (event.tempo) {
+        parts.push(encodeTempo(event.tempo));
+    }
+    if (event.staff) {
+        parts.push(`\\change Staff = "${event.staff}"`);
+    }
+    return parts.join(' ');
+};
+/**
+ * Encode a tuplet event
+ */
+const encodeTupletEvent = (event, env, lastDuration) => {
+    let result = `\\tuplet ${event.ratio.denominator}/${event.ratio.numerator} { `;
+    let newEnv = env;
+    let newDuration = lastDuration;
+    for (const subEvent of event.events) {
+        if (subEvent.type === 'note') {
+            const { str, newEnv: ne, newDuration: nd } = encodeNoteEvent(subEvent, newEnv, newDuration);
+            result += str + ' ';
+            newEnv = ne;
+            newDuration = nd;
+        }
+        else if (subEvent.type === 'rest') {
+            const { str, newDuration: nd } = encodeRestEvent(subEvent, newEnv, newDuration);
+            result += str + ' ';
+            newDuration = nd;
+        }
+    }
+    result += '}';
+    return { str: result, newEnv, newDuration };
+};
+/**
+ * Encode a tremolo event
+ */
+const encodeTremoloEvent = (event, env) => {
+    let newEnv = env;
+    // First chord/note
+    let pitchA = '';
+    if (event.pitchA.length > 1) {
+        pitchA += '<';
+        const pitchStrs = [];
+        for (const pitch of event.pitchA) {
+            const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+            pitchStrs.push(str);
+            newEnv = ne;
+        }
+        pitchA += pitchStrs.join(' ');
+        pitchA += '>';
+    }
+    else if (event.pitchA.length === 1) {
+        const { str, newEnv: ne } = encodePitch(event.pitchA[0], newEnv);
+        pitchA += str;
+        newEnv = ne;
+    }
+    // Second chord/note
+    let pitchB = '';
+    if (event.pitchB.length > 1) {
+        pitchB += '<';
+        const pitchStrs = [];
+        for (const pitch of event.pitchB) {
+            const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+            pitchStrs.push(str);
+            newEnv = ne;
+        }
+        pitchB += pitchStrs.join(' ');
+        pitchB += '>';
+    }
+    else if (event.pitchB.length === 1) {
+        const { str, newEnv: ne } = encodePitch(event.pitchB[0], newEnv);
+        pitchB += str;
+        newEnv = ne;
+    }
+    const result = `\\repeat tremolo ${event.count} { ${pitchA}${event.division} ${pitchB}${event.division} }`;
+    return { str: result, newEnv };
+};
+/**
+ * Encode a barline event
+ */
+const encodeBarlineEvent = (event) => {
+    const style = BARLINE_MAP[event.style] || event.style;
+    if (style === '|') {
+        return ''; // Default barline, no need to encode
+    }
+    return `\\bar "${style}"`;
+};
+/**
+ * Encode a harmony event (chord symbol)
+ * Uses the lilylet extension: \chords "text" (parsed by modified lotus grammar)
+ */
+const encodeHarmonyEvent = (event) => {
+    return `\\chords "${event.text}"`;
+};
+/**
+ * Encode a markup event
+ */
+const encodeMarkupEvent = (event) => {
+    const placement = event.placement === 'below' ? '_' : '^';
+    return `${placement}\\markup { ${event.content} }`;
+};
+/**
+ * Encode a voice to LilyPond
+ */
+const encodeVoice = (voice, measureContext, voiceIndex) => {
+    let result = '';
+    let env = { step: 0, octave: 0 }; // Start at middle C
+    let lastDuration = null;
+    for (const event of voice.events) {
+        switch (event.type) {
+            case 'note': {
+                const { str, newEnv, newDuration } = encodeNoteEvent(event, env, lastDuration);
+                result += str + ' ';
+                env = newEnv;
+                lastDuration = newDuration;
+                break;
+            }
+            case 'rest': {
+                const { str, newDuration } = encodeRestEvent(event, env, lastDuration);
+                result += str + ' ';
+                lastDuration = newDuration;
+                break;
+            }
+            case 'context': {
+                result += encodeContextChange(event) + ' ';
+                break;
+            }
+            case 'tuplet': {
+                const { str, newEnv, newDuration } = encodeTupletEvent(event, env, lastDuration);
+                result += str + ' ';
+                env = newEnv;
+                lastDuration = newDuration;
+                break;
+            }
+            case 'tremolo': {
+                const { str, newEnv } = encodeTremoloEvent(event, env);
+                result += str + ' ';
+                env = newEnv;
+                break;
+            }
+            case 'barline': {
+                const str = encodeBarlineEvent(event);
+                if (str) {
+                    result += str + ' ';
+                }
+                break;
+            }
+            case 'harmony': {
+                result += encodeHarmonyEvent(event) + ' ';
+                break;
+            }
+            case 'markup': {
+                result += encodeMarkupEvent(event) + ' ';
+                break;
+            }
+            case 'pitchReset': {
+                env = { step: 0, octave: 0 };
+                break;
+            }
+        }
+    }
+    return result.trim();
+};
+/**
+ * Encode metadata to LilyPond header block
+ */
+const encodeMetadata = (metadata) => {
+    const entries = [];
+    if (metadata.title) {
+        entries.push(`  title = "${metadata.title}"`);
+    }
+    if (metadata.subtitle) {
+        entries.push(`  subtitle = "${metadata.subtitle}"`);
+    }
+    if (metadata.composer) {
+        entries.push(`  composer = "${metadata.composer}"`);
+    }
+    if (metadata.arranger) {
+        entries.push(`  arranger = "${metadata.arranger}"`);
+    }
+    if (metadata.lyricist) {
+        entries.push(`  poet = "${metadata.lyricist}"`);
+    }
+    if (metadata.opus) {
+        entries.push(`  opus = "${metadata.opus}"`);
+    }
+    if (metadata.instrument) {
+        entries.push(`  instrument = "${metadata.instrument}"`);
+    }
+    entries.push('  tagline = ##f');
+    return entries.join('\n');
+};
+/**
+ * Encode a complete LilyletDoc to LilyPond format
+ *
+ * Structure:
+ * - Multiple parts → outer <<>>
+ * - Part with multiple staves → GrandStaff
+ * - Part with single staff → standalone Staff
+ */
+export const encode = (doc, options = {}) => {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    // Filter out trailing empty measures (measures with no musical content)
+    const hasMusicContent = (measure) => {
+        for (const part of measure.parts) {
+            for (const voice of part.voices) {
+                for (const event of voice.events) {
+                    if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'tremolo') {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    // Trim trailing empty measures
+    let measureCount = doc.measures.length;
+    while (measureCount > 0 && !hasMusicContent(doc.measures[measureCount - 1])) {
+        measureCount--;
+    }
+    const measures = doc.measures.slice(0, measureCount);
+    // Determine number of parts from the document
+    const partCount = Math.max(...measures.map(m => m.parts.length), 1);
+    const partVoices = [];
+    for (let pi = 0; pi < partCount; pi++) {
+        partVoices.push(new Map());
+    }
+    // Track time signature for each measure (for spacer rests)
+    const measureTimeSigs = [];
+    let currentKey;
+    let currentTimeSig;
+    for (let mi = 0; mi < measures.length; mi++) {
+        const measure = measures[mi];
+        // Update context from measure
+        if (measure.key)
+            currentKey = measure.key;
+        if (measure.timeSig)
+            currentTimeSig = measure.timeSig;
+        // Store time signature for this measure
+        measureTimeSigs[mi] = currentTimeSig;
+        // Process each part
+        for (let pi = 0; pi < measure.parts.length; pi++) {
+            const part = measure.parts[pi];
+            const staffMap = partVoices[pi];
+            for (let vi = 0; vi < part.voices.length; vi++) {
+                const voice = part.voices[vi];
+                const staff = voice.staff || 1;
+                if (!staffMap.has(staff)) {
+                    staffMap.set(staff, []);
+                }
+                const staffMeasures = staffMap.get(staff);
+                // Ensure we have enough measure slots
+                while (staffMeasures.length <= mi) {
+                    staffMeasures.push([]);
+                }
+                // Encode voice content
+                const voiceContent = encodeVoice(voice, {
+                    key: currentKey,
+                    timeSig: currentTimeSig,
+                    isFirst: mi === 0
+                }, vi);
+                staffMeasures[mi].push(voiceContent);
+            }
+        }
+    }
+    // Build a staff string (used for both GrandStaff children and standalone Staff)
+    // Staff ID format: "partIndex_staffIndex" (e.g., "1_1", "1_2", "2_1") for multi-part decoding
+    const buildStaffString = (measures, staffId, indent) => {
+        // Find max voices per measure for this staff
+        const maxVoices = Math.max(...measures.map(m => m.length), 1);
+        // Build voice lines
+        const voiceLines = [];
+        for (let vi = 0; vi < maxVoices; vi++) {
+            const measureContents = measures.map((m, mi) => {
+                // Use correct spacer rest based on time signature
+                const spacer = getSpacerRest(measureTimeSigs[mi]);
+                const content = m[vi] || spacer;
+                // Wrap each measure in its own \relative c' to reset pitch context
+                return `${indent}    \\relative c' { ${content} } |  % ${mi + 1}`;
+            });
+            voiceLines.push(`${indent}  \\new Voice {\n${measureContents.join('\n')}\n${indent}  }`);
+        }
+        return `${indent}\\new Staff = "${staffId}" <<\n${voiceLines.join('\n')}\n${indent}>>`;
+    };
+    // Build music content for each part
+    const partStrings = [];
+    for (let pi = 0; pi < partCount; pi++) {
+        const staffMap = partVoices[pi];
+        const staffNums = Array.from(staffMap.keys()).sort((a, b) => a - b);
+        if (staffNums.length === 0) {
+            // Empty part, skip
+            continue;
+        }
+        const partIndex = pi + 1; // 1-based part index
+        if (staffNums.length === 1) {
+            // Single staff part → standalone Staff
+            const staffNum = staffNums[0];
+            const measures = staffMap.get(staffNum);
+            const staffId = `${partIndex}_${staffNum}`;
+            const staffStr = buildStaffString(measures, staffId, '    ');
+            partStrings.push(staffStr);
+        }
+        else {
+            // Multiple staves → GrandStaff
+            const staffStrings = [];
+            for (const staffNum of staffNums) {
+                const measures = staffMap.get(staffNum);
+                const staffId = `${partIndex}_${staffNum}`;
+                const staffStr = buildStaffString(measures, staffId, '      ');
+                staffStrings.push(staffStr);
+            }
+            partStrings.push(`    \\new GrandStaff <<\n${staffStrings.join('\n')}\n    >>`);
+        }
+    }
+    const musicContent = partStrings.join('\n');
+    // Determine outer wrapper
+    // - Single part with single staff → just Staff (no outer <<>>)
+    // - Single part with multiple staves → GrandStaff (no extra outer <<>>)
+    // - Multiple parts → outer <<>>
+    let scoreContent;
+    if (partCount === 1 && partStrings.length === 1) {
+        // Single part - use as-is (already has Staff or GrandStaff)
+        scoreContent = musicContent;
+    }
+    else {
+        // Multiple parts - wrap in <<>>
+        scoreContent = `  <<\n${musicContent}\n  >>`;
+    }
+    // Build header
+    const headerContent = doc.metadata ? encodeMetadata(doc.metadata) : '  tagline = ##f';
+    // Build document
+    const paperWidth = typeof opts.paper?.width === 'number' ? `${opts.paper.width}\\mm` : opts.paper?.width || '210\\mm';
+    const paperHeight = typeof opts.paper?.height === 'number' ? `${opts.paper.height}\\mm` : opts.paper?.height || '297\\mm';
+    const lyDoc = `\\version "2.22.0"
+
+\\language "english"
+
+\\header {
+${headerContent}
+}
+
+#(set-global-staff-size ${opts.fontSize})
+
+\\paper {
+  paper-width = ${paperWidth}
+  paper-height = ${paperHeight}
+  ragged-last = ##t
+  ragged-last-bottom = ##f
+}
+
+\\layout {
+  \\context {
+    \\Score
+    autoBeaming = ##${opts.autoBeaming ? 't' : 'f'}
+  }
+}
+
+\\score {
+${scoreContent}
+
+  \\layout { }${opts.withMIDI ? '\n  \\midi { }' : ''}
+}
+`;
+    return lyDoc;
+};
+/**
+ * Encode LilyletDoc to minimal LilyPond (music content only, no headers)
+ */
+export const encodeMinimal = (doc) => {
+    const parts = [];
+    for (const measure of doc.measures) {
+        for (const part of measure.parts) {
+            for (const voice of part.voices) {
+                const content = encodeVoice(voice, { isFirst: false }, 0);
+                parts.push(content);
+            }
+        }
+        parts.push('|');
+    }
+    return parts.join(' ');
+};
+export default {
+    encode,
+    encodeMinimal,
+};