@goplayerjuggler/abc-tools 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplayerjuggler/abc-tools",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "sorting algorithm and implementation for ABC tunes; plus other tools for parsing and manipulating ABC tunes",
   "main": "src/index.js",
   "scripts": {

package/src/incipit.js

@@ -54,8 +54,8 @@ function cleanIncipitLine(theTextIncipit) {
 	//   theTextIncipit = theTextIncipit.replaceAll("]", "");
 	//console.log(theTextIncipit);
 
-	// Strip out continuations
-	theTextIncipit = theTextIncipit.replaceAll("\\", "");
+	// keep continuations!
+	// theTextIncipit = theTextIncipit.replaceAll("\\", "");
 
 	// Segno
 	theTextIncipit = theTextIncipit.replaceAll("S", "");
@@ -219,9 +219,8 @@ function StripChordsOne(theNotes) {
 }
 
 function sanitise(theTune) {
-	let j,
-		k,
-		theTextIncipits = [];
+	let j, k;
+	const theTextIncipits = [];
 	// Strip out annotations
 	theTune = StripAnnotationsOneForIncipits(theTune);
 
@@ -247,38 +246,26 @@ function sanitise(theTune) {
 			break;
 		}
 	}
-	// Find the L: parameter
-	let theL = "";
 
-	for (j = 0; j < nLines; ++j) {
-		theL = theLines[j];
-
-		if (theL.indexOf("L:") !== -1) {
-			break;
-		}
-	}
-	// Find the M: parameter
-	let theM = "";
-
-	for (j = 0; j < nLines; ++j) {
-		theM = theLines[j];
+	const unitLength = getUnitLength(theTune);
+	const meter = getMeter(theTune),
+		theM = meter ? `${meter[0]}/${meter[1]}` : "none";
 
-		if (theM.indexOf("M:") !== -1) {
-			break;
-		}
-	}
 	// Use at most the first three lines following the header K:
 	let added = 0;
 	for (k = indexOfTheKey + 1; k < nLines; ++k) {
 		const theTextIncipit = theLines[k];
-
+		if (theTextIncipit.match(/^\s*%%/)) continue; // skip lines starting with %%
 		// Clean out the incipit line of any annotations besides notes and bar lines
 		theTextIncipits.push(cleanIncipitLine(theTextIncipit));
 		added++;
+
 		if (added === 3) break;
 	}
 
-	return `X:1\n${theM}\n${theL}\n${theKey}\n${theTextIncipits.join("\n")}`;
+	return `X:1\nM:${theM}\nL:1/${
+		unitLength.den
+	}\n${theKey}\n${theTextIncipits.join("\n")}`;
 }
 
 /**
@@ -333,7 +320,7 @@ function getContourFromFullAbc(abc) {
 		if (abc.length === 0) return null;
 		abc = abc[0];
 	}
-	return getContour(getIncipitForContourGeneration(abc));
+	return getContour(getIncipitForContourGeneration(abc), { withSvg: true });
 }
 
 module.exports = {

package/src/manipulator.js

@@ -1,6 +1,6 @@
 const { Fraction } = require("./math.js");
 const {
-	parseABCWithBars,
+	parseAbc,
 	getMeter,
 	calculateBarDurations,
 } = require("./parse/parser.js");
@@ -43,6 +43,7 @@ function normaliseKey(keyHeader) {
 		major: "major",
 		ion: "major",
 		ionian: "major",
+		m: "minor",
 		min: "minor",
 		minor: "minor",
 		aeo: "minor",
@@ -91,7 +92,7 @@ function filterHeaders(headerLines, headersToStrip) {
 
 /**
  * Detect if ABC notation has an anacrusis (pickup bar)
- * @param {object} parsed - Parsed ABC data from parseABCWithBars
+ * @param {object} parsed - Parsed ABC data from parseAbc
  * @returns {boolean} - True if anacrusis is present
  */
 function hasAnacrucisFromParsed(parsed) {
@@ -112,7 +113,7 @@ function hasAnacrucisFromParsed(parsed) {
  * @returns {boolean} - True if anacrusis is present
  */
 function hasAnacrucis(abc) {
-	const parsed = parseABCWithBars(abc, { maxBars: 2 });
+	const parsed = parseAbc(abc, { maxBars: 2 });
 	return hasAnacrucisFromParsed(parsed);
 }
 /**
@@ -188,7 +189,7 @@ function toggleMeterDoubling(abc, smallMeter, largeMeter) {
 		abc = abc.replaceAll(/([^\s])([[:]?\|)/g, "$1 $2");
 	}
 
-	const parsed = parseABCWithBars(abc);
+	const parsed = parseAbc(abc);
 	const { headerLines, barLines, musicText } = parsed;
 
 	// Change meter in headers
@@ -326,7 +327,7 @@ function getFirstBars(
 		Math.ceil(numBarsFraction.num / numBarsFraction.den) + 2;
 
 	// Parse with estimated maxBars
-	const parsed = parseABCWithBars(abc, { maxBars: estimatedMaxBars });
+	const parsed = parseAbc(abc, { maxBars: estimatedMaxBars });
 	const { bars, headerLines, barLines, musicText, meter } = parsed;
 
 	const barDurations = calculateBarDurations(parsed);

package/src/parse/barline-parser.js

@@ -17,99 +17,48 @@
  * Classify bar line type
  *
  * @param {string} barLineStr - Bar line string from ABC notation
- * @returns {object} - Classification with type, text, and properties
+ * @returns {object} - parsed barline with text, and properties
  *
  * Return object structure:
  * {
- *   type: string,           // 'regular', 'double', 'final', 'repeat-start', 'repeat-end', 'repeat-both', 'repeat-ending', 'other'
  *   text: string,           // Original bar line string
- *   isRepeat: boolean,      // Whether this bar line involves repeats
- *   ending?: number         // For repeat-ending type, which ending (1-6)
+ *   trimmed: string,            // trimmed bar line string
+ *   isSectionBreak,              // double bars and ends of repeats are section breaks
+ *   isRepeatL: boolean,
+ * // true iff there’s a repeat to the left of the bar line; if not the property is omitted
+ * // indicates the end of a repeated section
+ *
+ *   isRepeatR: boolean,
+ * // true iff there’s a repeat to the rightt of the bar line; if not the property is omitted
+ * // indicates the start of a repeated section
+ *
  * }
+ *
+ *
  */
-function classifyBarLine(barLineStr) {
+function parseBarLine(barLineStr) {
 	const trimmed = barLineStr.trim();
-
-	// Repeat endings
-	if (trimmed.match(/^\|[1-6]$/)) {
-		return {
-			type: "repeat-ending",
-			ending: parseInt(trimmed[1]),
-			text: barLineStr,
-			isRepeat: true,
-		};
-	}
-
+	const result = {
+		text: barLineStr,
+		trimmed,
+	};
 	// Start repeat
-	if (trimmed.match(/^\|:/) || trimmed.match(/^\[\|/)) {
-		return {
-			type: "repeat-start",
-			text: barLineStr,
-			isRepeat: true,
-		};
+	if (trimmed.match(/:$/)) {
+		result.isRepeatR = true;
 	}
-
 	// End repeat
-	if (
-		trimmed.match(/^:\|/) ||
-		(trimmed.match(/^\|\]/) && !trimmed.match(/^\|\]$/))
-	) {
-		return {
-			type: "repeat-end",
-			text: barLineStr,
-			isRepeat: true,
-		};
-	}
-
-	// Double repeat
-	if (
-		trimmed.match(/^::/) ||
-		trimmed.match(/^:\|:/) ||
-		trimmed.match(/^::\|:?/) ||
-		trimmed.match(/^::\|\|:?/)
-	) {
-		return {
-			type: "repeat-both",
-			text: barLineStr,
-			isRepeat: true,
-		};
-	}
-
-	// Final bar
-	if (trimmed === "|]") {
-		return {
-			type: "final",
-			text: barLineStr,
-			isRepeat: false,
-		};
+	if (trimmed.match(/^:/)) {
+		result.isRepeatL = true;
+		result.isSectionBreak = true
 	}
 
 	// Double bar
-	if (trimmed === "||") {
-		return {
-			type: "double",
-			text: barLineStr,
-			isRepeat: false,
-		};
+	if (trimmed.match(/\|\|/)){
+		result.isSectionBreak = true;
 	}
-
-	// Regular bar
-	if (trimmed === "|") {
-		return {
-			type: "regular",
-			text: barLineStr,
-			isRepeat: false,
-		};
-	}
-
-	// Unknown/complex bar line
-	return {
-		type: "other",
-		text: barLineStr,
-		isRepeat: trimmed.includes(":"),
-	};
+	return result;
 }
 
 module.exports = {
-	classifyBarLine,
+	parseBarLine,
 };

package/src/parse/header-parser.js

@@ -38,7 +38,9 @@ function getMeter(abc) {
 	if (meterMatch) {
 		return [parseInt(meterMatch[1]), parseInt(meterMatch[2])];
 	}
-	return [4, 4]; // Default to 4/4
+	if (abc.match(/^M:\s*C\|/m)) return [2, 2];
+	if (abc.match(/^M:\s*C/m)) return [4, 4];
+	return null;
 }
 
 /**
@@ -54,6 +56,15 @@ function getUnitLength(abc) {
 	}
 	return new Fraction(1, 8); // Default to 1/8
 }
+/**
+ * Extract titles - there may be 0..N titles
+ *
+ * @param {string} abc - ABC notation string
+ * @returns {[string]} - array of titles
+ */
+function getTitles(abc) {
+	return [...abc.matchAll(/^(?:T:\s*.(.+)\n)/gm)];
+}
 
 /**
  * Process ABC lines: extract music lines with metadata
@@ -100,9 +111,11 @@ function getMusicLines(abc) {
 		// Check for line continuation
 		const hasContinuation = trimmed.match(/\\\s*(%|$)/) !== null;
 
-		// Remove inline comments and line continuation marker
+		// Remove inline comments
 		trimmed = trimmed.replace(/\s*%.*$/, "").trim();
-		trimmed = trimmed.replace(/\\\s*$/, "").trim();
+
+		// Do *not* remove continuations: `\` at the end of a line
+		// trimmed = trimmed.replace(/\\\s*$/, "").trim();
 
 		if (trimmed) {
 			musicLines.push(trimmed);
@@ -137,4 +150,5 @@ module.exports = {
 	getMeter,
 	getUnitLength,
 	getMusicLines,
+	getTitles,
 };

package/src/parse/note-parser.js

@@ -12,6 +12,7 @@ const { Fraction } = require("../math.js");
 // - Chord symbols and annotations
 // - Tuplets/triplets
 // - Broken rhythms
+// - Grace notes
 //
 // ============================================================================
 
@@ -193,6 +194,87 @@ function parseChord(chordStr, unitLength) {
 	};
 }
 
+/**
+ * Parse grace notes from a token
+ * Grace notes are enclosed in curly braces and have zero duration
+ *
+ * @param {string} graceStr - Grace note string (e.g., '{ABC}', '{^AB_c}', '{[CEG]A}')
+ * @returns {Array<object>|null} - Array of grace note objects, or null if not valid grace notes
+ *
+ * Each grace note has:
+ * - isGraceNote: true
+ * - duration: Fraction(0, 1)
+ * - pitch, octave: as normal
+ * - isChord: true (if chord in brackets)
+ * - chordNotes: Array (if chord)
+ */
+function parseGraceNotes(graceStr) {
+	if (!graceStr.startsWith("{") || !graceStr.endsWith("}")) {
+		return null;
+	}
+
+	const content = graceStr.slice(1, -1);
+	if (!content) {
+		return null;
+	}
+
+	const graceNotes = [];
+
+	// Match individual notes or chords: accidental + pitch + octave (+ duration to ignore)
+	// Supports: A, ^A, _B', [CEG], [^C_E'G], A2, B/2, etc.
+	const noteRegex = /(?:\[[^\]]+\]|[=^_]?[A-Ga-g][',]*)[0-9]*\/?[0-9]*/g;
+
+	let match;
+	while ((match = noteRegex.exec(content)) !== null) {
+		const noteToken = match[0];
+
+		// Check if it's a chord
+		if (noteToken.startsWith("[")) {
+			const chord = parseChord(noteToken, new Fraction(1, 8)); // unitLength irrelevant
+			if (chord && chord.notes) {
+				// Find topmost note for the grace chord
+				let topNote = chord.notes[0];
+				for (const note of chord.notes) {
+					const topPos =
+						(topNote.octave || 0) * 7 +
+						(NOTE_TO_DEGREE[topNote.pitch?.toUpperCase()] || 0);
+					const notePos =
+						(note.octave || 0) * 7 +
+						(NOTE_TO_DEGREE[note.pitch?.toUpperCase()] || 0);
+					if (notePos > topPos) {
+						topNote = note;
+					}
+				}
+
+				// Set zero duration for all notes in grace chord
+				chord.notes.forEach((note) => {
+					note.duration = new Fraction(0, 1);
+				});
+
+				graceNotes.push({
+					...topNote,
+					isGraceNote: true,
+					duration: new Fraction(0, 1),
+					isChord: true,
+					chordNotes: chord.notes,
+				});
+			}
+		} else {
+			// Single grace note
+			const pitchData = getPitch(noteToken);
+			if (pitchData) {
+				graceNotes.push({
+					...pitchData,
+					isGraceNote: true,
+					duration: new Fraction(0, 1),
+				});
+			}
+		}
+	}
+
+	return graceNotes.length > 0 ? graceNotes : null;
+}
+
 /**
  * Parse broken rhythm from a token
  * Broken rhythms modify the duration of two adjacent notes (e.g., A>B, C<<D)
@@ -210,12 +292,10 @@ function parseChord(chordStr, unitLength) {
  * - 3: triple-dotted rhythm (15:1 multiplier)
  */
 function parseBrokenRhythm(token) {
-	const brokenMatch = token.match(/^(.+?)\s*(<{1,3}|>{1,3})$/);
+	const brokenMatch = token.match(/^(<{1,3}|>{1,3})$/);
 	if (brokenMatch) {
-		const firstNoteToken = brokenMatch[1],
-			symbol = brokenMatch[2];
+		const symbol = brokenMatch[1];
 		return {
-			firstNoteToken,
 			isBrokenRhythm: true,
 			direction: symbol[0],
 			dots: symbol.length,
@@ -389,64 +469,6 @@ function parseNote(noteStr, unitLength, currentTuple) {
 	return result;
 }
 
-/**
- * Parse tuplet notation from a token
- *
- * @param {string} token - Tuplet token (e.g., '(3', '(3:2', '(3:2:4')
- * @param {boolean} isCompoundTimeSignature - Whether current time signature is compound (affects default q value)
- * @returns {object|null} - { isTuple: true, p, q, r } or null if not a valid tuplet
- */
-function parseTuplet(token, isCompoundTimeSignature) {
-	const tupleMatch = token.match(/^\(([2-9])(?::(\d)?)?(?::(\d)?)?$/);
-	if (tupleMatch) {
-		const pqr = {
-			p: parseInt(tupleMatch[1]),
-			q: tupleMatch[2],
-			r: tupleMatch[3],
-		};
-		const { p } = pqr;
-		let { q, r } = pqr;
-		if (q) {
-			q = parseInt(q);
-		} else {
-			switch (p) {
-				case 2:
-					q = 3;
-					break;
-				case 3:
-					q = 2;
-					break;
-				case 4:
-					q = 3;
-					break;
-				case 5:
-				case 7:
-				case 9:
-					q = isCompoundTimeSignature ? 3 : 2;
-					break;
-				case 6:
-					q = 2;
-					break;
-				case 8:
-					q = 3;
-					break;
-			}
-		}
-		if (r) {
-			r = parseInt(r);
-		} else {
-			r = p;
-		}
-		return {
-			isTuple: true,
-			p,
-			q,
-			r,
-		};
-	}
-	return null;
-}
-
 module.exports = {
 	parseDecorations,
 	parseChordSymbol,
@@ -456,7 +478,7 @@ module.exports = {
 	getDuration,
 	parseChord,
 	parseNote,
-	parseTuplet,
 	parseBrokenRhythm,
 	applyBrokenRhythm,
+	parseGraceNotes,
 };

package/src/parse/parser.js

@@ -7,15 +7,16 @@ const {
 } = require("./header-parser.js");
 const {
 	parseNote,
-	parseTuplet,
 	parseBrokenRhythm,
 	applyBrokenRhythm,
+	parseGraceNotes,
 } = require("./note-parser.js");
-const { classifyBarLine } = require("./barline-parser.js");
+const { parseBarLine } = require("./barline-parser.js");
 const {
+	analyzeSpacing,
 	getTokenRegex,
 	parseInlineField,
-	analyzeSpacing,
+	parseTuplet,
 } = require("./token-utils.js");
 
 // ============================================================================
@@ -34,6 +35,7 @@ const {
 // - Back quotes: ` (ignored spacing for legibility, preserved in metadata)
 // - Triplets: (3ABC, (3A/B/C/, (3A2B2C2
 // - Broken rhythms: A>B, C<<D, etc. (>, >>, >>>, <, <<, <<<)
+// - Grace notes: {ABC}, {^AB_c}, etc. (zero duration, transparent to broken rhythms)
 // - Repeat notation: |:, :|, |1, |2, etc.
 // - Bar lines: |, ||, |], [|, etc.
 // - Decorations: symbol decorations (~.MPSTHUV) and !name! decorations
@@ -47,7 +49,6 @@ const {
 // - Line breaks: preserves information about newlines in music
 //
 // NOT YET SUPPORTED:
-// - Grace notes: {ABC}
 // - Slurs: ()
 // - Lyrics: w: lines
 // - Multiple voices: V: fields
@@ -59,7 +60,7 @@ const {
 // ============================================================================
 
 /**
- * Parse ABC into structured data with bars
+ * Parse ABC into structured data
  *
  * @param {string} abc - ABC notation string
  * @param {object} options - Parsing options
@@ -68,18 +69,18 @@ const {
  *
  * Returns object with:
  * {
- *   bars: Array<Array<NoteObject>>,  // Array of bars, each bar is array of notes/chords/fields
+ *   bars: Array<Array<ScoreObject>>,  // Array of bars, each bar is array of ScoreObjects
+ * 		// A Score object is almost anything that isn’t a bar line: note/chord/field/broken rhythm/tuplet/1st or 2nd repeat or variant ending
  *   barLines: Array<BarLineObject>,  // Array of bar line information
  *   unitLength: Fraction,             // The L: field value (default 1/8)
  *   meter: [number, number],          // The M: field value (default [4,4])
- *   tonalBase: string,                // The tonic from K: field (e.g., 'D', 'G')
  *   lineMetadata: Array<LineMetadata>,// Info about original lines (comments, continuations)
  *   headerLines: Array<string>,       // Original header lines
  *   headerEndIndex: number,           // Index where headers end
  *   musicText: string                 // Processed music text (headers removed)
  * }
  *
- * NoteObject structure (regular note):
+ * ScoreObject structure (normal note):
  * {
  *   pitch: string,              // 'A'-'G' (uppercase for low octave, lowercase for middle)
  *   octave: number,             // Relative octave offset (0 = middle, +1 = high, -1 = low)
@@ -104,10 +105,11 @@ const {
  *     text: string
  *   },
  *   isChord: true,              // Present if this is a chord [CEG]
- *   chordNotes: Array<NoteObject> // All notes in the chord (when isChord=true)
+ *   chordNotes: Array<ScoreObject>, // All notes in the chord (when isChord=true)
+ *   isGraceNote: true           // Present if this is a grace note (has zero duration)
  * }
  *
- * NoteObject structure (silence/rest):
+ * ScoreObject structure (silence/rest):
  * {
  *   isSilence: true,
  *   duration: Fraction,
@@ -118,7 +120,7 @@ const {
  *   // Optional: decorations, chordSymbol, annotation (same as above)
  * }
  *
- * NoteObject structure (dummy note):
+ * ScoreObject structure (dummy note):
  * {
  *   isDummy: true,
  *   duration: Fraction,
@@ -128,7 +130,7 @@ const {
  *   spacing: { ... }
  * }
  *
- * NoteObject structure (inline field change):
+ * ScoreObject structure (inline field change):
  * {
  *   isInlineField: true,
  *   field: string,              // 'K', 'L', 'M', or 'P'
@@ -139,7 +141,7 @@ const {
  *   spacing: { ... }
  * }
  *
- * NoteObject structure (standalone chord symbol):
+ * ScoreObject structure (standalone chord symbol):
  * {
  *   isChordSymbol: true,
  *   chordSymbol: string,        // The chord name
@@ -149,7 +151,7 @@ const {
  *   spacing: { ... }
  * }
  *
- * Tuplet structure:
+ * ScoreObject structure (Tuplet):
  * {
  *   isTuple: true,
  *   p: number,                  // Tuplet ratio numerator
@@ -157,29 +159,35 @@ const {
  *   r: number,                  // Number of notes in tuplet
  *   token: string,
  *   sourceIndex: number,
- *   sourceLength: number
+ *   sourceLength: number,
+ *   spacing: { ... }
  * }
  *
- * BrokenRhythm structure:
+ * ScoreObject structure ((BrokenRhythm):
  * {
  *   isBrokenRhythm: true,
  *   direction: string,          // '>' or '<'
  *   dots: number,               // 1, 2, or 3
  *   token: string,
  *   sourceIndex: number,
- *   sourceLength: number
+ *   sourceLength: number,
+ *   spacing: { ... }
  * }
  *
  * BarLineObject structure:
  * {
- *   type: string,               // 'regular', 'double', 'final', 'repeat-start', etc.
  *   text: string,               // Original bar line string
- *   isRepeat: boolean,          // Whether this involves repeats
+ *   trimmed: string,            // trimmed bar line string
+ *   isSectionBreak,              // double bars and repeats are section breaks
+ *   isRepeatL: boolean,
+ * // true iff there’s a repeat to the left of the bar line; if not the property is omitted
+ * // indicates the end of a repeated section
+ *   isRepeatR: boolean,
+ * // true iff there’s a repeat to the right of the bar line; if not the property is omitted
+ * // indicates the start of a repeated section
  *   sourceIndex: number,        // Position in musicText
  *   sourceLength: number,       // Length of bar line
- *   barNumber: number,          // Which bar this terminates (0-indexed)
  *   hasLineBreak: boolean,      // Whether there's a newline after this bar line
- *   ending?: number             // For repeat-ending type, which ending (1-6)
  * }
  *
  * LineMetadata structure:
@@ -192,7 +200,7 @@ const {
  * }
  *
  * Example:
- *   parseABCWithBars('X:1\nL:1/4\nK:D\n"Dm"D2 [DF]A | ~B4 |]')
+ *   parseAbc('X:1\nL:1/4\nK:D\n"Dm"D2 [DF]A | ~B4 |]')
  *   // Returns:
  *   {
  *     bars: [
@@ -209,16 +217,14 @@ const {
  *     barLines: [...],
  *     unitLength: Fraction(1,4),
  *     meter: [4,4],
- *     tonalBase: 'D',
  *     lineMetadata: [...]
  *   }
  */
-function parseABCWithBars(abc, options = {}) {
+function parseAbc(abc, options = {}) {
 	const { maxBars = Infinity } = options;
 
 	let unitLength = getUnitLength(abc);
 	let meter = getMeter(abc);
-	let tonalBase = getTonalBase(abc);
 
 	const {
 		musicText,
@@ -231,13 +237,19 @@ function parseABCWithBars(abc, options = {}) {
 	// Create a Set of newline positions for O(1) lookup
 	const newlineSet = new Set(newlinePositions);
 
-	// Comprehensive bar line regex - includes trailing spaces
-	const barLineRegex = /(\|\||\|\]|\[\|\]|(\|:?)|(:?\|)|:\|\|:) */g;
+	/*
+	Bar line regex - includes trailing spaces; does not include: 1st & 2nd repeats and variant endings - tokenised by tokenRegex below
+	From the spec: "Abc parsers should be quite liberal in recognizing bar lines. In the wild, bar lines may have any shape, using a sequence of | (thin bar line), [ or ] (thick bar line), and : (dots), e.g. |[| or [|:::"
+	All the following bar lines are legal, given with most frequently seen first - according to my limited knowledge of what’s out there. AFAIK all but the last 4 are quite commonly seen.
+	`|`, `:|`, `|:`, `|]`, `||`, `:||:`, `:|:`, `::`, `[|`, `[|]`, `.|`
+	*/
+	const barLineRegex = /:*\.*[|[\]]*(?:\||::+)[|[\]]*:* */g; //captures expressions with at least one `|`, or at least two `:`.
 
 	const bars = [];
 	const barLines = [];
 	let currentBar = [];
 	let barCount = 0;
+	let previousRealNote = null; // Track last non-grace note for broken rhythms
 
 	// Split music text by bar lines while preserving positions
 	let lastBarPos = 0;
@@ -254,6 +266,7 @@ function parseABCWithBars(abc, options = {}) {
 						barLinePos: match.index,
 				  };
 
+		if (lastBarPos > 0) lastBarPos--; //the last character in a barline expression may be needed to match variant endings - eg `|1`
 		// Process segment before this bar line
 		const segment = musicText.substring(lastBarPos, barLinePos);
 
@@ -277,6 +290,47 @@ function parseABCWithBars(abc, options = {}) {
 					tokenMatch.index + fullToken.length
 				);
 
+				if (fullToken.match(getTokenRegex({ variantEndings: true }))) {
+					const variantEnding = {
+						isVariantEnding: true,
+						token: fullToken,
+						sourceIndex: tokenStartPos,
+						sourceLength: fullToken.length,
+						spacing,
+					};
+					currentBar.push(variantEnding);
+
+					continue;
+				}
+
+				// Check for grace notes
+				if (fullToken.startsWith("{")) {
+					const graceNotes = parseGraceNotes(fullToken);
+					if (graceNotes) {
+						// Add each grace note to the bar
+						graceNotes.forEach((graceNote, idx) => {
+							currentBar.push({
+								...graceNote,
+								token: fullToken,
+								sourceIndex: tokenStartPos,
+								sourceLength: fullToken.length,
+								// Only the last grace note gets the spacing
+								spacing:
+									idx === graceNotes.length - 1
+										? spacing
+										: {
+												whitespace: "",
+												backquotes: 0,
+												beamBreak: false,
+												lineBreak: false,
+										  },
+							});
+						});
+						// Grace notes don't update previousRealNote
+						continue;
+					}
+				}
+
 				// Check for inline field
 				const inlineField = parseInlineField(fullToken);
 				if (inlineField) {
@@ -291,11 +345,6 @@ function parseABCWithBars(abc, options = {}) {
 						if (meterMatch) {
 							meter = [parseInt(meterMatch[1]), parseInt(meterMatch[2])];
 						}
-					} else if (inlineField.field === "K") {
-						const keyMatch = inlineField.value.match(/^([A-G])/);
-						if (keyMatch) {
-							tonalBase = keyMatch[1].toUpperCase();
-						}
 					}
 
 					const inlineFieldObj = {
@@ -308,65 +357,71 @@ function parseABCWithBars(abc, options = {}) {
 						spacing,
 					};
 					currentBar.push(inlineFieldObj);
-					// previousNote = null; // Inline fields break note sequences
+					previousRealNote = null; // Inline fields break note sequences
 					continue;
 				}
 
 				// Check for broken rhythm
 				const brokenRhythm = parseBrokenRhythm(fullToken);
 				if (brokenRhythm) {
-					const { firstNoteToken } = brokenRhythm;
-					const firstNote = parseNote(firstNoteToken, unitLength, currentTuple);
-					// Find the next note token
-					const nextTokenMatch = tokenRegex.exec(segment);
-					if (nextTokenMatch) {
-						const nextToken = nextTokenMatch[0];
-						const nextTokenStartPos = lastBarPos + nextTokenMatch.index;
-						const nextSpacing = analyzeSpacing(
-							segment,
-							nextTokenMatch.index + nextToken.length
-						);
-
-						// Parse the next note
-						const nextNote = parseNote(nextToken, unitLength, currentTuple);
-						if (nextNote && nextNote.duration && firstNote.duration) {
-							// Apply broken rhythm to both notes
-							applyBrokenRhythm(firstNote, nextNote, brokenRhythm);
-
-							//add the firstNote
-							currentBar.push({
-								...firstNote,
-								token: fullToken,
-								sourceIndex: tokenStartPos,
-								sourceLength: fullToken.length,
-							});
-
-							// Add the broken rhythm marker to the bar
-							currentBar.push({
-								...brokenRhythm,
-							});
+					if (previousRealNote) {
+						// Find the next REAL note token (skip grace notes)
+						let nextTokenMatch = tokenRegex.exec(segment);
+						while (nextTokenMatch) {
+							const nextToken = nextTokenMatch[0];
+							// Skip grace notes
+							if (nextToken.startsWith("{")) {
+								nextTokenMatch = tokenRegex.exec(segment);
+								continue;
+							}
+							break;
+						}
 
-							// Add the next note to the bar
-							const nextNoteObj = {
-								...nextNote,
-								token: nextToken,
-								sourceIndex: nextTokenStartPos,
-								sourceLength: nextToken.length,
-								spacing: nextSpacing,
-							};
-							currentBar.push(nextNoteObj);
-							// previousNote = nextNoteObj;
-							continue;
+						if (nextTokenMatch) {
+							const nextToken = nextTokenMatch[0];
+							const nextTokenStartPos = lastBarPos + nextTokenMatch.index;
+							const nextSpacing = analyzeSpacing(
+								segment,
+								nextTokenMatch.index + nextToken.length
+							);
+
+							// Parse the next note
+							const nextNote = parseNote(nextToken, unitLength, currentTuple);
+							if (nextNote && nextNote.duration && previousRealNote.duration) {
+								// Apply broken rhythm to both notes
+								applyBrokenRhythm(previousRealNote, nextNote, brokenRhythm);
+
+								// Add the broken rhythm marker to the bar
+								currentBar.push({
+									...brokenRhythm,
+								});
+
+								// Add the next note to the bar
+								const nextNoteObj = {
+									...nextNote,
+									token: nextToken,
+									sourceIndex: nextTokenStartPos,
+									sourceLength: nextToken.length,
+									spacing: nextSpacing,
+								};
+								currentBar.push(nextNoteObj);
+								previousRealNote = null; //can't have successive broken rhythms
+								continue;
+							}
 						}
 					}
 					// If we couldn't apply the broken rhythm, just skip it
-					// previousNote = null;
+					previousRealNote = null;
 					continue;
 				}
 
 				// Tuplets
 				if (fullToken.match(/\(\d(?::\d?){0,2}/g)) {
-					const tuple = parseTuplet(fullToken);
+					const isCompound =
+						meter &&
+						meter[1] === 8 &&
+						[6, 9, 12, 15, 18].indexOf(meter[0]) >= 0;
+					const tuple = parseTuplet(fullToken, isCompound);
 					if (tuple) {
 						if (currentTuple) {
 							throw new Error("nested tuples not handled");
@@ -378,7 +433,7 @@ function parseABCWithBars(abc, options = {}) {
 							sourceIndex: tokenStartPos,
 							sourceLength: fullToken.length,
 						});
-						// previousNote = null; // Tuplet markers break note sequences
+						previousRealNote = null; // Tuplet markers break note sequences
 						continue;
 					}
 				}
@@ -393,7 +448,7 @@ function parseABCWithBars(abc, options = {}) {
 						sourceLength: fullToken.length,
 						spacing,
 					});
-					// Chord symbols do note break note sequences - leave previousNote
+					// Chord symbols don't break note sequences
 					continue;
 				}
 
@@ -407,7 +462,7 @@ function parseABCWithBars(abc, options = {}) {
 						sourceLength: fullToken.length,
 						spacing,
 					});
-					// Chord symbols do note break note sequences - leave previousNote
+					// Decorations don't break note sequences
 					continue;
 				}
 
@@ -422,8 +477,10 @@ function parseABCWithBars(abc, options = {}) {
 						spacing,
 					};
 					currentBar.push(noteObj);
-					// Only track as previous note if it has duration (for broken rhythms)
-					// previousNote = note.duration ? noteObj : null;
+					// Only track as previous note if it has non-zero duration (for broken rhythms)
+					if (note.duration && note.duration.n !== 0) {
+						previousRealNote = noteObj;
+					}
 				}
 			}
 		}
@@ -435,7 +492,7 @@ function parseABCWithBars(abc, options = {}) {
 			(barLineEndPos < musicText.length && musicText[barLineEndPos] === "\n");
 
 		// Store bar line information
-		const barLineInfo = classifyBarLine(barLineText);
+		const barLineInfo = parseBarLine(barLineText);
 		barLines.push({
 			...barLineInfo,
 			sourceIndex: barLinePos,
@@ -457,6 +514,7 @@ function parseABCWithBars(abc, options = {}) {
 			bars.push(currentBar);
 			barCount++;
 			currentBar = [];
+			previousRealNote = null; // Bar lines break note sequences
 
 			// Check if we've reached max bars
 			if (barCount >= maxBars) {
@@ -477,7 +535,6 @@ function parseABCWithBars(abc, options = {}) {
 		barLines,
 		unitLength,
 		meter,
-		tonalBase,
 		lineMetadata,
 		headerLines,
 		headerEndIndex,
@@ -489,7 +546,7 @@ function parseABCWithBars(abc, options = {}) {
  * Calculate bar durations from parsed ABC data
  * Returns duration for each bar as a Fraction
  *
- * @param {object} parsedData - Output from parseABCWithBars
+ * @param {object} parsedData - Output from parseAbc
  * @returns {Array<Fraction>} - Array of bar durations
  */
 function calculateBarDurations(parsedData) {
@@ -558,7 +615,7 @@ function getTunes(text) {
 
 module.exports = {
 	getTunes,
-	parseABCWithBars,
+	parseAbc,
 	calculateBarDurations,
 	// Re-export utilities for convenience
 	getTonalBase,
@@ -566,5 +623,5 @@ module.exports = {
 	getUnitLength,
 	getMusicLines,
 	analyzeSpacing,
-	classifyBarLine,
+	parseBarLine,
 };

package/src/parse/token-utils.js

@@ -6,15 +6,18 @@
 // - Token regex generation
 // - Inline field parsing
 // - Whitespace and beaming analysis
-//
+// - Bar lines are not captured, but variant endings and 1st and 2nd repeats are captured
 // ============================================================================
 
 const TokenRegexComponents = {
 	// Tuplet notation: (3, (3:2, (3:2:4
 	tuplet: String.raw`\(\d(?::\d?){0,2}`,
 
+	// Grace notes: {ABC}, {^AB_c}, etc.
+	graceNotes: String.raw`\{[^}]+\}`,
+
 	// Inline field changes: [K:D], [L:1/4], [M:3/4], [P:A]
-	inlineField: String.raw`\[(?:[KLMP]):[^\]]+\]`,
+	inlineField: String.raw`\[([KLMP]):\s*([^\]]+)\]`,
 
 	// Text in quotes: chord symbols "Dm7" or annotations "^text"
 	quotedText: String.raw`"[^"]+"`,
@@ -48,22 +51,41 @@ const TokenRegexComponents = {
 	// but we could have A16, or z10 (full bar rest for M:5/4; L:1/8)
 	duration: String.raw`[0-9]*\/?[0-9]*`,
 
-	// Tie (-) or broken rhythm (>, >>, >>>, <, <<, <<<)
-	// Optional: may have neither, or may have whitespace before broken rhythm
-	tieOrBroken: String.raw`(?:-|\s*(?:<{1,3}|>{1,3}))?`,
+	// Tie (-) - optional
+	tie: String.raw`-?`,
+
+	// Broken rhythm (>, >>, >>>, <, <<, <<<)
+	broken: String.raw`<{1,3}|>{1,3}`,
+
+	// variant ending - including one way of writing 1st and second repeats. Only handle single digits.
+	// examples: [1 [2 [3 [4 [1-3 [1-3,5-7
+	variantEnding: String.raw`\[\d(?:-\d)?(?:,\d(?:-\d)?)*`,
+
+	// 1st & 2nd repeats. Only handle single digits.
+	// examples: `|1`, `|2`
+	// Note that the other syntax, `[1`, `[2`, will be captured by the variantEnding component
+	repeat_1Or2: String.raw`\|[12]`,
 };
 
 /**
+ *
  * Get regex for matching ABC music tokens
- * Built from documented components for maintainability
  *
- * Matches: tuplets, inline fields, chord symbols, notes, rests, chords in brackets,
- * decorations, ties, and broken rhythms
+ * Matches: tuplets, grace notes, inline fields, chord symbols, notes, rests,
+ * chords in brackets, decorations, ties, broken rhythms, and variant endings including 1st and 2nd repeats
  *
+ * @param {object} options -
+ * 	when options.variantEndings is flagged, the returned regex just matches the next variant ending / 1st or 2nd repeat
+ * 	when options.inlineField is flagged, the returned regex just matches the next inline field
  * @returns {RegExp} - Regular expression for tokenising ABC music
  */
-const getTokenRegex = () => {
+const getTokenRegex = (options = {}) => {
 	const s = TokenRegexComponents;
+	if (options) {
+		if (options.variantEndings)
+			return new RegExp(`^${s.variantEnding}|${s.repeat_1Or2}$`);
+		if (options.inlineField) return new RegExp(`^$${s.inlineField}$`);
+	}
 	// Complete note/rest/chord pattern with optional leading decoration
 	const notePattern =
 		s.bangDecorations() +
@@ -72,16 +94,20 @@ const getTokenRegex = () => {
 		s.pitch +
 		s.octave +
 		s.duration +
-		s.tieOrBroken;
+		s.tie;
 
 	// Combine all patterns with alternation
 	const fullPattern = [
 		s.tuplet,
+		s.graceNotes,
 		s.inlineField,
 		s.quotedText,
 		//allow standalone bang and symbol decorations (?)
 		notePattern,
 		s.bangDecoration,
+		s.broken,
+		s.variantEnding,
+		s.repeat_1Or2,
 	].join("|");
 
 	return new RegExp(fullPattern, "g");
@@ -101,7 +127,7 @@ const getTokenRegex = () => {
  * - [P:...] - Part marker
  */
 function parseInlineField(token) {
-	const fieldMatch = token.match(/^\[([KLMP]):\s*([^\]]+)\]$/);
+	const fieldMatch = token.match(getTokenRegex({ inlineField: true }));
 	if (fieldMatch) {
 		return {
 			field: fieldMatch[1],
@@ -168,8 +194,66 @@ function analyzeSpacing(segment, tokenEndPos) {
 	};
 }
 
+/**
+ * Parse tuplet notation from a token
+ *
+ * @param {string} token - Tuplet token (e.g., '(3', '(3:2', '(3:2:4')
+ * @param {boolean} isCompoundTimeSignature - Whether current time signature is compound (affects default q value)
+ * @returns {object|null} - { isTuple: true, p, q, r } or null if not a valid tuplet
+ */
+function parseTuplet(token, isCompoundTimeSignature) {
+	const tupleMatch = token.match(/^\(([2-9])(?::(\d)?)?(?::(\d)?)?$/);
+	if (tupleMatch) {
+		const pqr = {
+			p: parseInt(tupleMatch[1]),
+			q: tupleMatch[2],
+			r: tupleMatch[3],
+		};
+		const { p } = pqr;
+		let { q, r } = pqr;
+		if (q) {
+			q = parseInt(q);
+		} else {
+			switch (p) {
+				case 2:
+					q = 3;
+					break;
+				case 3:
+					q = 2;
+					break;
+				case 4:
+					q = 3;
+					break;
+				case 5:
+				case 7:
+				case 9:
+					q = isCompoundTimeSignature ? 3 : 2;
+					break;
+				case 6:
+					q = 2;
+					break;
+				case 8:
+					q = 3;
+					break;
+			}
+		}
+		if (r) {
+			r = parseInt(r);
+		} else {
+			r = p;
+		}
+		return {
+			isTuple: true,
+			p,
+			q,
+			r,
+		};
+	}
+	return null;
+}
 module.exports = {
+	analyzeSpacing,
 	getTokenRegex,
 	parseInlineField,
-	analyzeSpacing,
+	parseTuplet,
 };

package/src/sort/contour-sort.js

@@ -2,7 +2,7 @@ const { Fraction } = require("../math.js");
 const {
 	getTonalBase,
 	getUnitLength,
-	parseABCWithBars,
+	parseAbc,
 	getMeter,
 } = require("../parse/parser.js");
 
@@ -38,8 +38,10 @@ function getContour(
 	const unitLength = getUnitLength(abc);
 	const maxDuration = unitLength.multiply(maxNbUnitLengths);
 	const meter = getMeter(abc);
-	const maxNbBars = maxDuration.divide(new Fraction(meter[0], meter[1]));
-	const { bars } = parseABCWithBars(abc, {
+	const maxNbBars = meter
+		? maxDuration.divide(new Fraction(meter[0], meter[1]))
+		: new Fraction(2, 1); //default 2 bars when no meter (free meter)
+	const { bars } = parseAbc(abc, {
 		maxBars: Math.ceil(maxNbBars.toNumber()),
 	});
 	let cumulatedDuration = new Fraction(0, 1);

package/src/sort/contour-svg.js

@@ -13,11 +13,19 @@ const { decodeChar } = require("./encode.js");
  * @property {number} paddingBottom - Bottom padding in pixels
  * @property {number} paddingLeft - Left padding in pixels
  * @property {number} paddingRight - Right padding in pixels
- * @property {boolean} forceBaseline - ensures the baseline at zero is displayed
+ * @property {boolean} forceBaseline - Ensures the baseline at zero is displayed
  * @property {number|null} minDegree - Minimum degree for vertical range (null for auto)
  * @property {number|null} maxDegree - Maximum degree for vertical range (null for auto)
  * @property {string} class - CSS class name for the SVG element
  * @property {string} ariaLabel - Accessible label for screen readers
+ * @property {number} noteStartRadius - Radius of the circle marking note starts (played notes only)
+ * @property {boolean} onlyShowMeaningfulStartOfPlayedNotes - If true, only show start markers when previous note is same pitch; if false, show on all played notes
+ * @property {boolean} showYAxis - Whether to display the Y axis
+ * @property {string} yAxisColor - Colour for the Y axis line
+ * @property {number} yAxisWidth - Width of the Y axis line
+ * @property {number} yAxisTickLength - Length of regular ticks (for 5th degree markers)
+ * @property {number} yAxisTonicTickLength - Length of tonic ticks (for tonic degree markers)
+ * @property {number} yAxisTickWidth - Width of tick marks
  */
 
 /**
@@ -25,35 +33,42 @@ const { decodeChar } = require("./encode.js");
  * @type {SvgConfig}
  */
 const contourToSvg_defaultConfig = {
-	degreeHeight: 5, // much smaller (default is 12)
-	paddingTop: 1, // less padding (default is 20)
-	paddingBottom: 1, // less padding (default is 20)
-	strokeWidth: 2, // slightly thinner lines (default is 3)
+	degreeHeight: 5,
+	paddingTop: 3,
+	paddingBottom: 3,
+	strokeWidth: 2,
 	unitWidth: 15,
-	// degreeHeight: 12,
-	// strokeWidth: 3,
 	playedColor: "#2563eb", // blue
-	heldColor: "#93c5fd", // lighter blue (held notes)
+	heldColor: "#2563eb", // same as played (no longer lighter blue)
 	baselineColor: "#555555", // Davy's grey
-	// paddingTop: 20,
-	// paddingBottom: 20,
 	paddingLeft: 10,
 	paddingRight: 10,
-	minDegree: null, // null means auto-calculate from contour
-	maxDegree: null, // null means auto-calculate from contour
+	minDegree: null,
+	maxDegree: null,
 	forceBaseline: true,
 	class: "contour-svg",
 	ariaLabel: "Tune contour",
+	noteStartRadius: 3,
+	onlyShowMeaningfulStartOfPlayedNotes: true,
+	showYAxis: true,
+	yAxisColor: "#888888",
+	yAxisWidth: 1,
+	yAxisTickLength: 4,
+	yAxisTonicTickLength: 6,
+	yAxisTickWidth: 1,
 };
 
 /**
- * Converts a tune contour object into an SVG visualization
+ * Converts a tune contour object into an SVG visualisation
  *
  * The SVG represents the melodic contour as a series of connected horizontal line segments.
  * Each segment's vertical position corresponds to its modal degree (pitch relative to tonic),
  * and its horizontal length represents its duration relative to the common subdivision of the beat.
  * The resulting SVG is landscape-oriented (wider than tall).
  *
+ * Played notes are marked with a small filled circle at their start point.
+ * Held notes (continuations of the same pitch) have no start marker.
+ *
  * Silences are not drawn but occupy space on the x-axis, causing subsequent notes to be
  * positioned after the cumulative duration of preceding silences.
  *
@@ -75,7 +90,7 @@ const contourToSvg_defaultConfig = {
  * // With fixed vertical range for comparing multiple contours
  * const svg = contourToSvg(contour, { minDegree: -15, maxDegree: 15 });
  *
- * // Auto range  - calculates from the contour's actual pitch range
+ * // Auto range - calculates from the contour's actual pitch range
  * const svg2 = contourToSvg(contour, {
  *   minDegree: null,
  *   maxDegree: null
@@ -87,7 +102,7 @@ const contourToSvg_defaultConfig = {
  * // You can also set just one bound
  * const svg3 = contourToSvg(contour, {
  *   minDegree: -15,
- *   maxDegree: null //maxDegree will auto-calculate
+ *   maxDegree: null // maxDegree will auto-calculate
  * });
  */
 function contourToSvg(contour, svgConfig = {}) {
@@ -156,7 +171,11 @@ function contourToSvg(contour, svgConfig = {}) {
 	const svgWidth = totalWidth + config.paddingLeft + config.paddingRight;
 	const svgHeight = chartHeight + config.paddingTop + config.paddingBottom;
 
-	// Helper function to convert position to Y coordinate
+	/**
+	 * Converts a modal degree position to Y coordinate in SVG space
+	 * @param {number} pos - Modal degree position
+	 * @returns {number} Y coordinate
+	 */
 	const positionToY = (pos) => {
 		const relativePos = maxPosition - pos;
 		return config.paddingTop + relativePos * config.degreeHeight;
@@ -165,6 +184,47 @@ function contourToSvg(contour, svgConfig = {}) {
 	// Build SVG path elements
 	const pathElements = [];
 
+	// Add Y axis if configured
+	if (config.showYAxis) {
+		const yAxisX = config.paddingLeft - 5;
+		const yAxisTop = positionToY(maxPosition);
+		const yAxisBottom = positionToY(minPosition);
+
+		pathElements.push(
+			`<line x1="${yAxisX}" y1="${yAxisTop}" ` +
+				`x2="${yAxisX}" y2="${yAxisBottom}" ` +
+				`stroke="${config.yAxisColor}" stroke-width="${config.yAxisWidth}" />`
+		);
+
+		// Add tick marks for positions within range
+		// Regular ticks at positions: ..., -11, -4, 4, 11, 18, ... (5th degree in each octave)
+		// Tonic ticks at positions: ..., -14, -7, 0, 7, 14, ... (tonic in each octave)
+		const minPos = Math.floor(minPosition);
+		const maxPos = Math.ceil(maxPosition);
+
+		for (let pos = minPos; pos <= maxPos; pos++) {
+			let tickLength = 0;
+
+			// Check if this is a tonic position (0, ±7, ±14, ...)
+			if (pos % 7 === 0) {
+				tickLength = config.yAxisTonicTickLength;
+			}
+			// Check if this is a 5th position (±4, ±11, ±18, ...)
+			else if (pos % 7 === 4 || pos % 7 === -3) {
+				tickLength = config.yAxisTickLength;
+			}
+
+			if (tickLength > 0) {
+				const tickY = positionToY(pos);
+				pathElements.push(
+					`<line x1="${yAxisX - tickLength}" y1="${tickY}" ` +
+						`x2="${yAxisX}" y2="${tickY}" ` +
+						`stroke="${config.yAxisColor}" stroke-width="${config.yAxisTickWidth}" />`
+				);
+			}
+		}
+	}
+
 	// Add baseline at position 0 if it's within range
 	if (minPosition <= 0 && maxPosition >= 0) {
 		const baselineY = positionToY(0);
@@ -196,6 +256,39 @@ function contourToSvg(contour, svgConfig = {}) {
 				`stroke-linecap="round" />`
 		);
 
+		// Add note start marker (filled circle) for played notes
+		// If onlyShowMeaningfulStartOfPlayedNotes is true, only show when previous note is same pitch
+		if (!seg.isHeld) {
+			let showStartMarker = true;
+
+			if (config.onlyShowMeaningfulStartOfPlayedNotes) {
+				// Find previous non-silence segment
+				let prevNonSilenceIdx = i - 1;
+				while (
+					prevNonSilenceIdx >= 0 &&
+					segments[prevNonSilenceIdx].isSilence
+				) {
+					prevNonSilenceIdx--;
+				}
+
+				// Only show marker if previous note exists and is at same position
+				if (prevNonSilenceIdx >= 0) {
+					const prevSeg = segments[prevNonSilenceIdx];
+					showStartMarker = prevSeg.position === seg.position;
+				} else {
+					// First note: don't show marker
+					showStartMarker = false;
+				}
+			}
+
+			if (showStartMarker) {
+				pathElements.push(
+					`<circle cx="${x1}" cy="${y}" r="${config.noteStartRadius}" ` +
+						`fill="${color}" />`
+				);
+			}
+		}
+
 		// Add connecting vertical line to next non-silence segment if position changes
 		let nextNonSilenceIdx = i + 1;
 		while (