abcjs 6.1.9 → 6.2.1

package/src/write/creation/decoration.js

@@ -0,0 +1,357 @@
+// abc_decoration.js: Creates a data structure suitable for printing a line of abc
+
+var DynamicDecoration = require('./elements/dynamic-decoration');
+var CrescendoElem = require('./elements/crescendo-element');
+var GlissandoElem = require('./elements/glissando-element');
+var glyphs = require('./glyphs');
+var RelativeElement = require('./elements/relative-element');
+var TieElem = require('./elements/tie-element');
+
+var Decoration = function Decoration() {
+	this.startDiminuendoX = undefined;
+	this.startCrescendoX = undefined;
+	this.minTop = 12;	// TODO-PER: this is assuming a 5-line staff. Pass that info in.
+	this.minBottom = 0;
+};
+
+var closeDecoration = function (voice, decoration, pitch, width, abselem, roomtaken, dir, minPitch) {
+	var yPos;
+	for (var i = 0; i < decoration.length; i++) {
+		if (decoration[i] === "staccato" || decoration[i] === "tenuto" || decoration[i] === "accent") {
+			var symbol = "scripts." + decoration[i];
+			if (decoration[i] === "accent") symbol = "scripts.sforzato";
+			if (yPos === undefined)
+				yPos = (dir === "down") ? pitch + 2 : minPitch - 2;
+			else
+				yPos = (dir === "down") ? yPos + 2 : yPos - 2;
+			if (decoration[i] === "accent") {
+				// Always place the accent three pitches away, no matter whether that is a line or space.
+				if (dir === "up") yPos--;
+				else yPos++;
+			} else {
+				// don't place on a stave line. The stave lines are 2,4,6,8,10
+				switch (yPos) {
+					case 2:
+					case 4:
+					case 6:
+					case 8:
+					case 10:
+						if (dir === "up") yPos--;
+						else yPos++;
+						break;
+				}
+			}
+			if (pitch > 9) yPos++; // take up some room of those that are above
+			var deltaX = width / 2;
+			if (glyphs.getSymbolAlign(symbol) !== "center") {
+				deltaX -= (glyphs.getSymbolWidth(symbol) / 2);
+			}
+			abselem.addFixedX(new RelativeElement(symbol, deltaX, glyphs.getSymbolWidth(symbol), yPos));
+		}
+		if (decoration[i] === "slide" && abselem.heads[0]) {
+			var yPos2 = abselem.heads[0].pitch;
+			yPos2 -= 2; // TODO-PER: not sure what this fudge factor is.
+			var blank1 = new RelativeElement("", -roomtaken - 15, 0, yPos2 - 1);
+			var blank2 = new RelativeElement("", -roomtaken - 5, 0, yPos2 + 1);
+			abselem.addFixedX(blank1);
+			abselem.addFixedX(blank2);
+			voice.addOther(new TieElem({ anchor1: blank1, anchor2: blank2, fixedY: true }));
+		}
+	}
+	if (yPos === undefined)
+		yPos = pitch;
+
+	return { above: yPos, below: abselem.bottom };
+};
+
+var volumeDecoration = function (voice, decoration, abselem, positioning) {
+	for (var i = 0; i < decoration.length; i++) {
+		switch (decoration[i]) {
+			case "p":
+			case "mp":
+			case "pp":
+			case "ppp":
+			case "pppp":
+			case "f":
+			case "ff":
+			case "fff":
+			case "ffff":
+			case "sfz":
+			case "mf":
+				var elem = new DynamicDecoration(abselem, decoration[i], positioning);
+				voice.addOther(elem);
+		}
+	}
+};
+
+var compoundDecoration = function (decoration, pitch, width, abselem, dir) {
+	function highestPitch() {
+		if (abselem.heads.length === 0)
+			return 10;	// TODO-PER: I don't know if this can happen, but we'll return the top of the staff if so.
+		var pitch = abselem.heads[0].pitch;
+		for (var i = 1; i < abselem.heads.length; i++)
+			pitch = Math.max(pitch, abselem.heads[i].pitch);
+		return pitch;
+	}
+	function lowestPitch() {
+		if (abselem.heads.length === 0)
+			return 2;	// TODO-PER: I don't know if this can happen, but we'll return the bottom of the staff if so.
+		var pitch = abselem.heads[0].pitch;
+		for (var i = 1; i < abselem.heads.length; i++)
+			pitch = Math.min(pitch, abselem.heads[i].pitch);
+		return pitch;
+	}
+	function compoundDecoration(symbol, count) {
+		var placement = (dir === 'down') ? lowestPitch() + 1 : highestPitch() + 9;
+		if (dir !== 'down' && count === 1)
+			placement--;
+		var deltaX = width / 2;
+		deltaX += (dir === 'down') ? -5 : 3;
+		for (var i = 0; i < count; i++) {
+			placement -= 1;
+			abselem.addFixedX(new RelativeElement(symbol, deltaX, glyphs.getSymbolWidth(symbol), placement));
+		}
+	}
+
+	for (var i = 0; i < decoration.length; i++) {
+		switch (decoration[i]) {
+			case "/": compoundDecoration("flags.ugrace", 1); break;
+			case "//": compoundDecoration("flags.ugrace", 2); break;
+			case "///": compoundDecoration("flags.ugrace", 3); break;
+			case "////": compoundDecoration("flags.ugrace", 4); break;
+		}
+	}
+};
+
+var stackedDecoration = function (decoration, width, abselem, yPos, positioning, minTop, minBottom) {
+	function incrementPlacement(placement, height) {
+		if (placement === 'above')
+			yPos.above += height;
+		else
+			yPos.below -= height;
+	}
+	function getPlacement(placement) {
+		var y;
+		if (placement === 'above') {
+			y = yPos.above;
+			if (y < minTop)
+				y = minTop;
+		} else {
+			y = yPos.below;
+			if (y > minBottom)
+				y = minBottom;
+		}
+		return y;
+	}
+	function textDecoration(text, placement, anchor) {
+		var y = getPlacement(placement);
+		var textFudge = 2;
+		var textHeight = 5;
+		// TODO-PER: Get the height of the current font and use that for the thickness.
+		abselem.addFixedX(new RelativeElement(text, width / 2, 0, y + textFudge, { type: "decoration", klass: 'ornament', thickness: 3, anchor: anchor }));
+
+		incrementPlacement(placement, textHeight);
+	}
+	function symbolDecoration(symbol, placement) {
+		var deltaX = width / 2;
+		if (glyphs.getSymbolAlign(symbol) !== "center") {
+			deltaX -= (glyphs.getSymbolWidth(symbol) / 2);
+		}
+		var height = glyphs.symbolHeightInPitches(symbol) + 1; // adding a little padding so nothing touches.
+		var y = getPlacement(placement);
+		y = (placement === 'above') ? y + height / 2 : y - height / 2;// Center the element vertically.
+		abselem.addFixedX(new RelativeElement(symbol, deltaX, glyphs.getSymbolWidth(symbol), y, { klass: 'ornament', thickness: glyphs.symbolHeightInPitches(symbol) }));
+
+		incrementPlacement(placement, height);
+	}
+
+	var symbolList = {
+		"+": "scripts.stopped",
+		"open": "scripts.open",
+		"snap": "scripts.snap",
+		"wedge": "scripts.wedge",
+		"thumb": "scripts.thumb",
+		"shortphrase": "scripts.shortphrase",
+		"mediumphrase": "scripts.mediumphrase",
+		"longphrase": "scripts.longphrase",
+		"trill": "scripts.trill",
+		"roll": "scripts.roll",
+		"irishroll": "scripts.roll",
+		"marcato": "scripts.umarcato",
+		"dmarcato": "scripts.dmarcato",
+		"umarcato": "scripts.umarcato",
+		"turn": "scripts.turn",
+		"uppermordent": "scripts.prall",
+		"pralltriller": "scripts.prall",
+		"mordent": "scripts.mordent",
+		"lowermordent": "scripts.mordent",
+		"downbow": "scripts.downbow",
+		"upbow": "scripts.upbow",
+		"fermata": "scripts.ufermata",
+		"invertedfermata": "scripts.dfermata",
+		"breath": ",",
+		"coda": "scripts.coda",
+		"segno": "scripts.segno"
+	};
+
+	var hasOne = false;
+	for (var i = 0; i < decoration.length; i++) {
+		switch (decoration[i]) {
+			case "0":
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "D.C.":
+			case "D.S.":
+				textDecoration(decoration[i], positioning, 'middle');
+				hasOne = true;
+				break;
+			case "D.C.alcoda":
+				textDecoration("D.C. al coda", positioning, 'end');
+				hasOne = true;
+				break;
+			case "D.C.alfine":
+				textDecoration("D.C. al fine", positioning, 'end');
+				hasOne = true;
+				break;
+			case "D.S.alcoda":
+				textDecoration("D.S. al coda", positioning, 'end');
+				hasOne = true;
+				break;
+			case "D.S.alfine":
+				textDecoration("D.S. al fine", positioning, 'end');
+				hasOne = true;
+				break;
+			case "fine":
+				textDecoration("FINE", positioning, 'middle');
+				hasOne = true;
+				break;
+			case "+":
+			case "open":
+			case "snap":
+			case "wedge":
+			case "thumb":
+			case "shortphrase":
+			case "mediumphrase":
+			case "longphrase":
+			case "trill":
+			case "roll":
+			case "irishroll":
+			case "marcato":
+			case "dmarcato":
+			case "turn":
+			case "uppermordent":
+			case "pralltriller":
+			case "mordent":
+			case "lowermordent":
+			case "downbow":
+			case "upbow":
+			case "fermata":
+			case "breath":
+			case "umarcato":
+			case "coda":
+			case "segno":
+				symbolDecoration(symbolList[decoration[i]], positioning);
+				hasOne = true;
+				break;
+			case "invertedfermata":
+				symbolDecoration(symbolList[decoration[i]], 'below');
+				hasOne = true;
+				break;
+			case "mark":
+				abselem.klass = "mark";
+				break;
+		}
+	}
+	return hasOne;
+};
+
+function leftDecoration(decoration, abselem, roomtaken) {
+	for (var i = 0; i < decoration.length; i++) {
+		switch (decoration[i]) {
+			case "arpeggio":
+				// The arpeggio symbol is the height of a note (that is, two Y units). This stacks as many as we need to go from the
+				// top note to the bottom note. The arpeggio should also be a little taller than the stacked notes, so there is an extra
+				// one drawn and it is offset by half of a note height (that is, one Y unit).
+				for (var j = abselem.abcelem.minpitch - 1; j <= abselem.abcelem.maxpitch; j += 2) {
+					abselem.addExtra(
+						new RelativeElement(
+							"scripts.arpeggio",
+							-glyphs.getSymbolWidth("scripts.arpeggio") * 2 - roomtaken,
+							0,
+							j + 2,
+							{ klass: 'ornament', thickness: glyphs.symbolHeightInPitches("scripts.arpeggio") }
+						)
+					);
+				}
+				break;
+		}
+	}
+}
+
+Decoration.prototype.dynamicDecoration = function (voice, decoration, abselem, positioning) {
+	var diminuendo;
+	var crescendo;
+	var glissando;
+	for (var i = 0; i < decoration.length; i++) {
+		switch (decoration[i]) {
+			case "diminuendo(":
+				this.startDiminuendoX = abselem;
+				diminuendo = undefined;
+				break;
+			case "diminuendo)":
+				diminuendo = { start: this.startDiminuendoX, stop: abselem };
+				this.startDiminuendoX = undefined;
+				break;
+			case "crescendo(":
+				this.startCrescendoX = abselem;
+				crescendo = undefined;
+				break;
+			case "crescendo)":
+				crescendo = { start: this.startCrescendoX, stop: abselem };
+				this.startCrescendoX = undefined;
+				break;
+			case "glissando(":
+				this.startGlissandoX = abselem;
+				glissando = undefined;
+				break;
+			case "glissando)":
+				glissando = { start: this.startGlissandoX, stop: abselem };
+				this.startGlissandoX = undefined;
+				break;
+		}
+	}
+	if (diminuendo) {
+		voice.addOther(new CrescendoElem(diminuendo.start, diminuendo.stop, ">", positioning));
+	}
+	if (crescendo) {
+		voice.addOther(new CrescendoElem(crescendo.start, crescendo.stop, "<", positioning));
+	}
+	if (glissando) {
+		voice.addOther(new GlissandoElem(glissando.start, glissando.stop));
+	}
+};
+
+Decoration.prototype.createDecoration = function (voice, decoration, pitch, width, abselem, roomtaken, dir, minPitch, positioning, hasVocals) {
+	if (!positioning)
+		positioning = { ornamentPosition: 'above', volumePosition: hasVocals ? 'above' : 'below', dynamicPosition: hasVocals ? 'above' : 'below' };
+	// These decorations don't affect the placement of other decorations
+	volumeDecoration(voice, decoration, abselem, positioning.volumePosition);
+	this.dynamicDecoration(voice, decoration, abselem, positioning.dynamicPosition);
+	compoundDecoration(decoration, pitch, width, abselem, dir);
+
+	// treat staccato, accent, and tenuto first (may need to shift other markers)
+	var yPos = closeDecoration(voice, decoration, pitch, width, abselem, roomtaken, dir, minPitch);
+	// yPos is an object containing 'above' and 'below'. That is the placement of the next symbol on either side.
+
+	yPos.above = Math.max(yPos.above, this.minTop);
+	var hasOne = stackedDecoration(decoration, width, abselem, yPos, positioning.ornamentPosition, this.minTop, this.minBottom);
+	if (hasOne) {
+		//			abselem.top = Math.max(yPos.above + 3, abselem.top); // TODO-PER: Not sure why we need this fudge factor.
+	}
+	leftDecoration(decoration, abselem, roomtaken);
+};
+
+module.exports = Decoration;

package/src/write/{abc_absolute_element.js → creation/elements/absolute-element.js}

@@ -1,8 +1,7 @@
 //    abc_absolute_element.js: Definition of the AbsoluteElement class.
 
-var setClass = require('./set-class');
-var highlight = require("./highlight");
-var unhighlight = require("./unhighlight");
+var highlight = require("../../interactive/highlight");
+var unhighlight = require("../../interactive/unhighlight");
 
 // Everything that is placed in the SVG is first created as an absolute element. This is one unit of graphic information.
 // That is, it embodies a concept: a clef, a time signature, a bar line,etc. or most complexly:
@@ -32,7 +31,7 @@ var unhighlight = require("./unhighlight");
 // minspacing - spacing which must be taken on top of the width defined by the duration
 // type is a meta-type for the element. It is not necessary for drawing, but it is useful to make semantic sense of the element. For instance, it can be used in the element's class name.
 var AbsoluteElement = function AbsoluteElement(abcelem, duration, minspacing, type, tuneNumber, options) {
-//	console.log("Absolute:",abcelem, duration, minspacing, type, tuneNumber, options);
+	//	console.log("Absolute:",abcelem, duration, minspacing, type, tuneNumber, options);
 	if (!options)
 		options = {};
 	this.tuneNumber = tuneNumber;
@@ -92,16 +91,16 @@ AbsoluteElement.prototype.addExtra = function (extra) {
 	// )
 	// 	console.log("extra", extra);
 
-	this.fixed.w = Math.max(this.fixed.w, extra.dx+extra.w);
+	this.fixed.w = Math.max(this.fixed.w, extra.dx + extra.w);
 	if (this.fixed.t === undefined) this.fixed.t = extra.top; else this.fixed.t = Math.max(this.fixed.t, extra.top);
 	if (this.fixed.b === undefined) this.fixed.b = extra.bottom; else this.fixed.b = Math.min(this.fixed.b, extra.bottom);
-	if (extra.dx<this.extraw) this.extraw = extra.dx;
+	if (extra.dx < this.extraw) this.extraw = extra.dx;
 	this.extra[this.extra.length] = extra;
 	this._addChild(extra);
 };
 
 AbsoluteElement.prototype.addHead = function (head) {
-	if (head.dx<this.extraw) this.extraw = head.dx;
+	if (head.dx < this.extraw) this.extraw = head.dx;
 	this.heads[this.heads.length] = head;
 	this.addRight(head);
 };
@@ -128,7 +127,7 @@ AbsoluteElement.prototype.addRight = function (right) {
 	// )
 	// 	console.log("right", right);
 	// These are the elements that are the fixed part.
-	this.fixed.w = Math.max(this.fixed.w, right.dx+right.w);
+	this.fixed.w = Math.max(this.fixed.w, right.dx + right.w);
 	if (right.top !== undefined) {
 		if (this.fixed.t === undefined) this.fixed.t = right.top; else this.fixed.t = Math.max(this.fixed.t, right.top);
 	}
@@ -137,7 +136,7 @@ AbsoluteElement.prototype.addRight = function (right) {
 	}
 	// if (isNaN(this.fixed.t) || isNaN(this.fixed.b))
 	// 	debugger;
-	if (right.dx+right.w>this.w) this.w = right.dx+right.w;
+	if (right.dx + right.w > this.w) this.w = right.dx + right.w;
 	this.right[this.right.length] = right;
 	this._addChild(right);
 };
@@ -161,15 +160,15 @@ AbsoluteElement.prototype.addCentered = function (elem) {
 	// 	elem.type !== 'lyric'
 	// )
 	// 	console.log("centered", elem);
-	var half = elem.w/2;
-	if (-half<this.extraw) this.extraw = -half;
+	var half = elem.w / 2;
+	if (-half < this.extraw) this.extraw = -half;
 	this.extra[this.extra.length] = elem;
-	if (elem.dx+half>this.w) this.w = elem.dx+half;
+	if (elem.dx + half > this.w) this.w = elem.dx + half;
 	this.right[this.right.length] = elem;
 	this._addChild(elem);
 };
 
-AbsoluteElement.prototype.setLimit = function(member, child) {
+AbsoluteElement.prototype.setLimit = function (member, child) {
 	if (!child[member]) return;
 	if (!this.specialY[member])
 		this.specialY[member] = child[member];
@@ -178,7 +177,7 @@ AbsoluteElement.prototype.setLimit = function(member, child) {
 };
 
 AbsoluteElement.prototype._addChild = function (child) {
-//	console.log("Relative:",child);
+	//	console.log("Relative:",child);
 	child.parent = this;
 	this.children[this.children.length] = child;
 	this.pushTop(child.top);
@@ -216,7 +215,7 @@ AbsoluteElement.prototype.pushBottom = function (bottom) {
 
 AbsoluteElement.prototype.setX = function (x) {
 	this.x = x;
-	for (var i=0; i<this.children.length; i++)
+	for (var i = 0; i < this.children.length; i++)
 		this.children[i].setX(x);
 };
 

package/src/write/creation/elements/beam-element.js

@@ -0,0 +1,113 @@
+//    abc_beam_element.js: Definition of the BeamElem class.
+
+// Most elements on the page are related to a particular absolute element -- notes, rests, bars, etc. Beams, however, span multiple elements.
+// This means that beams can't be laid out until the absolute elements are placed. There is the further complication that the stems for beamed
+// notes can't be laid out until the beams are because we don't know how long they will be until we know the slope of the beam and the horizontal
+// spacing of the absolute elements.
+//
+// So, when a beam is detected, a BeamElem is created, then all notes belonging to that beam are added to it. These notes are not given stems at that time.
+// Then, after the horizontal layout is complete, all of the BeamElem are iterated to set the beam position, then all of the notes that are beamed are given
+// stems. After that, we are ready for the drawing step.
+
+// There are three phases: the setup phase, when new elements are being discovered, the layout phase, when everything is calculated, and the drawing phase,
+// when the object is not changed, but is used to put the elements on the page.
+
+//
+// Setup phase
+//
+var BeamElem = function BeamElem(stemHeight, type, flat, firstElement) {
+	// type is "grace", "up", "down", or undefined. flat is used to force flat beams, as it commonly found in the grace notes of bagpipe music.
+	this.type = "BeamElem";
+	this.isflat = !!flat;
+	this.isgrace = !!(type && type === "grace");
+	this.forceup = !!(this.isgrace || (type && type === "up"));
+	this.forcedown = !!(type && type === "down");
+	this.elems = []; // all the AbsoluteElements that this beam touches. It may include embedded rests.
+	this.total = 0;
+	this.average = 6; // use middle line as start for average.
+	this.allrests = true;
+	this.stemHeight = stemHeight;
+	this.beams = []; // During the layout phase, this will become a list of the beams that need to be drawn.
+	if (firstElement && firstElement.duration) {
+		this.duration = firstElement.duration;
+		if (firstElement.startTriplet) {
+			this.duration *= firstElement.tripletMultiplier;
+		}
+		this.duration = Math.round(this.duration * 1000) / 1000;
+	} else
+		this.duration = 0;
+};
+
+BeamElem.prototype.setHint = function () {
+	this.hint = true;
+};
+
+BeamElem.prototype.runningDirection = function (abcelem) {
+	var pitch = abcelem.averagepitch;
+	if (pitch === undefined) return; // don't include elements like spacers in beams
+	this.total = Math.round(this.total + pitch);
+	if (!this.count)
+		this.count = 0;
+	this.count++
+};
+
+BeamElem.prototype.add = function (abselem) {
+	var pitch = abselem.abcelem.averagepitch;
+	if (pitch === undefined) return; // don't include elements like spacers in beams
+	if (!abselem.abcelem.rest)
+		this.allrests = false;
+	abselem.beam = this;
+	this.elems.push(abselem);
+	this.total = Math.round(this.total + pitch);
+	if (this.min === undefined || abselem.abcelem.minpitch < this.min) {
+		this.min = abselem.abcelem.minpitch;
+	}
+	if (this.max === undefined || abselem.abcelem.maxpitch > this.max) {
+		this.max = abselem.abcelem.maxpitch;
+	}
+};
+
+BeamElem.prototype.addBeam = function (beam) {
+	this.beams.push(beam);
+};
+
+BeamElem.prototype.setStemDirection = function () {
+	// Have to figure this out before the notes are placed because placing the notes also places the decorations.
+	this.average = calcAverage(this.total, this.count);
+	if (this.forceup) {
+		this.stemsUp = true;
+	} else if (this.forcedown) {
+		this.stemsUp = false;
+	} else {
+		var middleLine = 6;	// hardcoded 6 is B
+		this.stemsUp = this.average < middleLine; // true is up, false is down;
+	}
+	delete this.count;
+	this.total = 0;
+};
+
+BeamElem.prototype.calcDir = function () {
+	this.average = calcAverage(this.total, this.elems.length);
+	if (this.forceup) {
+		this.stemsUp = true;
+	} else if (this.forcedown) {
+		this.stemsUp = false;
+	} else {
+		var middleLine = 6;	// hardcoded 6 is B
+		this.stemsUp = this.average < middleLine; // true is up, false is down;
+	}
+	var dir = this.stemsUp ? 'up' : 'down';
+	for (var i = 0; i < this.elems.length; i++) {
+		for (var j = 0; j < this.elems[i].heads.length; j++) {
+			this.elems[i].heads[j].stemDir = dir;
+		}
+	}
+};
+
+function calcAverage(total, numElements) {
+	if (!numElements)
+		return 0;
+	return total / numElements;
+}
+
+module.exports = BeamElem;

package/src/write/{bottom-text.js → creation/elements/bottom-text.js}

@@ -1,4 +1,4 @@
-const addTextIf = require("./add-text-if");
+const addTextIf = require("../add-text-if");
 
 function BottomText(metaText, width, isPrint, paddingLeft, spacing, getTextSize) {
 	this.rows = [];
@@ -10,19 +10,18 @@ function BottomText(metaText, width, isPrint, paddingLeft, spacing, getTextSize)
 }
 
 BottomText.prototype.unalignedWords = function (unalignedWords, paddingLeft, spacing, getTextSize) {
-	var indent = 50;
 	var klass = 'meta-bottom unaligned-words';
 	var defFont = 'wordsfont';
-	this.rows.push({startGroup: "unalignedWords", klass: 'abcjs-meta-bottom abcjs-unaligned-words', name: "words"});
+	this.rows.push({ startGroup: "unalignedWords", klass: 'abcjs-meta-bottom abcjs-unaligned-words', name: "words" });
 	var space = getTextSize.calc("i", defFont, klass);
 
-	this.rows.push({move: spacing.words});
+	this.rows.push({ move: spacing.words });
 
 	for (var j = 0; j < unalignedWords.length; j++) {
 		if (unalignedWords[j] === '')
-			this.rows.push({move: space.height});
+			this.rows.push({ move: space.height });
 		else if (typeof unalignedWords[j] === 'string') {
-			addTextIf(this.rows, { marginLeft: paddingLeft + indent, text: unalignedWords[j], font: defFont, klass: klass, inGroup: true, name: "words"}, getTextSize);
+			addTextIf(this.rows, { marginLeft: paddingLeft, text: unalignedWords[j], font: defFont, klass: klass, inGroup: true, name: "words" }, getTextSize);
 		} else {
 			var largestY = 0;
 			var offsetX = 0;
@@ -30,7 +29,7 @@ BottomText.prototype.unalignedWords = function (unalignedWords, paddingLeft, spa
 				var thisWord = unalignedWords[j][k];
 				var font = (thisWord.font) ? thisWord.font : defFont;
 				this.rows.push({
-					left: paddingLeft + indent + offsetX,
+					left: paddingLeft + offsetX,
 					text: thisWord.text,
 					font: font,
 					anchor: 'start'
@@ -43,11 +42,11 @@ BottomText.prototype.unalignedWords = function (unalignedWords, paddingLeft, spa
 					offsetX += space.width;
 				}
 			}
-			this.rows.push({move: largestY});
+			this.rows.push({ move: largestY });
 		}
 	}
-	this.rows.push({move: space.height * 2});
-	this.rows.push({endGroup: "unalignedWords", absElemType: "unalignedWords", startChar: -1, endChar: -1, name: "unalignedWords"});
+	this.rows.push({ move: space.height * 2 });
+	this.rows.push({ endGroup: "unalignedWords", absElemType: "unalignedWords", startChar: -1, endChar: -1, name: "unalignedWords" });
 }
 
 BottomText.prototype.extraText = function (metaText, marginLeft, spacing, getTextSize) {
@@ -62,18 +61,18 @@ BottomText.prototype.extraText = function (metaText, marginLeft, spacing, getTex
 	if (metaText['abc-creator']) extraText += "Creator: " + metaText['abc-creator'] + "\n";
 	if (metaText['abc-edited-by']) extraText += "Edited By: " + metaText['abc-edited-by'] + "\n";
 	if (extraText.length > 0) {
-			addTextIf(this.rows, { marginLeft: marginLeft, text: extraText, font: 'historyfont', klass: 'meta-bottom extra-text', marginTop: spacing.info, absElemType: "extraText", name: "description"}, getTextSize);
+		addTextIf(this.rows, { marginLeft: marginLeft, text: extraText, font: 'historyfont', klass: 'meta-bottom extra-text', marginTop: spacing.info, absElemType: "extraText", name: "description" }, getTextSize);
 	}
 }
 
 BottomText.prototype.footer = function (footer, width, paddingLeft, getTextSize) {
 	var klass = 'header meta-bottom';
 	var font = "footerfont";
-	this.rows.push({startGroup: "footer", klass: klass});
+	this.rows.push({ startGroup: "footer", klass: klass });
 	// Note: whether there is a footer or not doesn't change any other positioning, so this doesn't change the Y-coordinate.
-	addTextIf(this.rows, { marginLeft: paddingLeft, text: footer.left, font: font, klass: klass, name: "footer"}, getTextSize);
-	addTextIf(this.rows, { marginLeft: paddingLeft + width / 2, text: footer.center, font: font, klass: klass, anchor: 'middle', name: "footer"} , getTextSize);
-	addTextIf(this.rows, { marginLeft: paddingLeft + width, text: footer.right, font: font, klass: klass, anchor: 'end', name: "footer"}, getTextSize);
+	addTextIf(this.rows, { marginLeft: paddingLeft, text: footer.left, font: font, klass: klass, name: "footer" }, getTextSize);
+	addTextIf(this.rows, { marginLeft: paddingLeft + width / 2, text: footer.center, font: font, klass: klass, anchor: 'middle', name: "footer" }, getTextSize);
+	addTextIf(this.rows, { marginLeft: paddingLeft + width, text: footer.right, font: font, klass: klass, anchor: 'end', name: "footer" }, getTextSize);
 }
 
 module.exports = BottomText;

package/src/write/{abc_brace_element.js → creation/elements/brace-element.js}

@@ -1,11 +1,11 @@
 //    abc_brace_element.js: Definition of the BraceElement class.
 
 var BraceElem = function BraceElem(voice, type) {
-    this.startVoice = voice;
-    this.type = type;
+	this.startVoice = voice;
+	this.type = type;
 };
 
-BraceElem.prototype.setBottomStaff = function(voice) {
+BraceElem.prototype.setBottomStaff = function (voice) {
 	this.endVoice = voice;
 	// If only the start brace has a name then the name belongs to the brace instead of the staff.
 	if (this.startVoice.header && !this.endVoice.header) {
@@ -14,12 +14,12 @@ BraceElem.prototype.setBottomStaff = function(voice) {
 	}
 };
 
-BraceElem.prototype.continuing = function(voice) {
+BraceElem.prototype.continuing = function (voice) {
 	// If the final staff isn't present, then use the last one we saw.
 	this.lastContinuedVoice = voice;
 };
 
-BraceElem.prototype.getWidth = function() {
+BraceElem.prototype.getWidth = function () {
 	return 10; // TODO-PER: right now the drawing function doesn't vary the width at all. If it does in the future then this will change.
 };