@k-l-lambda/lilylet 0.1.68 → 0.1.70

package/lib/lilylet/staffLayout.js

@@ -0,0 +1,226 @@
+/**
+ * Staff-layout parser, ported from FindLab starry (app/staffLayout/).
+ *
+ * The layout string uses STAFF as the leaf unit (distinct from ABC's %%score,
+ * which is voice-leaf). Brackets group staves: `{}` = Brace (grand staff),
+ * `<>` = Bracket, `[]` = Square; conjunctions between consecutive staves:
+ * `,` = Blank, `-` = Solid, `.` = Dashed. Staff ids are [a-zA-Z_0-9]+; a slot
+ * with no id is an anonymous staff (auto-named "1","2",…).
+ *
+ * Example: "<[v1-v2].va> {pl-pr} <b>" → 6 staves v1,v2,va,pl,pr,b grouped as
+ * a Bracket over { a Square [v1-v2] dashed-joined to va }, a Brace {pl-pr},
+ * and a Bracket <b>.
+ */
+export var StaffGroupType;
+(function (StaffGroupType) {
+    StaffGroupType[StaffGroupType["Default"] = 0] = "Default";
+    StaffGroupType[StaffGroupType["Brace"] = 1] = "Brace";
+    StaffGroupType[StaffGroupType["Bracket"] = 2] = "Bracket";
+    StaffGroupType[StaffGroupType["Square"] = 3] = "Square";
+})(StaffGroupType || (StaffGroupType = {}));
+export var StaffConjunctionType;
+(function (StaffConjunctionType) {
+    StaffConjunctionType[StaffConjunctionType["Blank"] = 0] = "Blank";
+    StaffConjunctionType[StaffConjunctionType["Dashed"] = 1] = "Dashed";
+    StaffConjunctionType[StaffConjunctionType["Solid"] = 2] = "Solid";
+})(StaffConjunctionType || (StaffConjunctionType = {}));
+const singleGroup = (id) => ({ type: StaffGroupType.Default, staff: id });
+const BOUNDS_TO_GROUPTYPE = {
+    "{": StaffGroupType.Brace,
+    "}": StaffGroupType.Brace,
+    "<": StaffGroupType.Bracket,
+    ">": StaffGroupType.Bracket,
+    "[": StaffGroupType.Square,
+    "]": StaffGroupType.Square,
+};
+const OPEN_BOUNDS = "{<[";
+const CLOSE_BOUNDS = "}>]";
+const CONJUNCTIONS_MAP = {
+    ",": StaffConjunctionType.Blank,
+    "-": StaffConjunctionType.Solid,
+    ".": StaffConjunctionType.Dashed,
+};
+// MEI staffGrp @symbol by StaffGroupType (Default → none). MEI's allowed values
+// are brace | bracket | bracketsq | line | none — note the square variant is
+// "bracketsq", NOT "square" (the latter is MusicXML's <group-symbol> value).
+const GROUP_SYMBOLS_MEI = [null, "brace", "bracket", "bracketsq"];
+const randomB64 = () => {
+    const code = Buffer.from(Math.random().toString().slice(2)).toString("base64").replace(/=/g, "");
+    return code.split("").reverse().slice(0, 6).join("");
+};
+const makeUniqueName = (set, index, prefix) => {
+    let name = prefix;
+    if (!name)
+        name = index.toString();
+    else if (set.has(name))
+        name += "_" + index.toString();
+    while (set.has(name))
+        name = (prefix ? prefix + "_" : "") + randomB64();
+    return name;
+};
+// Tokenize a layout string into RawItem[] (one per staff slot). Lexer: whitespace
+// skipped, single chars [-,.{}<>[]] are bounds/conjunctions, [a-zA-Z_0-9]+ is an id.
+// An item accumulates leading open-bounds (leftBounds), an optional id, trailing
+// close-bounds (rightBounds); a conjunction terminates the item and starts the next.
+const tokenize = (code) => {
+    const tokens = code.match(/[A-Za-z0-9_]+|[-,.{}<>\[\]]/g) || [];
+    const items = [];
+    let cur = { id: null, leftBounds: [], rightBounds: [], conjunction: null };
+    let seenId = false; // id slot filled for the current item
+    let seenRight = false; // started collecting right bounds / closing
+    const pushItem = () => {
+        items.push(cur);
+        cur = { id: null, leftBounds: [], rightBounds: [], conjunction: null };
+        seenId = false;
+        seenRight = false;
+    };
+    for (const tok of tokens) {
+        if (tok in CONJUNCTIONS_MAP) {
+            cur.conjunction = tok;
+            pushItem();
+            continue;
+        }
+        if (OPEN_BOUNDS.includes(tok)) {
+            // An open bound after the id/closing starts a fresh item's left bounds.
+            if (seenId || seenRight)
+                pushItem();
+            cur.leftBounds.push(tok);
+            continue;
+        }
+        if (CLOSE_BOUNDS.includes(tok)) {
+            cur.rightBounds.push(tok);
+            seenRight = true;
+            continue;
+        }
+        // id token
+        if (seenId || seenRight)
+            pushItem();
+        cur.id = tok;
+        seenId = true;
+    }
+    // Flush the final item if it carries any content.
+    if (cur.id !== null || cur.leftBounds.length || cur.rightBounds.length)
+        pushItem();
+    return items;
+};
+const makeGroupsFromRaw = (parent, seq) => {
+    let remains = seq;
+    while (remains.length) {
+        const word = remains.shift();
+        const bound = BOUNDS_TO_GROUPTYPE[word];
+        if (bound !== undefined) {
+            if (CLOSE_BOUNDS.includes(word) && bound === parent.type)
+                break;
+            if (OPEN_BOUNDS.includes(word)) {
+                const group = { type: bound, level: Number.isFinite(parent.level) ? parent.level + 1 : 0 };
+                remains = makeGroupsFromRaw(group, remains);
+                parent.subs = parent.subs || [];
+                parent.subs.push(group);
+            }
+        }
+        else {
+            parent.subs = parent.subs || [];
+            parent.subs.push(singleGroup(word));
+        }
+    }
+    while (parent.type === StaffGroupType.Default && parent.subs && parent.subs.length === 1) {
+        const sub = parent.subs[0];
+        parent.type = sub.type;
+        parent.subs = sub.subs;
+        parent.staff = sub.staff;
+        parent.level = sub.level;
+    }
+    while (parent.subs && parent.subs.length === 1 && parent.subs[0].type === StaffGroupType.Default) {
+        const sub = parent.subs[0];
+        parent.subs = sub.subs;
+        parent.staff = sub.staff;
+    }
+    parent.grand = parent.type === StaffGroupType.Brace && !!parent.subs && parent.subs.every(sub => !!sub.staff);
+    return remains;
+};
+const groupHead = (group) => {
+    if (group.staff)
+        return group.staff;
+    else if (group.subs)
+        return groupHead(group.subs[0]);
+};
+const groupTail = (group) => {
+    if (group.staff)
+        return group.staff;
+    else if (group.subs)
+        return groupTail(group.subs[group.subs.length - 1]);
+};
+export const groupKey = (group) => {
+    if (group.staff)
+        return group.staff;
+    else if (group.subs)
+        return `${groupHead(group)}-${groupTail(group)}`;
+};
+const groupDict = (group, dict) => {
+    const key = groupKey(group);
+    if (key !== undefined)
+        dict[key] = group;
+    if (group.subs)
+        group.subs.forEach(sub => groupDict(sub, dict));
+};
+export class StaffLayout {
+    staffIds;
+    conjunctions;
+    group;
+    groups;
+    constructor(raw) {
+        // make unique ids (anonymous slots get "1","2",… ; named collisions disambiguated)
+        const ids = new Set();
+        raw.forEach((item, i) => {
+            item.id = makeUniqueName(ids, i + 1, item.id || undefined);
+            ids.add(item.id);
+        });
+        this.staffIds = raw.map(item => item.id);
+        this.conjunctions = raw.slice(0, raw.length - 1).map(item => item.conjunction ? CONJUNCTIONS_MAP[item.conjunction] : StaffConjunctionType.Blank);
+        // make groups
+        const seq = [].concat(...raw.map(item => [...item.leftBounds, item.id, ...item.rightBounds]));
+        this.group = { type: StaffGroupType.Default };
+        makeGroupsFromRaw(this.group, seq);
+        const dict = {};
+        groupDict(this.group, dict);
+        this.groups = Object.entries(dict).map(([key, group]) => {
+            let ids = key.split("-");
+            if (ids.length === 1)
+                ids = [ids[0], ids[0]];
+            const range = ids.map(id => this.staffIds.indexOf(id));
+            const cons = this.conjunctions.slice(range[0], range[1]);
+            const bar = cons.length ? Math.min(...cons) : 0;
+            group.key = key;
+            group.bar = bar;
+            return { group, range, key };
+        });
+    }
+    get stavesCount() {
+        return this.staffIds.length;
+    }
+}
+export const parseStaffLayout = (code) => new StaffLayout(tokenize(code));
+// ── MEI staffGrp encoding (ported from FindLab staffLayout/encoding.js encodeMEI) ──
+// Recursively emit nested <staffGrp> with symbol (brace/bracket/square) and bar.thru,
+// with <staffDef n="..."> leaves keyed by staff index. nameDict maps a group key to a
+// label. Returns the inner XML (no <scoreDef> wrapper); the caller positions it.
+const bool = (x) => (x ? "true" : "false");
+const stateMEIGroup = (statements, group, nameDict, ids, indent, tab) => {
+    const pad = tab.repeat(indent);
+    const name = group.key !== undefined ? nameDict[group.key] : undefined;
+    if (group.subs) {
+        const symbol = GROUP_SYMBOLS_MEI[group.type] ? ` symbol="${GROUP_SYMBOLS_MEI[group.type]}"` : "";
+        statements.push(`${pad}<staffGrp bar.thru="${bool((group.bar ?? 0) > 1)}"${symbol}>`);
+        if (name)
+            statements.push(`${pad}${tab}<label>${name}</label>`);
+        group.subs.forEach(sub => stateMEIGroup(statements, sub, nameDict, ids, indent + 1, tab));
+        statements.push(`${pad}</staffGrp>`);
+    }
+    if (group.staff)
+        statements.push(`${pad}<staffDef n="${ids.indexOf(group.staff) + 1}">`);
+};
+export const encodeStaffLayoutMEI = (layout, nameDict = {}, indent = 0, tab = "\t") => {
+    const statements = [];
+    stateMEIGroup(statements, layout.group, nameDict, layout.staffIds, indent, tab);
+    return statements.join("\n");
+};

package/lib/lilylet/types.d.ts

@@ -239,8 +239,16 @@ export interface Metadata {
     opus?: string;
     instrument?: string;
     genre?: string;
+    staves?: string;
+    instruments?: {
+        [key: string]: InstrumentName;
+    };
     autoBeam?: 'auto' | 'on' | 'off';
 }
+export interface InstrumentName {
+    name: string;
+    shortName?: string;
+}
 export interface Part {
     name?: string;
     voices: Voice[];

package/lib/staffLayout.d.ts

@@ -0,0 +1 @@
+export * from "./lilylet/staffLayout.js";

package/lib/staffLayout.js

@@ -0,0 +1 @@
+export * from "./lilylet/staffLayout.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.68",
+  "version": "0.1.70",
   "description": "Lilylet is a lilyopnd-like sheet music language designed for Markdown rendering and symbolic music representation in AIGC applications.",
   "type": "module",
   "main": "lib/index.js",

package/source/abc/abc.jison

@@ -37,14 +37,14 @@
 
 	const patch = (terms, bar) => {
 		const control = {};
-		terms.forEach(term => {
+		(terms || []).forEach(term => {
 			if (term.control)
 				control[term.control.name] = term.control.value;
 		});
 
 		return {
 			control,
-			terms,
+			terms: terms || [],
 			bar,
 		};
 	};
@@ -195,10 +195,10 @@ Am									\b[A-G](?=[m][a][j]|[m][i][n]\b)
 a									\b[a-g](?=[\W\d\sA-Ga-g_yzHJLMOPRSTuv]*\b)
 z									\b[z]
 Z									\b[Z]
-x									\b[x](?=[\W\d\s])
+x									\b[x](?=[\W\d\s]|[_^=]*[A-Ga-g])
 y									\b[y]
 N									[0-9]
-P									\b[HJLMOPRSTuv](?=[A-Ga-g][A-Ga-g0-9]*\b)
+P									\b[HJLMOPRSTuv](?=[_^=]*[A-Ga-g][A-Ga-g0-9_^=,']*)
 PP									\b[HJLMOPRSTuv](?=[xz!\[^_=\s"])
 
 SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~&]
@@ -211,8 +211,8 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~&]
 <string>\\\"						return 'STR_CONTENT'
 <string>[^"]+						return 'STR_CONTENT'
 
-^[T][:][\s]*						{ this.pushState('title_string'); return 'T:'; }
-^[C][:][\s]*						{ this.pushState('title_string'); return 'C:'; }
+^[T][:][\s]*						{ var pre = this.matched.slice(0, this.matched.length - yytext.length); if (pre === '' || pre.slice(-1) === '\n') { this.pushState('title_string'); return 'T:'; } this.unput(yytext.slice(1)); yytext = 'T'; return 'T'; }
+^[C][:][\s]*						{ var pre = this.matched.slice(0, this.matched.length - yytext.length); if (pre === '' || pre.slice(-1) === '\n') { this.pushState('title_string'); return 'C:'; } this.unput(yytext.slice(1)); yytext = 'C'; return 'A'; }
 <title_string>\n					{ this.popState(); }
 <title_string>[^\n]+				return 'STR_CONTENT'
 
@@ -226,10 +226,10 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~&]
 <voice_header>[ \t]+				{}
 <voice_header>\n					{ this.popState(); }
 <voice_header>\]					{ this.popState(); return ']'; }
-<key_signature>"treble"				return 'TREBLE';
-<key_signature>"bass"				return 'BASS';
-<key_signature>"tenor"				return 'TENOR';
-<key_signature>"alto"				return 'ALTO';
+<key_signature>"treble"[0-9]*		return 'TREBLE';
+<key_signature>"bass"[0-9]*			return 'BASS';
+<key_signature>"tenor"[0-9]*		return 'TENOR';
+<key_signature>"alto"[0-9]*			return 'ALTO';
 <key_signature>"none"				return 'NAME';
 <key_signature>"Dor"				return 'NAME';
 <key_signature>"Phr"				return 'NAME';
@@ -262,9 +262,10 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~&]
 <spec_comment_name>[\w]+			{ this.popState(); this.pushState('spec_comment_skip'); }
 <spec_comment_name>\n				{ this.popState(); this.popState(); }
 <spec_comment>[ \t]+				{}
-<spec_comment>[([{]				{ this._scoreDepth = (this._scoreDepth || 0) + 1; return yytext; }
+<spec_comment>[([{]					{ this._scoreDepth = (this._scoreDepth || 0) + 1; return yytext; }
 <spec_comment>[)\]}]				{ this._scoreDepth = (this._scoreDepth || 0) - 1; return yytext; }
 <spec_comment>[|]					return yytext
+<spec_comment>[A-Z][:]				{ this.popState(); this.popState(); this.unput(yytext); return 'LAYOUT_END'; }
 <spec_comment>[\w]+					return 'NN'
 <spec_comment>\n					{ if (this._scoreDepth > 0) { /* layout continues on next line */ } else { this.popState(); this.popState(); return 'LAYOUT_END'; } }
 <spec_comment_skip>[^\n]+			{}
@@ -360,7 +361,7 @@ staff_layout
 staff_layout_items
 	: staff_layout_item						-> [$1]
 	| staff_layout_items staff_layout_item	-> [...$1, $2]
-	| staff_layout_items '|'				-> $1
+	| staff_layout_items '|'				{ if ($1.length) $1[$1.length - 1].barThruAfter = true; $$ = $1; }
 	;
 
 staff_layout_item
@@ -467,6 +468,7 @@ numeric_tempo
 
 voice_exp
 	: number							-> voice($1)
+	| number assigns					-> voice($1, null, $2)
 	| number NAME						-> voice($1, $2)
 	| number NAME assigns				-> voice($1, $2, $3)
 	| number NAME plus_minus_number		-> voice($1, $2 + ($3 < 0 ? '-' : '+') + Math.abs($3))
@@ -539,10 +541,18 @@ bar
 	| '|' ']' ':'						-> '|]'
 	| ':' '|' ']'						-> ':|]'
 	| '|' N								-> '|' + $2
+	| '|' N volta_rest					-> '|' + $2 + $3
 	| ':' '|' N							-> ':|' + $2
+	| ':' '|' N volta_rest				-> ':|' + $2 + $3
 	| '&'								-> '&'
 	;
 
+// Additional volta endings after the first number, comma-separated: "1,2", "1,2,3".
+volta_rest
+	: ',' N								-> ',' + $2
+	| volta_rest ',' N					-> $1 + ',' + $3
+	;
+
 music
 	: %empty							-> []
 	| music expressive_mark				-> $1 ? [...$1, $2] : [$2]
@@ -555,9 +565,17 @@ music
 	| music N							-> $1
 	| music NAME						-> $1
 	| music '^' NAME					-> $1
+	| music '^' articulation_letter		-> $1
 	| music '[' N						-> $1
 	;
 
+// Articulation-class letters (P macro: HJLMOPRSTuv). After a stray '^' inside a
+// text annotation, a word like "Menuetto"/"Largo" starts with one of these and the
+// lexer emits it as the articulation token, not NAME — swallow it like '^' NAME.
+articulation_letter
+	: 'P' | 'T' | 'H' | 'J' | 'L' | 'M' | 'R' | 'O' | 'S' | 'u' | 'v'
+	;
+
 control
 	: '[' H ':' header_value ']'		-> ({control: header($2, $4)})
 	| '[' 'K:' header_value ']'			-> ({control: header("K", $3)})
@@ -756,7 +774,14 @@ duration
 	: number '/' number					-> frac(Number($1), Number($3))
 	| '/' number						-> frac(1, Number($2))
 	| number							-> frac(Number($1))
-	| '/'								-> frac(1, 2)
+	| slashes							-> frac(1, Math.pow(2, $1))
+	| number slashes					-> frac(Number($1), Math.pow(2, $2))
+	;
+
+// One or more '/' halve the unit length each: '/'=1/2, '//'=1/4, '///'=1/8.
+slashes
+	: '/'								-> 1
+	| slashes '/'						-> $1 + 1
 	;
 
 broken_rhythm

package/source/abc/abc.ts

@@ -130,6 +130,7 @@ namespace ABC {
 	export interface StaffGroup {
 		items: (StaffGroup | string)[];
 		bound?: 'arc' | 'square' | 'curly';
+		barThruAfter?: boolean;   // a '|' followed this sibling in %%score (barlines run through)
 	};