abcjs 6.0.2 → 6.1.0

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.2",
+  "version": "6.1.0",
   "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/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_header.js

@@ -364,7 +364,7 @@ var ParseHeader = function(tokenizer, warn, multilineVars, tune, tuneBuilder) {
 						multilineVars.meter = meter;
 					return [ e-i+1+ws ];
 				case "[K:":
-					var result = parseKeyVoice.parseKey(line.substring(i+3, e));
+					var result = parseKeyVoice.parseKey(line.substring(i+3, e), true);
 					if (result.foundClef && tuneBuilder.hasBeginMusic())
 						tuneBuilder.appendStartingElement('clef', startChar, endChar, multilineVars.clef);
 					if (result.foundKey && tuneBuilder.hasBeginMusic())
@@ -426,7 +426,7 @@ var ParseHeader = function(tokenizer, warn, multilineVars, tune, tuneBuilder) {
 						tuneBuilder.appendStartingElement('meter', multilineVars.iChar + i, multilineVars.iChar + line.length, meter);
 					return [ line.length ];
 				case "K:":
-					var result = parseKeyVoice.parseKey(line.substring(i+2));
+					var result = parseKeyVoice.parseKey(line.substring(i+2), tuneBuilder.hasBeginMusic());
 					if (result.foundClef && tuneBuilder.hasBeginMusic())
 						tuneBuilder.appendStartingElement('clef', multilineVars.iChar + i, multilineVars.iChar + line.length, multilineVars.clef);
 					if (result.foundKey && tuneBuilder.hasBeginMusic())
@@ -498,7 +498,7 @@ var ParseHeader = function(tokenizer, warn, multilineVars, tune, tuneBuilder) {
 				case  'K':
 					// since the key is the last thing that can happen in the header, we can resolve the tempo now
 					this.resolveTempo();
-					var result = parseKeyVoice.parseKey(line.substring(2));
+					var result = parseKeyVoice.parseKey(line.substring(2), false);
 					if (!multilineVars.is_in_header && tuneBuilder.hasBeginMusic()) {
 						if (result.foundClef)
 							tuneBuilder.appendStartingElement('clef', startChar, endChar, multilineVars.clef);

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 = {
@@ -340,7 +193,7 @@ var parseKeyVoice = {};
 		}
 	};
 
-	parseKeyVoice.parseKey = function(str)	// (and clef)
+	parseKeyVoice.parseKey = function(str, isInline)	// (and clef)
 	{
 		// returns:
 		//		{ foundClef: true, foundKey: true }
@@ -431,8 +284,14 @@ var parseKeyVoice = {};
 					// We need to do a deep copy because we are going to modify it
 					var oldKey = parseKeyVoice.deepCopyKey(multilineVars.key);
 					//TODO-PER: HACK! To get the local transpose to work, the transposition is done for each line. This caused the global transposition variable to be factored in twice, so, instead of rewriting that right now, I'm just subtracting one of them here.
-					var keyCompensate = multilineVars.globalTranspose ? -multilineVars.globalTranspose : 0;
+					var keyCompensate = !isInline && multilineVars.globalTranspose ? -multilineVars.globalTranspose : 0;
+					//console.log("parse", JSON.stringify(multilineVars), isInline)
+					var savedOrigKey;
+					if (isInline)
+						savedOrigKey = multilineVars.globalTransposeOrigKeySig
 					multilineVars.key = parseKeyVoice.deepCopyKey(parseKeyVoice.standardKey(key, retPitch.token, acc, keyCompensate));
+					if (isInline)
+						multilineVars.globalTransposeOrigKeySig = savedOrigKey
 					multilineVars.key.mode = mode;
 					if (oldKey) {
 						// Add natural in all places that the old key had an accidental.

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_tokenizer.js

@@ -702,18 +702,15 @@ var Tokenizer = function(lines, multilineVars) {
 		}
 		switch (x.token) {
 			case 'pt': return { used: used+1, value: parseFloat(num) };
+			case 'px': return { used: used+1, value: parseFloat(num) };
 			case 'cm': return { used: used+1, value: parseFloat(num)/2.54*72 };
 			case 'in': return { used: used+1, value: parseFloat(num)*72 };
 			default: tokens.unshift(x); return { used: used, value: parseFloat(num) };
 		}
-		return { used: 0 };
 	};
-	var substInChord = function(str)
-	{
-		while ( str.indexOf("\\n") !== -1)
-		{
-			str = str.replace("\\n", "\n");
-		}
+	var substInChord = function(str) {
+		str = str.replace(/\\n/g, "\n");
+		str = str.replace(/\\"/g, '"');
 		return str;
 	};
 	this.getBrackettedSubstring = function(line, i, maxErrorChars, _matchChar)
@@ -728,8 +725,11 @@ var Tokenizer = function(lines, multilineVars) {
 		// but in the error case it might not be.
 		var matchChar = _matchChar || line.charAt(i);
 		var pos = i+1;
-		while ((pos < line.length) && (line.charAt(pos) !== matchChar))
+		var esc = false;
+		while ((pos < line.length) && (esc || line[pos] !== matchChar)) {
+			esc = line[pos] === '\\';
 			++pos;
+		}
 		if (line.charAt(pos) === matchChar)
 			return [pos-i+1,substInChord(line.substring(i+1, pos)), true];
 		else	// we hit the end of line, so we'll just pick an arbitrary num of chars so the line doesn't disappear.