abcjs 6.5.2 → 6.6.0

package/src/parse/chord-grid.js

@@ -0,0 +1,364 @@
+// This takes a visual object and returns an object that can
+// be rotely turned into a chord grid.
+//
+// 1) It will always be 8 measures on a line, unless it is a 12 bar blues, then it will be 4 measures.
+// 2) If it is not in 4/4 it will return an error
+// 3) If there are no chords it will return an error
+// 4) It will be divided into parts with the part title and an array of measures
+// 5) |: and :| will be included in a measure
+// 6) If there are first and second endings and the chords are the same, then collapse them
+// 7) If there are first and second endings and the chords are different, use a separate line for the second ending and right justify it.
+// 8) If there is one chord per measure and it is repeated in the next measure use a % for the second measure.
+// 9) All lines are the same height, so they are tall enough to fit two lines if there lots of chords
+// 10) Chords will be printed as large as they can without overlapping, so different chords will be smaller if they are long.
+// 11) If there are two chords per measure then there is a slash between them.
+// 12) If there are three or four chords then there is a 2x2 grid with the chords reading right to left. For three chords, leave the repeated cell blank.
+// 13) Breaks are indicated by the word "break" or "N.C.". A break that extends to the next measure is indicated by three dots in the next measure.
+// 14) Ignore pickup notes
+// 15) if a part is not a multiple of 8 bars (and not 12 bars), the last line has
+// 4 squares on left and not any grid on the right.
+// 16) Annotations and some decorations get printed above the cells.
+
+function chordGrid(visualObj) {
+	const meter = visualObj.getMeterFraction()
+	const isCommonTime = meter.num === 4 && meter.den === 4
+	const isCutTime = meter.num === 2 && meter.den === 2
+	if (!isCutTime && !isCommonTime)
+		throw new Error("notCommonTime")
+	const deline = visualObj.deline()
+
+	let chartLines = []
+
+	let nonSubtitle = false
+	deline.forEach(section => {
+		if (section.subtitle) {
+			if (nonSubtitle) {
+				// Don't do the subtitle if the first thing is the subtitle, but that is already printed on the top
+				chartLines.push({
+					type: "subtitle",
+					subtitle: section.subtitle.text
+				});
+			}
+		} else if (section.text) {
+			nonSubtitle = true
+			chartLines.push({
+				type: "text",
+				text: section.text.text
+			})
+		} else if (section.staff) {
+			nonSubtitle = true
+			// The first staff and the first voice in it drive everything.
+			// Only part designations there will count. However, look for
+			// chords in any other part. If there is not a chord defined in
+			// the first part, use a chord defined in another part.
+			const staves = section.staff
+			const parts = flattenVoices(staves)
+
+			chartLines = chartLines.concat(parts)
+		}
+	})
+	collapseIdenticalEndings(chartLines)
+	addLineBreaks(chartLines)
+	addPercents(chartLines)
+	return chartLines
+
+}
+
+const breakSynonyms = ['break', '(break)', 'no chord', 'n.c.', 'tacet'];
+
+function flattenVoices(staves) {
+	const parts = []
+	let partName = ""
+	let measures = []
+	let currentBar = {chord: ['', '', '', '']}
+	let lastChord = ""
+	let nextBarEnding = ""
+	staves.forEach((staff, staffNum) => {
+		if (staff.voices) {
+			staff.voices.forEach((voice, voiceNum) => {
+				let currentPartNum = 0
+				let beatNum = 0
+				let measureNum = 0
+				voice.forEach(element => {
+					if (element.el_type === 'part') {
+						if (measures.length > 0) {
+							if (staffNum === 0 && voiceNum === 0) {
+								parts.push({
+									type: "part",
+									name: partName,
+									lines: [measures]
+								})
+								measures = []
+							// } else {
+							// 	currentPartNum++
+							// 	measureNum = 0
+							// 	measures = parts[currentPartNum].lines[0]
+							}
+						}
+						partName = element.title
+					} else if (element.el_type === 'note') {
+						addDecoration(element, currentBar)
+						const intBeat = Math.floor(beatNum)
+						if (element.chord && element.chord.length > 0) {
+							const chord = element.chord[0] // Use just the first chord specified - if there are multiple ones, then ignore them
+							const chordName = chord.position === 'default' || breakSynonyms.indexOf(chord.name.toLowerCase()) >= 0 ? chord.name : ''
+							if (chordName) {
+								if (intBeat > 0 && !currentBar.chord[0]) // Be sure there is a chord for the first beat in a measure
+									currentBar.chord[0] = lastChord
+								lastChord = chordName
+								if (currentBar.chord[intBeat]) {
+									// If there is already a chord on this beat put the next chord on the next beat, but don't overwrite anything.
+									// This handles the case were a chord is misplaced slightly, for instance it is on the 1/8 before the beat.
+									if (intBeat < 4 && !currentBar.chord[intBeat + 1])
+										currentBar.chord[intBeat + 1] = chordName
+								} else
+									currentBar.chord[intBeat] = chordName
+							}
+							element.chord.forEach(ch => {
+								if (ch.position !== 'default' && breakSynonyms.indexOf(chord.name.toLowerCase()) < 0){
+									if (!currentBar.annotations)
+										currentBar.annotations = []
+									currentBar.annotations.push(ch.name)
+								}
+							})
+						}
+						if (!element.rest || element.rest.type !== 'spacer') {
+							const thisDuration = Math.floor(element.duration * 4)
+							if (thisDuration > 4) {
+								measureNum += Math.floor(thisDuration / 4)
+								beatNum = 0
+							} else {
+								let thisBeat = element.duration * 4
+								if (element.tripletMultiplier)
+									thisBeat *= element.tripletMultiplier
+								beatNum += thisBeat
+							}
+						}
+					} else if (element.el_type === 'bar') {
+						if (nextBarEnding) {
+							currentBar.ending = nextBarEnding
+							nextBarEnding = ""
+						}
+						addDecoration(element, currentBar)
+						if (element.type === 'bar_dbl_repeat' || element.type === 'bar_left_repeat')
+							currentBar.hasStartRepeat = true
+						if (element.type === 'bar_dbl_repeat' || element.type === 'bar_right_repeat')
+							currentBar.hasEndRepeat = true
+						if (element.startEnding)
+							nextBarEnding = element.startEnding
+						if (beatNum >= 4) {
+							if (currentBar.chord[0] === '') {
+								// If there isn't a chord change at the beginning, repeat the last chord found
+								if (currentBar.chord[1] || currentBar.chord[2] || currentBar.chord[3]) {
+									currentBar.chord[0] = findLastChord(measures)
+								}
+							}
+							if (staffNum === 0 && voiceNum === 0)
+								measures.push(currentBar)
+							else {
+								// Add the found items of interest to the original array
+								// We have the extra [0] in there because lines is an array of lines (but we just use the [0] for constructing, we split it apart at the end)
+								let index = measureNum
+								let partIndex = 0
+								while (index >= parts[partIndex].lines[0].length && partIndex < parts.length) {
+									index -= parts[partIndex].lines[0].length
+									partIndex++
+								}
+								if (partIndex < parts.length && index < parts[partIndex].lines[0].length) {
+									const bar = parts[partIndex].lines[0][index]
+									if (!bar.chord[0] && currentBar.chord[0])
+										bar.chord[0] = currentBar.chord[0]
+									if (!bar.chord[1] && currentBar.chord[1])
+										bar.chord[1] = currentBar.chord[1]
+									if (!bar.chord[2] && currentBar.chord[2])
+										bar.chord[2] = currentBar.chord[2]
+									if (!bar.chord[3] && currentBar.chord[3])
+										bar.chord[3] = currentBar.chord[3]
+									if (currentBar.annotations) {
+										if (!bar.annotations)
+											bar.annotations = currentBar.annotations
+										else
+											bar.annotations = bar.annotations.concat(currentBar.annotations)
+									}
+								}
+								measureNum++
+							}
+							currentBar = {chord: ['', '', '', '']}
+						} else
+							currentBar.chord = ['', '', '', '']
+						beatNum = 0
+					} else if (element.el_type === 'tempo') {
+						// TODO-PER: should probably report tempo, too
+					}
+				})
+				if (staffNum === 0 && voiceNum === 0) {
+					parts.push({
+						type: "part",
+						name: partName,
+						lines: [measures]
+					})
+				}
+			})
+		}
+	})
+	if (!lastChord)
+		throw new Error("noChords")
+	return parts
+}
+
+function findLastChord(measures) {
+	for (let m = measures.length-1; m >= 0; m--) {
+		for (let c = measures[m].chord.length-1; c >= 0; c--) {
+			if (measures[m].chord[c])
+				return measures[m].chord[c]
+		}
+	}
+}
+
+function collapseIdenticalEndings(chartLines) {
+	chartLines.forEach(line => {
+		if (line.type === "part") {
+			const partLine = line.lines[0]
+			const ending1 = partLine.findIndex(bar => {
+				return !!bar.ending
+			})
+			const ending2 = partLine.findIndex((bar, index) => {
+				return index > ending1 && !!bar.ending
+			})
+			if (ending1 >= 0 && ending2 >= 0) {
+				// If the endings are not the same length, don't collapse
+				if (ending2 - ending1 === partLine.length - ending2) {
+					let matches = true
+					for (let i = 0; i < ending2 - ending1 && matches; i++) {
+						const measureLhs = partLine[ending1+i]
+						const measureRhs = partLine[ending2+i]
+						if (measureLhs.chord[0] !== measureRhs.chord[0])
+							matches = false
+						if (measureLhs.chord[1] !== measureRhs.chord[1])
+							matches = false
+						if (measureLhs.chord[2] !== measureRhs.chord[2])
+							matches = false
+						if (measureLhs.chord[3] !== measureRhs.chord[3])
+							matches = false
+						if (measureLhs.annotations && !measureRhs.annotations)
+							matches = false
+						if (!measureLhs.annotations && measureRhs.annotations)
+							matches = false
+						if (measureLhs.annotations && measureRhs.annotations) {
+							if (measureLhs.annotations.length !== measureRhs.annotations.length)
+								matches = false
+							else {
+								for (let j = 0; j < measureLhs.annotations.length; j++) {
+									if (measureLhs.annotations[j] !== measureRhs.annotations[j])
+										matches = false
+								}
+							}
+						}
+					}
+					if (matches) {
+						delete partLine[ending1].ending
+						partLine.splice(ending2, partLine.length - ending2)
+					}
+				}
+			}
+		}
+	})
+}
+
+function addLineBreaks(chartLines) {
+	chartLines.forEach(line => {
+		if (line.type === "part") {
+			const newLines = []
+			const oldLines = line.lines[0]
+			let is12bar = false
+			const firstEndRepeat = oldLines.findIndex(l => {
+				return !!l.hasEndRepeat
+			})
+			const length = firstEndRepeat >= 0 ? Math.min(firstEndRepeat+1,oldLines.length) : oldLines.length
+			if (length === 12)
+				is12bar = true
+			const barsPerLine = is12bar ? 4 : 8 // Only do 4 bars per line for 12-bar blues
+			for (let i = 0; i < oldLines.length; i += barsPerLine) {
+				const newLine = oldLines.slice(i, i + barsPerLine)
+				const endRepeat = newLine.findIndex(l => {
+					return !!l.hasEndRepeat
+				})
+				if (endRepeat >= 0 && endRepeat < newLine.length-1) {
+					newLines.push(newLine.slice(0, endRepeat+1))
+					newLines.push(newLine.slice(endRepeat+1))
+				} else
+					newLines.push(newLine)
+			}
+			// TODO-PER: The following probably doesn't handle all cases. Rethink it.
+			for (let i = 0; i < newLines.length; i++) {
+				if (newLines[i][0].ending) {
+					const prevLine = Math.max(0, i-1)
+					const toAdd = newLines[prevLine].length - newLines[i].length
+					const thisLine = []
+					for (let j = 0; j < toAdd; j++)
+						thisLine.push({noBorder: true, chord: ['', '', '', '']})
+					newLines[i] = thisLine.concat(newLines[i])
+				}
+			}
+			line.lines = newLines
+		}
+	})
+}
+
+function addPercents(chartLines) {
+	chartLines.forEach(part => {
+		if (part.lines) {
+			let lastMeasureSingle = false
+			let lastChord = ""
+			part.lines.forEach(line => {
+				line.forEach(measure => {
+					if (!measure.noBorder) {
+						const chords = measure.chord
+						if (!chords[0] && !chords[1] && !chords[2] && !chords[3]) {
+							// if there are no chords specified for this measure
+							if (lastMeasureSingle) {
+								if (lastChord)
+									chords[0] = '%'
+							} else
+								chords[0] = lastChord
+							lastMeasureSingle = true
+						} else if (!chords[1] && !chords[2] && !chords[3]) {
+							// if there is a single chord for this measure
+							lastMeasureSingle = true
+							lastChord = chords[0]
+						} else {
+							// if the measure is complicated - in that case the next measure won't get %
+							lastMeasureSingle = false
+							lastChord = chords[3] || chords[2] || chords[1]
+						}
+					}
+				})
+			})
+		}
+	})
+}
+
+function addDecoration(element, currentBar) {
+	if (element.decoration) {
+		// Some decorations are interesting to rhythm players
+		for (let i = 0; i < element.decoration.length; i++) {
+			switch (element.decoration[i]) {
+				case 'fermata':
+				case 'segno':
+				case 'coda':
+				case "D.C.":
+				case "D.S.":
+				case "D.C.alcoda":
+				case "D.C.alfine":
+				case "D.S.alcoda":
+				case "D.S.alfine":
+				case "fine":
+					if (!currentBar.annotations)
+						currentBar.annotations = []
+					currentBar.annotations.push(element.decoration[i])
+					break;
+			}
+		}
+	}
+}
+module.exports = chordGrid

package/src/parse/tune-builder.js

@@ -549,7 +549,7 @@ function resolveOverlays(tune) {
 						} else if (event.el_type === "note") {
 							if (inOverlay) {
 								overlayVoice[k].voice.push(event);
-							} else {
+							} else if (!event.rest || event.rest.type !== 'spacer') {
 								durationThisBar += event.duration;
 								durationsPerLines[i] += event.duration;
 							}

package/src/str/output.js

@@ -1,5 +1,5 @@
 var keyAccidentals = require("../const/key-accidentals");
-var { relativeMajor, transposeKey, relativeMode } = require("../const/relative-major");
+var { relativeMajor, transposeKey, relativeMode, isLegalMode } = require("../const/relative-major");
 var transposeChordName = require("../parse/transpose-chord")
 
 var strTranspose;
@@ -61,8 +61,9 @@ var strTranspose;
 			var match = segment.match(/^( *)([A-G])([#b]?)( ?)(\w*)/)
 			if (match) {
 				var start = count + 2 + match[1].length // move past the 'K:' and optional white space
-				var key = match[2] + match[3] + match[4] + match[5] // key name, accidental, optional space, and mode
-				var destinationKey = newKey({ root: match[2], acc: match[3], mode: match[5] }, steps)
+				var mode = isLegalMode(match[5]) ? match[5]: ''
+				var key = match[2] + match[3] + match[4] + mode // key name, accidental, optional space, and mode
+				var destinationKey = newKey({ root: match[2], acc: match[3], mode: mode }, steps)
 				var dest = destinationKey.root + destinationKey.acc + match[4] + destinationKey.mode
 				changes.push({ start: start, end: start + key.length, note: dest })
 			}
@@ -136,14 +137,16 @@ var strTranspose;
 				}
 			}
 			if (el.el_type === 'note' && el.pitches) {
-				for (var j = 0; j < el.pitches.length; j++) {
-					var note = parseNote(el.pitches[j].name, keyRoot, keyAccidentals, measureAccidentals)
+				var pitchArray = findNotes(abc,el.startChar, el.endChar)
+				//console.log(pitchArray)
+				for (var j = 0; j < pitchArray.length; j++) {
+					var note = parseNote(pitchArray[j].note, keyRoot, keyAccidentals, measureAccidentals)
 					if (note.acc)
 						measureAccidentals[note.name.toUpperCase()] = note.acc
 					var newPitch = transposePitch(note, destinationKey, letterDistance, transposedMeasureAccidentals)
 					if (newPitch.acc)
 						transposedMeasureAccidentals[newPitch.upper] = newPitch.acc
-					changes.push(replaceNote(abc, el.startChar, el.endChar, newPitch.acc + newPitch.name, j))
+					changes.push({note:newPitch.acc+newPitch.name, start: pitchArray[j].index, end: pitchArray[j].index+pitchArray[j].note.length})
 				}
 				if (el.gracenotes) {
 					for (var g = 0; g < el.gracenotes.length; g++) {
@@ -216,6 +219,7 @@ var strTranspose;
 				break;
 			}
 		}
+		var newNote
 		switch (adj) {
 			case -2: acc = "__"; break;
 			case -1: acc = "_"; break;
@@ -224,7 +228,7 @@ var strTranspose;
 			case 2: acc = "^^"; break;
 			case -3:
 				// This requires a triple flat, so bump down the pitch and try again
-				var newNote = {}
+				newNote = {}
 				newNote.pitch = note.pitch - 1
 				newNote.oct = note.oct
 				newNote.name = letters[letters.indexOf(note.name) - 1]
@@ -239,7 +243,7 @@ var strTranspose;
 				return transposePitch(newNote, key, letterDistance + 1, measureAccidentals)
 			case 3:
 				// This requires a triple sharp, so bump up the pitch and try again
-				var newNote = {}
+				newNote = {}
 				newNote.pitch = note.pitch + 1
 				newNote.oct = note.oct
 				newNote.name = letters[letters.indexOf(note.name) + 1]
@@ -276,8 +280,8 @@ var strTranspose;
 	var regPitch = /([_^=]*)([A-Ga-g])([,']*)/
 	var regNote = /([_^=]*[A-Ga-g][,']*)(\d*\/*\d*)([\>\<\-\)\.\s\\]*)/
 	var regOptionalNote = /([_^=]*[A-Ga-g][,']*)?(\d*\/*\d*)?([\>\<\-\)]*)?/
-	var regSpace = /(\s*)$/
-	var regOptionalSpace = /(\s*)/
+	//var regSpace = /(\s*)$/
+	//var regOptionalSpace = /(\s*)/
 
 	// This the relationship of the note to the tonic and an octave. So what is returned is a distance in steps from the tonic and the amount of adjustment from
 	// a normal scale. That is - in the key of D an F# is two steps from the tonic and no adjustment. A G# is three steps from the tonic and one half-step higher.
@@ -298,63 +302,95 @@ var strTranspose;
 		return { acc: reg[1], name: name, pitch: pos, oct: oct, adj: calcAdjustment(reg[1], keyAccidentals[name], measureAccidentals[name]), courtesy: reg[1] === currentAcc }
 	}
 
-	function replaceNote(abc, start, end, newPitch, index) {
+	function findNotes(abc, start, end) {
+		// TODO-PER: I thought this regex should have found all the notes and ignored the chords and decorations but it didn't: /(?:"[^"]+")*(?:![^!]+!)*([_^=]*)([A-Ga-g])([,']*)/g
 		var note = abc.substring(start, end);
-		// Try single note first
-		var match = note.match(new RegExp(regNote.source + regSpace.source));
-		if (match) {
-			var noteLen = match[1].length;
-			var trailingLen = match[2].length + match[3].length + match[4].length;
-			var leadingLen = end - start - noteLen - trailingLen;
-			start += leadingLen;
-			end -= trailingLen;
-		} else {
-			// Match chord
-			var regPreBracket = /([^\[]*)/;
-			var regOpenBracket = /\[/;
-			var regCloseBracket = /\-?](\d*\/*\d*)?([\>\<\-\)]*)/;
-			var regChord = new RegExp(
-				regPreBracket.source +
-				regOpenBracket.source +
-				"(?:" + regOptionalNote.source + "\\s*){1,8}" +
-				regCloseBracket.source +
-				regSpace.source
-			);
-			match = note.match(regChord);
-			if (match) {
-				var beforeChordLen = match[1].length + 1; // text before + '['
-				var chordBody = note.slice(match[1].length + 1, note.lastIndexOf("]"));
-				// Collect notes inside chord
-				var chordNotes = [];
-				var regNoteWithSpace = new RegExp(regOptionalNote.source + "\\s*", "g");
-				for (const m of chordBody.matchAll(regNoteWithSpace)) {
-					let noteText = m[0].trim();
-					if (noteText !== "") {
-						chordNotes.push({ text: noteText, index: m.index });
-					}
-				}
-				if (index >= chordNotes.length) {
-					throw new Error("Chord index out of range for chord: " + note);
-				}
-				var chosen = chordNotes[index];
-				// Preserve duration and tie
-				let mDurTie = chosen.text.match(/^(.+?)(\d+\/?\d*)?(-)?$/);
-				let pitchPart = mDurTie ? mDurTie[1] : chosen.text;
-				let durationPart = mDurTie && mDurTie[2] ? mDurTie[2] : "";
-				let tiePart = mDurTie && mDurTie[3] ? mDurTie[3] : "";
-				// Replace note keeping duration and tie
-				newPitch = newPitch + durationPart + tiePart;
-				start += beforeChordLen + chosen.index;
-				end = start + chosen.text.length;
+
+		// Since the regex will also find "c", "d", and "a" in `!coda!`, we need to filter them
+		var array
+		var ignoreBlocks = []
+		var regChord = /("[^"]+")+/g
+		while ((array = regChord.exec(note)) !== null) {
+			ignoreBlocks.push({start: regChord.lastIndex-array[0].length, end: regChord.lastIndex})
+		}
+		var regDec = /(![^!]+!)+/g
+		while ((array = regDec.exec(note)) !== null) {
+			ignoreBlocks.push({start: regDec.lastIndex-array[0].length, end: regDec.lastIndex})
+		}
+
+		var ret = []
+		// Define the regex each time because it is stateful
+		var regPitch = /([_^=]*)([A-Ga-g])([,']*)/g
+		while ((array = regPitch.exec(note)) !== null) {
+			var found = false
+			for (var i = 0; i < ignoreBlocks.length; i++) {
+				if (regPitch.lastIndex >= ignoreBlocks[i].start && regPitch.lastIndex <= ignoreBlocks[i].end)
+					found = true
 			}
+			if (!found)
+				ret.push({note: array[0], index: start + regPitch.lastIndex-array[0].length})
 		}
-		return {
-			start: start,
-			end: end,
-			note: newPitch
-		};
+
+		return ret
 	}
 
+	// function replaceNote(abc, start, end, newPitch, oldPitch, index) {
+	// 	var note = abc.substring(start, end);
+	// 	// Try single note first
+	// 	var match = note.match(new RegExp(regNote.source + regSpace.source));
+	// 	if (match) {
+	// 		var noteLen = match[1].length;
+	// 		var trailingLen = match[2].length + match[3].length + match[4].length;
+	// 		var leadingLen = end - start - noteLen - trailingLen;
+	// 		start += leadingLen;
+	// 		end -= trailingLen;
+	// 	} else {
+	// 		// Match chord
+	// 		var regPreBracket = /([^\[]*)/;
+	// 		var regOpenBracket = /\[/;
+	// 		var regCloseBracket = /\-?](\d*\/*\d*)?([\>\<\-\)]*)/;
+	// 		var regChord = new RegExp(
+	// 			regPreBracket.source +
+	// 			regOpenBracket.source +
+	// 			"(?:" + regOptionalNote.source + "\\s*){1,8}" +
+	// 			regCloseBracket.source +
+	// 			regSpace.source
+	// 		);
+	// 		match = note.match(regChord);
+	// 		if (match) {
+	// 			var beforeChordLen = match[1].length + 1; // text before + '['
+	// 			var chordBody = note.slice(match[1].length + 1, note.lastIndexOf("]"));
+	// 			// Collect notes inside chord
+	// 			var chordNotes = [];
+	// 			var regNoteWithSpace = new RegExp(regOptionalNote.source + "\\s*", "g");
+	// 			for (const m of chordBody.matchAll(regNoteWithSpace)) {
+	// 				let noteText = m[0].trim();
+	// 				if (noteText !== "") {
+	// 					chordNotes.push({ text: noteText, index: m.index });
+	// 				}
+	// 			}
+	// 			if (index >= chordNotes.length) {
+	// 				throw new Error("Chord index out of range for chord: " + note);
+	// 			}
+	// 			var chosen = chordNotes[index];
+	// 			// Preserve duration and tie
+	// 			let mDurTie = chosen.text.match(/^(.+?)(\d+\/?\d*)?(-)?$/);
+	// 			let pitchPart = mDurTie ? mDurTie[1] : chosen.text;
+	// 			let durationPart = mDurTie && mDurTie[2] ? mDurTie[2] : "";
+	// 			let tiePart = mDurTie && mDurTie[3] ? mDurTie[3] : "";
+	// 			// Replace note keeping duration and tie
+	// 			newPitch = newPitch + durationPart + tiePart;
+	// 			start += beforeChordLen + chosen.index;
+	// 			end = start + chosen.text.length;
+	// 		}
+	// 	}
+	// 	return {
+	// 		start: start,
+	// 		end: end,
+	// 		note: newPitch
+	// 	};
+	// }
+
 	function replaceGrace(abc, start, end, newGrace, index) {
 		var note = abc.substring(start, end)
 		// I don't know how to capture more than one note, so I'm separating them. There is a limit of the number of notes in a chord depending on the repeats I have here, but it is unlikely to happen in real music.