abcjs 6.0.3 → 6.1.1

package/index.js

@@ -25,6 +25,7 @@ var version = require('./version');
 var animation = require('./src/api/abc_animation');
 var tuneBook = require('./src/api/abc_tunebook');
 var sequence = require('./src/synth/abc_midi_sequencer');
+var strTranspose = require('./src/str/output');
 
 var abcjs = {};
 
@@ -43,6 +44,7 @@ abcjs.TimingCallbacks = require('./src/api/abc_timing_callbacks');
 
 var glyphs = require('./src/write/abc_glyphs');
 abcjs.setGlyph = glyphs.setSymbol;
+abcjs.strTranspose = strTranspose;
 
 var CreateSynth = require('./src/synth/create-synth');
 var instrumentIndexToName = require('./src/synth/instrument-index-to-name');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abcjs",
-  "version": "6.0.3",
+  "version": "6.1.1",
   "description": "Renderer for abc music notation",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -10,7 +10,7 @@
     "build:basic": "npm run webpack -- --mode development --config-name basic",
     "build:basic-min": "npm run webpack -- --mode production --config-name basic",
     "build:plugin": "npm run webpack -- --mode production --config-name plugin",
-    "test": "mocha 'tests/**/*.js'",
+    "test": "echo 'To run tests, open the file tests/all.html in a browser.'",
     "docs:dev": "vuepress dev docs",
     "docs:build": "vuepress build docs",
     "build:analyze": "npm run build:basic -- --env analyze"

package/src/api/abc_tunebook_svg.js

@@ -59,96 +59,6 @@ function renderOne(div, tune, params, tuneNumber, lineOffset) {
     }
 }
 
-function renderEachLineSeparately(div, tune, params, tuneNumber) {
-    function initializeTuneLine(tune) {
-        var obj = new Tune();
-        obj.formatting = tune.formatting;
-        obj.media = tune.media;
-        obj.version = tune.version;
-        return obj;
-    }
-
-    // Before rendering, chop up the returned tune into an array where each element is a line.
-    // The first element of the array gets the title and other items that go on top, the last element
-    // of the array gets the extra text that goes on bottom. Each element gets any non-music info that comes before it.
-    var tunes = [];
-    var tuneLine;
-    for (var i = 0; i < tune.lines.length; i++) {
-        var line = tune.lines[i];
-        if (!tuneLine)
-            tuneLine = initializeTuneLine(tune);
-
-        if (i === 0) {
-            // These items go on top of the music
-            tuneLine.copyTopInfo(tune);
-        }
-
-        // push the lines until we get to a music line
-        tuneLine.lines.push(line);
-        if (line.staff) {
-            tunes.push(tuneLine);
-            tuneLine = undefined;
-        }
-    }
-    // Add any extra stuff to the last line.
-    if (tuneLine) {
-        var lastLine = tunes[tunes.length-1];
-        for (var j = 0; j < tuneLine.lines.length; j++)
-            lastLine.lines.push(tuneLine.lines[j]);
-    }
-
-    // These items go below the music
-    tuneLine = tunes[tunes.length-1];
-    tuneLine.copyBottomInfo(tune);
-
-    // Now create sub-divs and render each line. Need to copy the params to change the padding for the interior slices.
-    var ep = {};
-    for (var key in params) {
-        if (params.hasOwnProperty(key)) {
-            ep[key] = params[key];
-        }
-    }
-    var origPaddingTop = ep.paddingtop;
-    var origPaddingBottom = ep.paddingbottom;
-    var currentScrollY = div.parentNode.scrollTop; // If there is scrolling it will be lost during the redraw so remember it.
-    var currentScrollX = div.parentNode.scrollLeft;
-    div.innerHTML = "";
-    var lineCount = 0;
-    for (var k = 0; k < tunes.length; k++) {
-        var lineEl = document.createElement("div");
-        div.appendChild(lineEl);
-
-        if (k === 0) {
-	        ep.paddingtop = origPaddingTop;
-	        ep.paddingbottom = 0;
-        } else if (k === tunes.length-1) {
-	        ep.paddingtop = 10;
-	        ep.paddingbottom = origPaddingBottom;
-        } else {
-	        ep.paddingtop = 10;
-	        ep.paddingbottom = 0;
-        }
-        if (k < tunes.length-1) {
-            // If it is not the last line, force stretchlast. If it is, stretchlast might have been set by the input parameters.
-            tunes[k].formatting = parseCommon.clone(tunes[k].formatting);
-            tunes[k].formatting.stretchlast = true;
-        }
-        renderOne(lineEl, tunes[k], ep, tuneNumber, lineCount);
-        lineCount += tunes[k].lines.length;
-        if (k === 0)
-            tune.engraver = tunes[k].engraver;
-        else {
-            if (!tune.engraver.staffgroups)
-                tune.engraver.staffgroups = tunes[k].engraver.staffgroups;
-            else if (tunes[k].engraver.staffgroups.length > 0)
-                tune.engraver.staffgroups.push(tunes[k].engraver.staffgroups[0]);
-        }
-    }
-    if (currentScrollX || currentScrollY) {
-        div.parentNode.scrollTo(currentScrollX, currentScrollY);
-    }
-}
-
 // A quick way to render a tune from javascript when interactivity is not required.
 // This is used when a javascript routine has some abc text that it wants to render
 // in a div or collection of divs. One tune or many can be rendered.
@@ -214,10 +124,7 @@ var renderAbc = function(output, abc, parserParams, engraverParams, renderParams
 	        tune = doLineWrapping(div, tune, tuneNumber, abcString, params);
 	        return tune;
         }
-        else if (removeDiv || !params.oneSvgPerLine || tune.lines.length < 2)
-            renderOne(div, tune, params, tuneNumber, 0);
-        else
-            renderEachLineSeparately(div, tune, params, tuneNumber);
+        renderOne(div, tune, params, tuneNumber, 0);
         if (removeDiv)
             div.parentNode.removeChild(div);
         return null;
@@ -239,10 +146,7 @@ function doLineWrapping(div, tune, tuneNumber, abcString, params) {
         if (warnings)
             tune.warnings = warnings;
     }
-    if (!params.oneSvgPerLine || tune.lines.length < 2)
-        renderOne(div, tune, ret.revisedParams, tuneNumber, 0);
-    else
-        renderEachLineSeparately(div, tune, ret.revisedParams, tuneNumber);
+    renderOne(div, tune, ret.revisedParams, tuneNumber, 0);
 	tune.explanation = ret.explanation;
 	return tune;
 }

package/src/const/key-accidentals.js

@@ -0,0 +1,53 @@
+var { relativeMajor } = require("./relative-major");
+
+var key1sharp = { acc: 'sharp', note: 'f' };
+var key2sharp = { acc: 'sharp', note: 'c' };
+var key3sharp = { acc: 'sharp', note: 'g' };
+var key4sharp = { acc: 'sharp', note: 'd' };
+var key5sharp = { acc: 'sharp', note: 'A' };
+var key6sharp = { acc: 'sharp', note: 'e' };
+var key7sharp = { acc: 'sharp', note: 'B' };
+var key1flat = { acc: 'flat', note: 'B' };
+var key2flat = { acc: 'flat', note: 'e' };
+var key3flat = { acc: 'flat', note: 'A' };
+var key4flat = { acc: 'flat', note: 'd' };
+var key5flat = { acc: 'flat', note: 'G' };
+var key6flat = { acc: 'flat', note: 'c' };
+var key7flat = { acc: 'flat', note: 'F' };
+
+var keys = {
+	'C#': [key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp],
+	'F#': [key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp],
+	'B': [key1sharp, key2sharp, key3sharp, key4sharp, key5sharp],
+	'E': [key1sharp, key2sharp, key3sharp, key4sharp],
+	'A': [key1sharp, key2sharp, key3sharp],
+	'D': [key1sharp, key2sharp],
+	'G': [key1sharp],
+	'C': [],
+	'F': [key1flat],
+	'Bb': [key1flat, key2flat],
+	'Eb': [key1flat, key2flat, key3flat],
+	'Cm': [key1flat, key2flat, key3flat],
+	'Ab': [key1flat, key2flat, key3flat, key4flat],
+	'Db': [key1flat, key2flat, key3flat, key4flat, key5flat],
+	'Gb': [key1flat, key2flat, key3flat, key4flat, key5flat, key6flat],
+	'Cb': [key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat],
+
+	// The following are not in the 2.0 spec, but seem normal enough.
+	// TODO-PER: These SOUND the same as what's written, but they aren't right
+	'A#': [key1flat, key2flat],
+	'B#': [],
+	'D#': [key1flat, key2flat, key3flat],
+	'E#': [key1flat],
+	'G#': [key1flat, key2flat, key3flat, key4flat],
+	'none': [],
+};
+
+function keyAccidentals(key) {
+	var newKey = keys[relativeMajor(key)]
+	if (!newKey) // If we don't recognize the key then there is no change
+		return null
+	return JSON.parse(JSON.stringify(newKey))
+};
+
+module.exports = keyAccidentals;

package/src/const/relative-major.js

@@ -0,0 +1,92 @@
+// All these keys have the same number of accidentals
+var keys = {
+	'C': { modes: ['CMaj', 'Amin', 'Am', 'GMix', 'DDor', 'EPhr', 'FLyd', 'BLoc'], stepsFromC: 0 },
+	'Db': { modes: ['DbMaj', 'Bbmin', 'Bbm', 'AbMix', 'EbDor', 'FPhr', 'GbLyd', 'CLoc'], stepsFromC: 1 },
+	'D': { modes: ['DMaj', 'Bmin', 'Bm', 'AMix', 'EDor', 'F#Phr', 'GLyd', 'C#Loc'], stepsFromC: 2 },
+	'Eb': { modes: ['EbMaj', 'Cmin', 'Cm', 'BbMix', 'FDor', 'GPhr', 'AbLyd', 'DLoc'], stepsFromC: 3 },
+	'E': { modes: ['EMaj', 'C#min', 'C#m', 'BMix', 'F#Dor', 'G#Phr', 'ALyd', 'D#Loc'], stepsFromC: 4 },
+	'F': { modes: ['FMaj', 'Dmin', 'Dm', 'CMix', 'GDor', 'APhr', 'BbLyd', 'ELoc'], stepsFromC: 5 },
+	'Gb': { modes: ['GbMaj', 'Ebmin', 'Ebm', 'DbMix', 'AbDor', 'BbPhr', 'CbLyd', 'FLoc'], stepsFromC: 6 },
+	'G': { modes: ['GMaj', 'Emin', 'Em', 'DMix', 'ADor', 'BPhr', 'CLyd', 'F#Loc'], stepsFromC: 7 },
+	'Ab': { modes: ['AbMaj', 'Fmin', 'Fm', 'EbMix', 'BbDor', 'CPhr', 'DbLyd', 'GLoc'], stepsFromC: 8 },
+	'A': { modes: ['AMaj', 'F#min', 'F#m', 'EMix', 'BDor', 'C#Phr', 'DLyd', 'G#Loc'], stepsFromC: 9 },
+	'Bb': { modes: ['BbMaj', 'Gmin', 'Gm', 'FMix', 'CDor', 'DPhr', 'EbLyd', 'ALoc'], stepsFromC: 10 },
+	'B': { modes: ['BMaj', 'G#min', 'G#m', 'F#Mix', 'C#Dor', 'D#Phr', 'ELyd', 'A#Loc'], stepsFromC: 11 },
+	// Enharmonic keys
+	'C#': { modes: ['C#Maj', 'A#min', 'A#m', 'G#Mix', 'D#Dor', 'E#Phr', 'F#Lyd', 'B#Loc'], stepsFromC: 1 },
+	'F#': { modes: ['F#Maj', 'D#min', 'D#m', 'C#Mix', 'G#Dor', 'A#Phr', 'BLyd', 'E#Loc'], stepsFromC: 6 },
+	'Cb': { modes: ['CbMaj', 'Abmin', 'Abm', 'GbMix', 'DbDor', 'EbPhr', 'FbLyd', 'BbLoc'], stepsFromC: 11 },
+}
+
+var keyReverse = null
+
+function createKeyReverse() {
+	keyReverse = {}
+	var allKeys = Object.keys(keys)
+	for (var i = 0 ; i < allKeys.length; i++) {
+		var keyObj = keys[allKeys[i]]
+		keyReverse[allKeys[i].toLowerCase()] = allKeys[i];
+		for (var j = 0; j < keyObj.modes.length; j++) {
+			var mode = keyObj.modes[j].toLowerCase()
+			keyReverse[mode] = allKeys[i];
+		}
+	}
+}
+
+function relativeMajor(key) {
+	// Translate a key to its relative major. If it doesn't exist, do the best we can
+	// by just returning the original key.
+	// There are alternate spellings of these - so the search needs to be case insensitive.
+	// To make this efficient, the first time this is called the "keys" object is reversed so this search is fast in the future
+	if (!keyReverse) {
+		createKeyReverse()
+	}
+	// get the key portion itself - there might be other stuff, like extra sharps and flats, or the mode written out.
+	var mode = key.toLowerCase().match(/([a-g][b#]?)(maj|min|mix|dor|phr|lyd|loc|m)?/)
+	if (!mode || !mode[2])
+		return key;
+	mode = mode[1] + mode[2]
+	var maj = keyReverse[mode]
+	if (maj)
+		return maj;
+	return key;
+}
+
+function relativeMode(majorKey, mode) {
+	// The reverse of the relativeMajor. Translate it back to the original mode.
+	// If it isn't a recognized mode or it is already major, then just return the major key.
+	var group = keys[majorKey]
+	if (!group)
+		return majorKey;
+	if (mode === '')
+		return majorKey;
+	var match = mode.toLowerCase().match(/^(maj|min|mix|dor|phr|lyd|loc|m)/)	
+	if (!match)
+		return majorKey
+	var regMode = match[1]	
+	for (var i = 0; i < group.modes.length; i++) {
+		var thisMode = group.modes[i]
+		var ind = thisMode.toLowerCase().indexOf(regMode)
+		if (ind !== -1 && ind === thisMode.length - regMode.length)
+			return thisMode.substring(0, thisMode.length - regMode.length)
+	}
+	return majorKey;
+}
+
+function transposeKey(key, steps) {
+	// This takes a major key and adds the desired steps.
+	// It assigns each key a number that is the number of steps from C so that there can just be arithmetic.
+	var match = keys[key]
+	if (!match)
+		return key;
+	while (steps < 0) steps += 12;
+	var fromC = (match.stepsFromC + steps) % 12;
+	for (var i = 0;  i < Object.keys(keys).length; i++) {
+		var k = Object.keys(keys)[i]
+		if (keys[k].stepsFromC === fromC)
+			return k;
+	}
+	return key;
+}
+
+module.exports = {relativeMajor: relativeMajor, relativeMode: relativeMode, transposeKey: transposeKey};

package/src/parse/abc_parse.js

@@ -224,6 +224,7 @@ var Parse = function() {
 		var replace = false;
 		var addWord = function(i) {
 			var word = parseCommon.strip(words.substring(last_divider, i));
+			word = word.replace(/\\([-_*|~])/g, '$1')
 			last_divider = i+1;
 			if (word.length > 0) {
 				if (replace)
@@ -237,34 +238,44 @@ var Parse = function() {
 			}
 			return false;
 		};
+		var escNext = false;
 		for (var i = 0; i < words.length; i++) {
-			switch (words.charAt(i)) {
+			switch (words[i]) {
 				case ' ':
 				case '\x12':
 					addWord(i);
 					break;
 				case '-':
-					if (!addWord(i) && word_list.length > 0) {
+					if (!escNext && !addWord(i) && word_list.length > 0) {
 						parseCommon.last(word_list).divider = '-';
 						word_list.push({skip: true, to: 'next'});
 					}
 					break;
 				case '_':
-					addWord(i);
-					word_list.push({skip: true, to: 'slur'});
+					if (!escNext) {
+						addWord(i);
+						word_list.push({skip: true, to: 'slur'});
+					}
 					break;
 				case '*':
-					addWord(i);
-					word_list.push({skip: true, to: 'next'});
+					if (!escNext) {
+						addWord(i);
+						word_list.push({skip: true, to: 'next'});
+					}
 					break;
 				case '|':
-					addWord(i);
-					word_list.push({skip: true, to: 'bar'});
+					if (!escNext) {
+						addWord(i);
+						word_list.push({skip: true, to: 'bar'});
+					}
 					break;
 				case '~':
-					replace = true;
+					if (!escNext) {
+						replace = true;
+					}
 					break;
 			}
+			escNext = words[i] === '\\'
 		}
 
 		var inSlur = false;

package/src/parse/abc_parse_book.js

@@ -6,13 +6,14 @@ var bookParser = function(book) {
 	"use strict";
 
 	var directives = "";
+	var initialWhiteSpace = book.match(/(\s*)/)
 	book = parseCommon.strip(book);
 	var tuneStrings = book.split("\nX:");
 	// Put back the X: that we lost when splitting the tunes.
 	for (var i = 1; i < tuneStrings.length; i++)
 		tuneStrings[i] = "X:" + tuneStrings[i];
-	// Keep track of the character position each tune starts with.
-	var pos = 0;
+	// Keep track of the character position each tune starts with. If the string starts with white space, count that, too.
+	var pos = initialWhiteSpace ? initialWhiteSpace[0].length : 0;
 	var tunes = [];
 	parseCommon.each(tuneStrings, function(tune) {
 		tunes.push({ abc: tune, startPos: pos});

package/src/parse/abc_parse_key_voice.js

@@ -19,154 +19,7 @@ var parseKeyVoice = {};
 	};
 
 	parseKeyVoice.standardKey = function(keyName, root, acc, localTranspose) {
-		var key1sharp = {acc: 'sharp', note: 'f'};
-		var key2sharp = {acc: 'sharp', note: 'c'};
-		var key3sharp = {acc: 'sharp', note: 'g'};
-		var key4sharp = {acc: 'sharp', note: 'd'};
-		var key5sharp = {acc: 'sharp', note: 'A'};
-		var key6sharp = {acc: 'sharp', note: 'e'};
-		var key7sharp = {acc: 'sharp', note: 'B'};
-		var key1flat = {acc: 'flat', note: 'B'};
-		var key2flat = {acc: 'flat', note: 'e'};
-		var key3flat = {acc: 'flat', note: 'A'};
-		var key4flat = {acc: 'flat', note: 'd'};
-		var key5flat = {acc: 'flat', note: 'G'};
-		var key6flat = {acc: 'flat', note: 'c'};
-		var key7flat = {acc: 'flat', note: 'F'};
-
-		var keys = {
-			'C#': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'A#m': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'G#Mix': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'D#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'E#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'F#Lyd': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'B#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-
-			'F#': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-			'D#m': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-			'C#Mix': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-			'G#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-			'A#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-			'BLyd': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-			'E#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
-
-			'B': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-			'G#m': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-			'F#Mix': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-			'C#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-			'D#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-			'ELyd': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-			'A#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
-
-			'E': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-			'C#m': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-			'BMix': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-			'F#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-			'G#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-			'ALyd': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-			'D#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp ],
-
-			'A': [ key1sharp, key2sharp, key3sharp ],
-			'F#m': [ key1sharp, key2sharp, key3sharp ],
-			'EMix': [ key1sharp, key2sharp, key3sharp ],
-			'BDor': [ key1sharp, key2sharp, key3sharp ],
-			'C#Phr': [ key1sharp, key2sharp, key3sharp ],
-			'DLyd': [ key1sharp, key2sharp, key3sharp ],
-			'G#Loc': [ key1sharp, key2sharp, key3sharp ],
-
-			'D': [ key1sharp, key2sharp ],
-			'Bm': [ key1sharp, key2sharp ],
-			'AMix': [ key1sharp, key2sharp ],
-			'EDor': [ key1sharp, key2sharp ],
-			'F#Phr': [ key1sharp, key2sharp ],
-			'GLyd': [ key1sharp, key2sharp ],
-			'C#Loc': [ key1sharp, key2sharp ],
-
-			'G': [ key1sharp ],
-			'Em': [ key1sharp ],
-			'DMix': [ key1sharp ],
-			'ADor': [ key1sharp ],
-			'BPhr': [ key1sharp ],
-			'CLyd': [ key1sharp ],
-			'F#Loc': [ key1sharp ],
-
-			'C': [],
-			'Am': [],
-			'GMix': [],
-			'DDor': [],
-			'EPhr': [],
-			'FLyd': [],
-			'BLoc': [],
-
-			'F': [ key1flat ],
-			'Dm': [ key1flat ],
-			'CMix': [ key1flat ],
-			'GDor': [ key1flat ],
-			'APhr': [ key1flat ],
-			'BbLyd': [ key1flat ],
-			'ELoc': [ key1flat ],
-
-			'Bb': [ key1flat, key2flat ],
-			'Gm': [ key1flat, key2flat ],
-			'FMix': [ key1flat, key2flat ],
-			'CDor': [ key1flat, key2flat ],
-			'DPhr': [ key1flat, key2flat ],
-			'EbLyd': [ key1flat, key2flat ],
-			'ALoc': [ key1flat, key2flat ],
-
-			'Eb': [ key1flat, key2flat, key3flat ],
-			'Cm': [ key1flat, key2flat, key3flat ],
-			'BbMix': [ key1flat, key2flat, key3flat ],
-			'FDor': [ key1flat, key2flat, key3flat ],
-			'GPhr': [ key1flat, key2flat, key3flat ],
-			'AbLyd': [ key1flat, key2flat, key3flat ],
-			'DLoc': [ key1flat, key2flat, key3flat ],
-
-			'Ab': [ key1flat, key2flat, key3flat, key4flat ],
-			'Fm': [ key1flat, key2flat, key3flat, key4flat ],
-			'EbMix': [ key1flat, key2flat, key3flat, key4flat ],
-			'BbDor': [ key1flat, key2flat, key3flat, key4flat ],
-			'CPhr': [ key1flat, key2flat, key3flat, key4flat ],
-			'DbLyd': [ key1flat, key2flat, key3flat, key4flat ],
-			'GLoc': [ key1flat, key2flat, key3flat, key4flat ],
-
-			'Db': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-			'Bbm': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-			'AbMix': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-			'EbDor': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-			'FPhr': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-			'GbLyd': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-			'CLoc': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
-
-			'Gb': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-			'Ebm': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-			'DbMix': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-			'AbDor': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-			'BbPhr': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-			'CbLyd': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-			'FLoc': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
-
-			'Cb': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-			'Abm': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-			'GbMix': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-			'DbDor': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-			'EbPhr': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-			'FbLyd': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-			'BbLoc': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
-
-			// The following are not in the 2.0 spec, but seem normal enough.
-			// TODO-PER: These SOUND the same as what's written, but they aren't right
-			'A#': [ key1flat, key2flat ],
-			'B#': [],
-			'D#': [ key1flat, key2flat, key3flat ],
-			'E#': [ key1flat ],
-			'G#': [ key1flat, key2flat, key3flat, key4flat ],
-			'Gbm': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
-			'none': []
-		};
-
-		return transpose.keySignature(multilineVars, keys, keyName, root, acc, localTranspose);
+		return transpose.keySignature(multilineVars, keyName, root, acc, localTranspose);
 	};
 
 	var clefLines = {

package/src/parse/abc_parse_music.js

@@ -289,7 +289,7 @@ MusicParser.prototype.parseMusic = function(line) {
 						}
 					}
 					multilineVars.addFormattingOptions(el, tune.formatting, 'bar');
-					tuneBuilder.appendElement('bar', startOfLine+i, startOfLine+i+ret[0], bar);
+					tuneBuilder.appendElement('bar', startOfLine+startI, startOfLine+i+ret[0], bar);
 					multilineVars.measureNotEmpty = false;
 					el = {};
 				}
@@ -732,7 +732,7 @@ var volumeDecorations = [
 ];
 
 var dynamicDecorations = [
-	"crescendo(", "crescendo)", "diminuendo(", "diminuendo)"
+	"crescendo(", "crescendo)", "diminuendo(", "diminuendo)", "glissando(", "glissando)"
 ];
 
 var accentPseudonyms = [

package/src/parse/abc_transpose.js

@@ -1,6 +1,8 @@
 //    abc_transpose.js: Handles the automatic transposition of key signatures, chord symbols, and notes.
 
-const allNotes = require("./all-notes");
+var allNotes = require("./all-notes");
+var transposeChordName = require("../parse/transpose-chord")
+var keyAccidentals = require('../const/key-accidentals');
 var transpose = {};
 
 var keyIndex = {
@@ -25,13 +27,13 @@ var keyIndex = {
 var newKey = ['C', 'Db', 'D', 'Eb', 'E', 'F', 'F#', 'G', 'Ab', 'A', 'Bb', 'B'];
 var newKeyMinor = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'Bb', 'B'];
 
-transpose.keySignature = function(multilineVars, keys, keyName, root, acc, localTranspose) {
-	if (multilineVars.clef.type === "perc")
-		return { accidentals: keys[keyName], root: root, acc: acc };
+transpose.keySignature = function(multilineVars, keyName, root, acc, localTranspose) {
+	if (multilineVars.clef.type === "perc" || multilineVars.clef.type === "none")
+		return { accidentals: keyAccidentals(keyName), root: root, acc: acc };
 	if (!localTranspose) localTranspose = 0;
 	multilineVars.localTransposeVerticalMovement = 0;
 	multilineVars.localTransposePreferFlats = false;
-	var k = keys[keyName];
+	var k = keyAccidentals(keyName);
 	if (!k) return multilineVars.key; // If the key isn't in the list, it is non-standard. We won't attempt to transpose it.
 	multilineVars.localTranspose = (multilineVars.globalTranspose ? multilineVars.globalTranspose : 0) + localTranspose;
 
@@ -54,7 +56,7 @@ transpose.keySignature = function(multilineVars, keys, keyName, root, acc, local
 	if (index > 11) index = index % 12;
 	var newKeyName = (keyName[0] === 'm' ? newKeyMinor[index] : newKey[index]);
 	var transposedKey = newKeyName + keyName;
-	var newKeySig = keys[transposedKey];
+	var newKeySig = keyAccidentals(transposedKey);
 	if (newKeySig.length > 0 && newKeySig[0].acc === 'flat')
 		multilineVars.localTransposePreferFlats = true;
 	var distance = transposedKey.charCodeAt(0) - baseKey.charCodeAt(0);
@@ -88,69 +90,8 @@ transpose.keySignature = function(multilineVars, keys, keyName, root, acc, local
 	return { accidentals: newKeySig, root: newKeyName[0], acc: newKeyName.length > 1 ? newKeyName[1] : "" };
 };
 
-var sharpChords = [ 'C', 'C♯', 'D', "D♯", 'E', 'F', "F♯", 'G', 'G♯', 'A', 'A♯', 'B'];
-var flatChords = [ 'C', 'D♭', 'D', 'E♭', 'E', 'F', 'G♭', 'G', 'A♭', 'A', 'B♭', 'B'];
-var sharpChordsFree = [ 'C', 'C#', 'D', "D#", 'E', 'F', "F#", 'G', 'G#', 'A', 'A#', 'B'];
-var flatChordsFree = [ 'C', 'Db', 'D', 'Eb', 'E', 'F', 'Gb', 'G', 'Ab', 'A', 'Bb', 'B'];
-
 transpose.chordName = function(multilineVars, chord) {
-	if (multilineVars.localTranspose && (multilineVars.localTranspose % 12 !== 0)) { // The chords are the same if it is an exact octave change.
-		var transposeFactor = multilineVars.localTranspose;
-		while (transposeFactor < 0) transposeFactor += 12;
-		if (transposeFactor > 11) transposeFactor = transposeFactor % 12;
-		if (multilineVars.freegchord) {
-			chord = chord.replace(/Cb/g, "`~11`");
-			chord = chord.replace(/Db/g, "`~1`");
-			chord = chord.replace(/Eb/g, "`~3`");
-			chord = chord.replace(/Fb/g, "`~4`");
-			chord = chord.replace(/Gb/g, "`~6`");
-			chord = chord.replace(/Ab/g, "`~8`");
-			chord = chord.replace(/Bb/g, "`~10`");
-			chord = chord.replace(/C#/g, "`~1`");
-			chord = chord.replace(/D#/g, "`~3`");
-			chord = chord.replace(/E#/g, "`~5`");
-			chord = chord.replace(/F#/g, "`~6`");
-			chord = chord.replace(/G#/g, "`~8`");
-			chord = chord.replace(/A#/g, "`~10`");
-			chord = chord.replace(/B#/g, "`~0`");
-		} else {
-			chord = chord.replace(/C♭/g, "`~11`");
-			chord = chord.replace(/D♭/g, "`~1`");
-			chord = chord.replace(/E♭/g, "`~3`");
-			chord = chord.replace(/F♭/g, "`~4`");
-			chord = chord.replace(/G♭/g, "`~6`");
-			chord = chord.replace(/A♭/g, "`~8`");
-			chord = chord.replace(/B♭/g, "`~10`");
-			chord = chord.replace(/C♯/g, "`~1`");
-			chord = chord.replace(/D♯/g, "`~3`");
-			chord = chord.replace(/E♯/g, "`~5`");
-			chord = chord.replace(/F♯/g, "`~6`");
-			chord = chord.replace(/G♯/g, "`~8`");
-			chord = chord.replace(/A♯/g, "`~10`");
-			chord = chord.replace(/B♯/g, "`~0`");
-		}
-		chord = chord.replace(/C/g, "`~0`");
-		chord = chord.replace(/D/g, "`~2`");
-		chord = chord.replace(/E/g, "`~4`");
-		chord = chord.replace(/F/g, "`~5`");
-		chord = chord.replace(/G/g, "`~7`");
-		chord = chord.replace(/A/g, "`~9`");
-		chord = chord.replace(/B/g, "`~11`");
-		var arr = chord.split("`");
-		for (var i = 0; i < arr.length; i++) {
-			if (arr[i][0] === '~') {
-				var chordNum = parseInt(arr[i].substr(1),10);
-				chordNum += transposeFactor;
-				if (chordNum > 11) chordNum -= 12;
-				if (multilineVars.freegchord)
-					arr[i] = multilineVars.localTransposePreferFlats ? flatChordsFree[chordNum] : sharpChordsFree[chordNum];
-				else
-					arr[i] = multilineVars.localTransposePreferFlats ? flatChords[chordNum] : sharpChords[chordNum];
-			}
-		}
-		chord = arr.join("");
-	}
-	return chord;
+	return transposeChordName(chord, multilineVars.localTranspose, multilineVars.localTransposePreferFlats, multilineVars.freegchord)
 };
 
 var pitchToLetter = [ 'c', 'd', 'e', 'f', 'g', 'a', 'b' ];