abcjs 6.0.3 → 6.1.1

package/dist/abcjs-basic.js

@@ -48,6 +48,8 @@ var tuneBook = __webpack_require__(/*! ./src/api/abc_tunebook */ "./src/api/abc_
 
 var sequence = __webpack_require__(/*! ./src/synth/abc_midi_sequencer */ "./src/synth/abc_midi_sequencer.js");
 
+var strTranspose = __webpack_require__(/*! ./src/str/output */ "./src/str/output.js");
+
 var abcjs = {};
 abcjs.signature = "abcjs-basic v" + version;
 Object.keys(animation).forEach(function (key) {
@@ -62,6 +64,7 @@ abcjs.TimingCallbacks = __webpack_require__(/*! ./src/api/abc_timing_callbacks *
 var glyphs = __webpack_require__(/*! ./src/write/abc_glyphs */ "./src/write/abc_glyphs.js");
 
 abcjs.setGlyph = glyphs.setSymbol;
+abcjs.strTranspose = strTranspose;
 
 var CreateSynth = __webpack_require__(/*! ./src/synth/create-synth */ "./src/synth/create-synth.js");
 
@@ -1098,101 +1101,6 @@ function renderOne(div, tune, params, tuneNumber, lineOffset) {
     var parent = div.parentNode;
     parent.style.width = div.style.width;
   }
-}
-
-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.
@@ -1263,8 +1171,9 @@ var renderAbc = function renderAbc(output, abc, parserParams, engraverParams, re
     if (!removeDiv && params.wrap && params.staffwidth) {
       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;
   }
@@ -1285,7 +1194,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;
 }
@@ -1294,6 +1203,262 @@ module.exports = renderAbc;
 
 /***/ }),
 
+/***/ "./src/const/key-accidentals.js":
+/*!**************************************!*\
+  !*** ./src/const/key-accidentals.js ***!
+  \**************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var _require = __webpack_require__(/*! ./relative-major */ "./src/const/relative-major.js"),
+    relativeMajor = _require.relativeMajor;
+
+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;
+
+/***/ }),
+
+/***/ "./src/const/relative-major.js":
+/*!*************************************!*\
+  !*** ./src/const/relative-major.js ***!
+  \*************************************/
+/***/ (function(module) {
+
+// 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
+};
+
+/***/ }),
+
 /***/ "./src/data/abc_tune.js":
 /*!******************************!*\
   !*** ./src/data/abc_tune.js ***!
@@ -3232,6 +3397,7 @@ var Parse = function Parse() {
 
     var addWord = function addWord(i) {
       var word = parseCommon.strip(words.substring(last_divider, i));
+      word = word.replace(/\\([-_*|~])/g, '$1');
       last_divider = i + 1;
 
       if (word.length > 0) {
@@ -3249,15 +3415,17 @@ var Parse = function Parse() {
       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,
@@ -3268,33 +3436,47 @@ var Parse = function Parse() {
           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;
@@ -3678,15 +3860,16 @@ var bookParser = function bookParser(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.
+  } // Keep track of the character position each tune starts with. If the string starts with white space, count that, too.
 
 
-  var pos = 0;
+  var pos = initialWhiteSpace ? initialWhiteSpace[0].length : 0;
   var tunes = [];
   parseCommon.each(tuneStrings, function (tune) {
     tunes.push({
@@ -5979,179 +6162,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 = {
@@ -7546,7 +7557,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 = {};
         }
@@ -7985,7 +7996,7 @@ function durationOfMeasure(multilineVars) {
 
 var legalAccents = ["trill", "lowermordent", "uppermordent", "mordent", "pralltriller", "accent", "fermata", "invertedfermata", "tenuto", "0", "1", "2", "3", "4", "5", "+", "wedge", "open", "thumb", "snap", "turn", "roll", "breath", "shortphrase", "mediumphrase", "longphrase", "segno", "coda", "D.S.", "D.C.", "fine", "beambr1", "beambr2", "slide", "marcato", "upbow", "downbow", "/", "//", "///", "////", "trem1", "trem2", "trem3", "trem4", "turnx", "invertedturn", "invertedturnx", "trill(", "trill)", "arpeggio", "xstem", "mark", "umarcato", "style=normal", "style=harmonic", "style=rhythm", "style=x", "style=triangle"];
 var volumeDecorations = ["p", "pp", "f", "ff", "mf", "mp", "ppp", "pppp", "fff", "ffff", "sfz"];
-var dynamicDecorations = ["crescendo(", "crescendo)", "diminuendo(", "diminuendo)"];
+var dynamicDecorations = ["crescendo(", "crescendo)", "diminuendo(", "diminuendo)", "glissando(", "glissando)"];
 var accentPseudonyms = [["<", "accent"], [">", "accent"], ["tr", "trill"], ["plus", "+"], ["emphasis", "accent"], ["^", "umarcato"], ["marcato", "umarcato"]];
 var accentDynamicPseudonyms = [["<(", "crescendo("], ["<)", "crescendo)"], [">(", "diminuendo("], [">)", "diminuendo)"]];
 
@@ -10135,6 +10146,10 @@ module.exports = Tokenizer;
 //    abc_transpose.js: Handles the automatic transposition of key signatures, chord symbols, and notes.
 var allNotes = __webpack_require__(/*! ./all-notes */ "./src/parse/all-notes.js");
 
+var transposeChordName = __webpack_require__(/*! ../parse/transpose-chord */ "./src/parse/transpose-chord.js");
+
+var keyAccidentals = __webpack_require__(/*! ../const/key-accidentals */ "./src/const/key-accidentals.js");
+
 var transpose = {};
 var keyIndex = {
   'C': 0,
@@ -10158,16 +10173,16 @@ 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],
+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;
@@ -10203,7 +10218,7 @@ transpose.keySignature = function (multilineVars, keys, keyName, root, acc, loca
   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);
 
@@ -10232,76 +10247,8 @@ transpose.keySignature = function (multilineVars, keys, keyName, root, acc, loca
   };
 };
 
-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'];
@@ -10418,6 +10365,83 @@ module.exports = allNotes;
 
 /***/ }),
 
+/***/ "./src/parse/transpose-chord.js":
+/*!**************************************!*\
+  !*** ./src/parse/transpose-chord.js ***!
+  \**************************************/
+/***/ (function(module) {
+
+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'];
+
+function transposeChordName(chord, steps, preferFlats, freeGCchord) {
+  if (!steps || steps % 12 === 0) // The chords are the same if it is an exact octave change.
+    return chord; // There are two things in the chord that might need to be transposed:
+  // The chord will start with a letter from A-G, and might have one accidental after it.
+  // That accidental might be an actual sharp or flat char, or it might be a pound sign or lower case "b".
+  // Then there is a bunch of stuff that isn't transposed and should just be copied. That is stuff like "7" and more complicated chords.
+  // But there is one other exception: right after a slash there will be a bass note and possibly an accidental. That should also be transposed.
+
+  while (steps < 0) {
+    steps += 12;
+  }
+
+  if (steps > 11) steps = steps % 12; // (chord name w/accidental) (a bunch of stuff) (/) (bass note) (anything else)
+
+  var match = chord.match(/^([A-G][b#♭♯]?)([^\/]+)?\/?([A-G][b#♭♯]?)?(.+)?/);
+  if (!match) return chord; // We don't recognize the format of the chord, so skip it.
+
+  var name = match[1];
+  var extra1 = match[2];
+  var bass = match[3];
+  var extra2 = match[4];
+  var index = sharpChords.indexOf(name);
+  if (index < 0) index = flatChords.indexOf(name);
+  if (index < 0) index = sharpChordsFree.indexOf(name);
+  if (index < 0) index = flatChordsFree.indexOf(name);
+  if (index < 0) return chord; // This should never happen, but if we can't find the chord just bail.	
+
+  index += steps;
+  index = index % 12;
+
+  if (preferFlats) {
+    if (freeGCchord) chord = flatChordsFree[index];else chord = flatChords[index];
+  } else {
+    if (freeGCchord) chord = sharpChordsFree[index];else chord = sharpChords[index];
+  }
+
+  if (extra1) chord += extra1;
+
+  if (bass) {
+    var index = sharpChords.indexOf(bass);
+    if (index < 0) index = flatChords.indexOf(bass);
+    if (index < 0) index = sharpChordsFree.indexOf(bass);
+    if (index < 0) index = flatChordsFree.indexOf(bass);
+    chord += '/';
+
+    if (index >= 0) {
+      index += steps;
+      index = index % 12;
+
+      if (preferFlats) {
+        if (freeGCchord) chord += flatChordsFree[index];else chord += flatChords[index];
+      } else {
+        if (freeGCchord) chord += sharpChordsFree[index];else chord += sharpChords[index];
+      }
+    } else chord += bass; // Don't know what to do so do nothing
+
+  }
+
+  if (extra2) chord += extra2;
+  return chord;
+}
+
+module.exports = transposeChordName;
+
+/***/ }),
+
 /***/ "./src/parse/tune-builder.js":
 /*!***********************************!*\
   !*** ./src/parse/tune-builder.js ***!
@@ -11890,107 +11914,676 @@ function getRevisedTuneParams(lineBreaks, staffWidth, params) {
     }
   }
 
-  return {
-    revisedParams: revisedParams
-  };
-}
+  return {
+    revisedParams: revisedParams
+  };
+}
+
+function calcLineWraps(tune, widths, params) {
+  // For calculating how much can go on the line, it depends on the width of the line. It is a convenience to just divide it here
+  // by the minimum spacing instead of multiplying the min spacing later.
+  // The scaling works differently: this is done by changing the scaling of the outer SVG, so the scaling needs to be compensated
+  // for here, because the actual width will be different from the calculated numbers.
+  // If the desired width is less than the margin, just punt and return the original tune
+  //console.log(widths)
+  if (widths.length === 0 || params.staffwidth < widths[0].left) {
+    return {
+      reParse: false,
+      explanation: "Staff width is narrower than the margin",
+      revisedParams: params
+    };
+  }
+
+  var scale = params.scale ? Math.max(params.scale, 0.1) : 1;
+  var minSpacing = params.wrap.minSpacing ? Math.max(parseFloat(params.wrap.minSpacing), 1) : 1;
+  var minSpacingLimit = params.wrap.minSpacingLimit ? Math.max(parseFloat(params.wrap.minSpacingLimit), 1) : minSpacing - 0.1;
+  var maxSpacing = params.wrap.maxSpacing ? Math.max(parseFloat(params.wrap.maxSpacing), 1) : undefined;
+  if (params.wrap.lastLineLimit && !maxSpacing) maxSpacing = Math.max(parseFloat(params.wrap.lastLineLimit), 1); // var targetHeight = params.wrap.targetHeight ? Math.max(parseInt(params.wrap.targetHeight, 10), 100) : undefined;
+
+  var preferredMeasuresPerLine = params.wrap.preferredMeasuresPerLine ? Math.max(parseInt(params.wrap.preferredMeasuresPerLine, 10), 0) : undefined;
+  var accumulatedLineBreaks = [];
+  var explanations = [];
+
+  for (var s = 0; s < widths.length; s++) {
+    var section = widths[s];
+    var usableWidth = params.staffwidth - section.left;
+    var lineBreakPoint = usableWidth / minSpacing / scale;
+    var minLineSize = usableWidth / maxSpacing / scale;
+    var allowableVariance = usableWidth / minSpacingLimit / scale;
+    var explanation = {
+      widths: section,
+      lineBreakPoint: lineBreakPoint,
+      minLineSize: minLineSize,
+      attempts: [],
+      staffWidth: params.staffwidth,
+      minWidth: Math.round(allowableVariance)
+    }; // If there is a preferred number of measures per line, test that first. If none of the lines is too long, then we're finished.
+
+    var lineBreaks = null;
+
+    if (preferredMeasuresPerLine) {
+      var f = fixedMeasureLineBreaks(section.measureWidths, lineBreakPoint, preferredMeasuresPerLine);
+      explanation.attempts.push({
+        type: "Fixed Measures Per Line",
+        preferredMeasuresPerLine: preferredMeasuresPerLine,
+        lineBreaks: f.lineBreaks,
+        failed: f.failed,
+        totals: f.totals
+      });
+      if (!f.failed) lineBreaks = f.lineBreaks;
+    } // If we don't have lineBreaks yet, use the free form method of line breaks.
+    // This will be called either if Preferred Measures is not used, or if the music is just weird - like a single measure is way too crowded.
+
+
+    if (!lineBreaks) {
+      var ff = freeFormLineBreaks(section.measureWidths, lineBreakPoint);
+      explanation.attempts.push({
+        type: "Free Form",
+        lineBreaks: ff.lineBreaks,
+        totals: ff.totals
+      });
+      lineBreaks = ff.lineBreaks; // We now have an acceptable number of lines, but the measures may not be optimally distributed. See if there is a better distribution.
+
+      if (lineBreaks.length > 0 && section.measureWidths.length < 25) {
+        // Only do this if everything doesn't fit on one line.
+        // This is an intensive operation and it is optional so just do it for shorter music.
+        ff = optimizeLineWidths(section, lineBreakPoint, lineBreaks, explanation);
+        explanation.attempts.push({
+          type: "Optimize",
+          failed: ff.failed,
+          reason: ff.reason,
+          lineBreaks: ff.lineBreaks,
+          totals: ff.totals
+        });
+        if (!ff.failed) lineBreaks = ff.lineBreaks;
+      }
+    }
+
+    accumulatedLineBreaks.push(lineBreaks);
+    explanations.push(explanation);
+  } // If the vertical space exceeds targetHeight, remove a line and try again. If that is too crowded, then don't use it.
+
+
+  var staffWidth = params.staffwidth;
+  var ret = getRevisedTuneParams(accumulatedLineBreaks, staffWidth, params);
+  ret.explanation = explanations;
+  ret.reParse = true;
+  return ret;
+}
+
+module.exports = {
+  wrapLines: wrapLines,
+  calcLineWraps: calcLineWraps
+};
+
+/***/ }),
+
+/***/ "./src/str/output.js":
+/*!***************************!*\
+  !*** ./src/str/output.js ***!
+  \***************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var keyAccidentals = __webpack_require__(/*! ../const/key-accidentals */ "./src/const/key-accidentals.js");
+
+var _require = __webpack_require__(/*! ../const/relative-major */ "./src/const/relative-major.js"),
+    relativeMajor = _require.relativeMajor,
+    transposeKey = _require.transposeKey,
+    relativeMode = _require.relativeMode;
+
+var transposeChordName = __webpack_require__(/*! ../parse/transpose-chord */ "./src/parse/transpose-chord.js");
+
+var strTranspose;
+
+(function () {
+  "use strict";
+
+  strTranspose = function strTranspose(abc, abcTune, steps) {
+    if (abcTune === "TEST") // Backdoor way to get entry points for unit tests
+      return {
+        keyAccidentals: keyAccidentals,
+        relativeMajor: relativeMajor,
+        transposeKey: transposeKey,
+        relativeMode: relativeMode,
+        transposeChordName: transposeChordName
+      };
+    steps = parseInt(steps, 10);
+    var changes = [];
+    var i;
+
+    for (i = 0; i < abcTune.length; i++) {
+      changes = changes.concat(transposeOneTune(abc, abcTune[i], steps));
+    } // Reverse sort so that we are replacing strings from the end to the beginning so that the indexes aren't invalidated as we go.
+    // (Because voices can be written in different ways we can't count on the notes being encountered in the order they appear in the string.)
+
+
+    changes = changes.sort(function (a, b) {
+      return b.start - a.start;
+    });
+    var output = abc.split('');
+
+    for (i = 0; i < changes.length; i++) {
+      var ch = changes[i];
+      output.splice(ch.start, ch.end - ch.start, ch.note);
+    }
+
+    return output.join('');
+  };
+
+  function transposeOneTune(abc, abcTune, steps) {
+    var changes = []; // Don't transpose bagpipe music - that is a special case and is always a particular key
+
+    var key = abcTune.getKeySignature();
+    if (key.root === 'Hp' || key.root === "HP") return changes;
+    changes = changes.concat(changeAllKeySigs(abc, steps));
+
+    for (var i = 0; i < abcTune.lines.length; i++) {
+      var staves = abcTune.lines[i].staff;
+
+      if (staves) {
+        for (var j = 0; j < staves.length; j++) {
+          var staff = staves[j];
+          if (staff.clef.type !== "perc") changes = changes.concat(transposeVoices(abc, staff.voices, staff.key, steps));
+        }
+      }
+    }
+
+    return changes;
+  }
+
+  function changeAllKeySigs(abc, steps) {
+    var changes = [];
+    var arr = abc.split("K:"); // now each line except the first one will start with whatever is right after "K:"
+
+    var count = arr[0].length;
+
+    for (var i = 1; i < arr.length; i++) {
+      var segment = arr[i];
+      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]; // key name, accidental, and mode
+
+        var destinationKey = newKey({
+          root: match[2],
+          acc: match[3],
+          mode: match[4]
+        }, steps);
+        var dest = destinationKey.root + destinationKey.acc + destinationKey.mode;
+        changes.push({
+          start: start,
+          end: start + key.length,
+          note: dest
+        });
+      }
+
+      count += segment.length + 2;
+    }
+
+    return changes;
+  }
+
+  function transposeVoices(abc, voices, key, steps) {
+    var changes = [];
+    var destinationKey = newKey(key, steps);
+
+    for (var i = 0; i < voices.length; i++) {
+      changes = changes.concat(transposeVoice(abc, voices[i], key.root, createKeyAccidentals(key), destinationKey, steps));
+    }
+
+    return changes;
+  }
+
+  function createKeyAccidentals(key) {
+    var ret = {};
+
+    for (var i = 0; i < key.accidentals.length; i++) {
+      var acc = key.accidentals[i];
+      if (acc.acc === 'flat') ret[acc.note.toUpperCase()] = '_';else if (acc.acc === 'sharp') ret[acc.note.toUpperCase()] = '^';
+    }
+
+    return ret;
+  }
+
+  function setLetterDistance(destinationKey, keyRoot, steps) {
+    var letterDistance = letters.indexOf(destinationKey.root) - letters.indexOf(keyRoot);
+    if (keyRoot === "none") letterDistance = letters.indexOf(destinationKey.root);
+
+    if (letterDistance === 0) {
+      // This could either be a half step (like Eb => E) or almost an octave (like E => Eb)
+      if (steps > 2) // If it is a large leap, then we are going up an octave
+        letterDistance += 7;else if (steps === -12) // If it is a large leap, then we are going down an octave	
+        letterDistance -= 7;
+    } else if (steps > 0 && letterDistance < 0) letterDistance += 7;else if (steps < 0 && letterDistance > 0) letterDistance -= 7;
+
+    if (steps > 12) letterDistance += 7;else if (steps < -12) letterDistance -= 7;
+    return letterDistance;
+  }
+
+  function transposeVoice(abc, voice, keyRoot, keyAccidentals, destinationKey, steps) {
+    var changes = [];
+    var letterDistance = setLetterDistance(destinationKey, keyRoot, steps);
+    var measureAccidentals = {};
+    var transposedMeasureAccidentals = {};
+
+    for (var i = 0; i < voice.length; i++) {
+      var el = voice[i];
+
+      if (el.chord) {
+        for (var c = 0; c < el.chord.length; c++) {
+          var ch = el.chord[c];
+
+          if (ch.position === 'default') {
+            var prefersFlats = destinationKey.accidentals.length && destinationKey.accidentals[0].acc === 'flat';
+            var newChord = transposeChordName(ch.name, steps, prefersFlats, true);
+            newChord = newChord.replace(/♭/g, "b").replace(/♯/g, "#");
+            if (newChord !== ch.name) // If we didn't recognize the chord the input is returned unchanged and there is nothing to replace
+              changes.push(replaceChord(abc, el.startChar, el.endChar, newChord));
+          }
+        }
+      }
+
+      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);
+          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));
+        }
+
+        if (el.gracenotes) {
+          for (var g = 0; g < el.gracenotes.length; g++) {
+            var grace = parseNote(el.gracenotes[g].name, keyRoot, keyAccidentals, measureAccidentals);
+            if (grace.acc) measureAccidentals[grace.name.toUpperCase()] = grace.acc;
+            var newGrace = transposePitch(grace, destinationKey, letterDistance, measureAccidentals);
+            if (newGrace.acc) transposedMeasureAccidentals[newGrace.upper] = newGrace.acc;
+            changes.push(replaceGrace(abc, el.startChar, el.endChar, newGrace.acc + newGrace.name, g));
+          }
+        }
+      } else if (el.el_type === "bar") {
+        measureAccidentals = {};
+        transposedMeasureAccidentals = {};
+      } else if (el.el_type === "keySignature") {
+        keyRoot = el.root;
+        keyAccidentals = createKeyAccidentals(el);
+        destinationKey = newKey(el, steps);
+        letterDistance = setLetterDistance(destinationKey, keyRoot, steps);
+      }
+    }
+
+    return changes;
+  }
+
+  var letters = "CDEFGAB";
+  var octaves = [",,,,", ",,,", ",,", ",", "", "'", "''", "'''", "''''"];
+
+  function newKey(key, steps) {
+    if (key.root === "none") {
+      return {
+        root: transposeKey("C", steps),
+        mode: "",
+        acc: "",
+        accidentals: []
+      };
+    }
+
+    var major = relativeMajor(key.root + key.acc + key.mode);
+    var newMajor = transposeKey(major, steps);
+    var newMode = relativeMode(newMajor, key.mode);
+    var acc = keyAccidentals(newMajor);
+    return {
+      root: newMode[0],
+      mode: key.mode,
+      acc: newMode.length > 1 ? newMode[1] : '',
+      accidentals: acc
+    };
+  }
+
+  function transposePitch(note, key, letterDistance, measureAccidentals) {
+    // Depending on what the current note and new note are, the octave might have changed
+    // The letterDistance is how far the change is to see if we passed "C" when transposing.
+    var pitch = note.pitch;
+    var origDistFromC = letters.indexOf(note.name);
+    var root = letters.indexOf(key.root);
+    var index = (root + pitch) % 7; // if the note crosses "c" then the octave changes, so that is true of "B" when going up one step, "A" and "B" when going up two steps, etc., and reverse when going down.
+
+    var newDistFromC = origDistFromC + letterDistance;
+    var oct = note.oct;
+
+    while (newDistFromC > 6) {
+      oct++;
+      newDistFromC -= 7;
+    }
+
+    while (newDistFromC < 0) {
+      oct--;
+      newDistFromC += 7;
+    }
+
+    var name = letters[index];
+    var acc = '';
+    var adj = note.adj; // the amount of adjustment depends on the key - if there is a sharp in the key sig, then -1 is a natural, if there isn't, then -1 is a flat.
+
+    var keyAcc = '=';
+
+    for (var i = 0; i < key.accidentals.length; i++) {
+      if (key.accidentals[i].note.toLowerCase() === name.toLowerCase()) {
+        adj = adj + (key.accidentals[i].acc === 'flat' ? -1 : 1);
+        keyAcc = key.accidentals[i].acc === 'flat' ? '_' : '^';
+        break;
+      }
+    }
+
+    switch (adj) {
+      case -2:
+        acc = "__";
+        break;
+
+      case -1:
+        acc = "_";
+        break;
+
+      case 0:
+        acc = "=";
+        break;
+
+      case 1:
+        acc = "^";
+        break;
+
+      case 2:
+        acc = "^^";
+        break;
+
+      case -3:
+        // This requires a triple flat, so bump down the pitch and try again
+        var newNote = {};
+        newNote.pitch = note.pitch - 1;
+        newNote.oct = note.oct;
+        newNote.name = letters[letters.indexOf(note.name) - 1];
+
+        if (!newNote.name) {
+          newNote.name = "B";
+          newNote.oct--;
+        }
+
+        if (newNote.name === "B" || newNote.name === "E") newNote.adj = note.adj + 1;else newNote.adj = note.adj + 2;
+        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.pitch = note.pitch + 1;
+        newNote.oct = note.oct;
+        newNote.name = letters[letters.indexOf(note.name) + 1];
+
+        if (!newNote.name) {
+          newNote.name = "C";
+          newNote.oct++;
+        }
+
+        if (newNote.name === "C" || newNote.name === "F") newNote.adj = note.adj - 1;else newNote.adj = note.adj - 2;
+        return transposePitch(newNote, key, letterDistance + 1, measureAccidentals);
+    }
+
+    if ((measureAccidentals[name] === acc || !measureAccidentals[name] && acc === keyAcc) && !note.courtesy) acc = "";
+
+    switch (oct) {
+      case 0:
+        name = name + ",,,";
+        break;
+
+      case 1:
+        name = name + ",,";
+        break;
+
+      case 2:
+        name = name + ",";
+        break;
+      // case 3: it is already correct
+
+      case 4:
+        name = name.toLowerCase();
+        break;
+
+      case 5:
+        name = name.toLowerCase() + "'";
+        break;
+
+      case 6:
+        name = name.toLowerCase() + "''";
+        break;
+
+      case 7:
+        name = name.toLowerCase() + "'''";
+        break;
+
+      case 8:
+        name = name.toLowerCase() + "''''";
+        break;
+    }
+
+    if (oct > 4) name = name.toLowerCase();
+    return {
+      acc: acc,
+      name: name,
+      upper: name.toUpperCase()
+    };
+  }
+
+  var regPitch = /([_^=]*)([A-Ga-g])([,']*)/;
+  var regNote = /([_^=]*[A-Ga-g][,']*)(\d*\/*\d*)([\>\<\-\)\.\s\\]*)/;
+  var regOptionalNote = /([_^=]*[A-Ga-g][,']*)?(\d*\/*\d*)?([\>\<\-\)]*)?/;
+  var regSpace = /(\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.
+  // I don't think there is any adjustment needed for minor keys since the adjustment is based on the key signature and the accidentals.
+
+  function parseNote(note, keyRoot, keyAccidentals, measureAccidentals) {
+    var root = keyRoot === "none" ? 0 : letters.indexOf(keyRoot);
+    var reg = note.match(regPitch); // reg[1] : "__", "_", "", "=", "^", or "^^"
+    // reg[2] : A-G a-g
+    // reg[3] : commas or apostrophes
+
+    var name = reg[2].toUpperCase();
+    var pos = letters.indexOf(name) - root;
+    if (pos < 0) pos += 7;
+    var oct = octaves.indexOf(reg[3]);
+    if (name === reg[2]) // See if it is a capital letter and subtract an octave if so.
+      oct--;
+    var currentAcc = measureAccidentals[name] || keyAccidentals[name] || "="; //  use the key accidentals if they exist, but override with the measure accidentals, and if neither of them exist, use a natural.
+
+    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) {
+    // There may be more than just the note between the start and end - there could be spaces, there could be a chord symbol, there could be a decoration.
+    // This could also be a part of a chord. If so, then the particular note needs to be teased out.
+    var note = abc.substring(start, end);
+    var match = note.match(new RegExp(regNote.source + regSpace.source), '');
+
+    if (match) {
+      // This will match a single note
+      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 {
+      // 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.
+      var regPreBracket = /([^\[]*)/;
+      var regOpenBracket = /\[/;
+      var regCloseBracket = /\-?](\d*\/*\d*)?([\>\<\-\)]*)/;
+      match = note.match(new RegExp(regPreBracket.source + regOpenBracket.source + regOptionalNote.source + regOptionalNote.source + regOptionalNote.source + regOptionalNote.source + regOptionalNote.source + regOptionalNote.source + regOptionalNote.source + regOptionalNote.source + regCloseBracket.source + regSpace.source));
+
+      if (match) {
+        // This will match a chord
+        // Get the number of chars used by the previous notes in this chord
+        var count = 1 + match[1].length; // one character for the open bracket
+
+        for (var i = 0; i < index; i++) {
+          // index is the iteration through the chord. This function gets called for each one.
+          if (match[i * 3 + 2]) count += match[i * 3 + 2].length;
+          if (match[i * 3 + 3]) count += match[i * 3 + 3].length;
+          if (match[i * 3 + 4]) count += match[i * 3 + 4].length;
+        }
+
+        start += count;
+        var endLen = match[index * 3 + 2] ? match[index * 3 + 2].length : 0; // endLen += match[index * 3 + 3] ? match[index * 3 + 3].length : 0
+        // endLen += match[index * 3 + 4] ? match[index * 3 + 4].length : 0
+
+        end = start + endLen;
+      }
+    }
+
+    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.
+
+    var regOpenBrace = /\{/;
+    var regCloseBrace = /\}/;
+    var regPreBrace = /([^\{]*)/;
+    var regPreNote = /(\/*)/;
+    var match = note.match(new RegExp(regPreBrace.source + regOpenBrace.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regPreNote.source + regOptionalNote.source + regCloseBrace.source));
+
+    if (match) {
+      // This will match all notes inside a grace symbol
+      // Get the number of chars used by the previous graces
+      var count = 1 + match[1].length; // one character for the open brace, and whatever comes before the brace
+
+      for (var i = 0; i < index; i++) {
+        // index is the iteration through the chord. This function gets called for each one.
+        if (match[i * 3 + 2]) count += match[i * 3 + 2].length;
+        if (match[i * 3 + 3]) count += match[i * 3 + 3].length;
+        if (match[i * 3 + 4]) count += match[i * 3 + 4].length;
+        if (match[i * 3 + 5]) count += match[i * 3 + 5].length;
+      }
+
+      if (match[index * 3 + 2]) count += match[i * 3 + 2].length;
+      start += count;
+      var endLen = match[index * 3 + 3] ? match[index * 3 + 3].length : 0;
+      endLen += match[index * 3 + 4] ? match[index * 3 + 4].length : 0;
+      endLen += match[index * 3 + 5] ? match[index * 3 + 5].length : 0;
+      end = start + endLen;
+    }
+
+    return {
+      start: start,
+      end: end,
+      note: newGrace
+    };
+  }
+
+  function replaceChord(abc, start, end, newChord) {
+    // Isolate the chord and just replace that
+    var match = abc.substring(start, end).match(/([^"]+)?(".+")+/);
+    if (match[1]) start += match[1].length;
+    end = start + match[2].length; // leave the quote in, so skip one more
 
-function calcLineWraps(tune, widths, params) {
-  // For calculating how much can go on the line, it depends on the width of the line. It is a convenience to just divide it here
-  // by the minimum spacing instead of multiplying the min spacing later.
-  // The scaling works differently: this is done by changing the scaling of the outer SVG, so the scaling needs to be compensated
-  // for here, because the actual width will be different from the calculated numbers.
-  // If the desired width is less than the margin, just punt and return the original tune
-  //console.log(widths)
-  if (widths.length === 0 || params.staffwidth < widths[0].left) {
     return {
-      reParse: false,
-      explanation: "Staff width is narrower than the margin",
-      revisedParams: params
+      start: start + 1,
+      end: end - 1,
+      note: newChord
     };
   }
 
-  var scale = params.scale ? Math.max(params.scale, 0.1) : 1;
-  var minSpacing = params.wrap.minSpacing ? Math.max(parseFloat(params.wrap.minSpacing), 1) : 1;
-  var minSpacingLimit = params.wrap.minSpacingLimit ? Math.max(parseFloat(params.wrap.minSpacingLimit), 1) : minSpacing - 0.1;
-  var maxSpacing = params.wrap.maxSpacing ? Math.max(parseFloat(params.wrap.maxSpacing), 1) : undefined;
-  if (params.wrap.lastLineLimit && !maxSpacing) maxSpacing = Math.max(parseFloat(params.wrap.lastLineLimit), 1); // var targetHeight = params.wrap.targetHeight ? Math.max(parseInt(params.wrap.targetHeight, 10), 100) : undefined;
+  function calcAdjustment(thisAccidental, keyAccidental, measureAccidental) {
+    if (!thisAccidental && measureAccidental) {
+      // There was no accidental on this note, but there was earlier in the measure, so we'll use that
+      thisAccidental = measureAccidental;
+    }
 
-  var preferredMeasuresPerLine = params.wrap.preferredMeasuresPerLine ? Math.max(parseInt(params.wrap.preferredMeasuresPerLine, 10), 0) : undefined;
-  var accumulatedLineBreaks = [];
-  var explanations = [];
+    if (!thisAccidental) return 0; // there is no deviation from the key.
 
-  for (var s = 0; s < widths.length; s++) {
-    var section = widths[s];
-    var usableWidth = params.staffwidth - section.left;
-    var lineBreakPoint = usableWidth / minSpacing / scale;
-    var minLineSize = usableWidth / maxSpacing / scale;
-    var allowableVariance = usableWidth / minSpacingLimit / scale;
-    var explanation = {
-      widths: section,
-      lineBreakPoint: lineBreakPoint,
-      minLineSize: minLineSize,
-      attempts: [],
-      staffWidth: params.staffwidth,
-      minWidth: Math.round(allowableVariance)
-    }; // If there is a preferred number of measures per line, test that first. If none of the lines is too long, then we're finished.
+    switch (keyAccidental) {
+      case undefined:
+        switch (thisAccidental) {
+          case '__':
+            return -2;
 
-    var lineBreaks = null;
+          case '_':
+            return -1;
 
-    if (preferredMeasuresPerLine) {
-      var f = fixedMeasureLineBreaks(section.measureWidths, lineBreakPoint, preferredMeasuresPerLine);
-      explanation.attempts.push({
-        type: "Fixed Measures Per Line",
-        preferredMeasuresPerLine: preferredMeasuresPerLine,
-        lineBreaks: f.lineBreaks,
-        failed: f.failed,
-        totals: f.totals
-      });
-      if (!f.failed) lineBreaks = f.lineBreaks;
-    } // If we don't have lineBreaks yet, use the free form method of line breaks.
-    // This will be called either if Preferred Measures is not used, or if the music is just weird - like a single measure is way too crowded.
+          case '=':
+            return 0;
 
+          case '^':
+            return 1;
 
-    if (!lineBreaks) {
-      var ff = freeFormLineBreaks(section.measureWidths, lineBreakPoint);
-      explanation.attempts.push({
-        type: "Free Form",
-        lineBreaks: ff.lineBreaks,
-        totals: ff.totals
-      });
-      lineBreaks = ff.lineBreaks; // We now have an acceptable number of lines, but the measures may not be optimally distributed. See if there is a better distribution.
+          case '^^':
+            return 2;
 
-      if (lineBreaks.length > 0 && section.measureWidths.length < 25) {
-        // Only do this if everything doesn't fit on one line.
-        // This is an intensive operation and it is optional so just do it for shorter music.
-        ff = optimizeLineWidths(section, lineBreakPoint, lineBreaks, explanation);
-        explanation.attempts.push({
-          type: "Optimize",
-          failed: ff.failed,
-          reason: ff.reason,
-          lineBreaks: ff.lineBreaks,
-          totals: ff.totals
-        });
-        if (!ff.failed) lineBreaks = ff.lineBreaks;
-      }
-    }
+          default:
+            return 0;
+          // this should never happen
+        }
 
-    accumulatedLineBreaks.push(lineBreaks);
-    explanations.push(explanation);
-  } // If the vertical space exceeds targetHeight, remove a line and try again. If that is too crowded, then don't use it.
+      case '_':
+        switch (thisAccidental) {
+          case '__':
+            return -1;
 
+          case '_':
+            return 0;
 
-  var staffWidth = params.staffwidth;
-  var ret = getRevisedTuneParams(accumulatedLineBreaks, staffWidth, params);
-  ret.explanation = explanations;
-  ret.reParse = true;
-  return ret;
-}
+          case '=':
+            return 1;
 
-module.exports = {
-  wrapLines: wrapLines,
-  calcLineWraps: calcLineWraps
-};
+          case '^':
+            return 2;
+
+          case '^^':
+            return 3;
+
+          default:
+            return 0;
+          // this should never happen
+        }
+
+      case '^':
+        switch (thisAccidental) {
+          case '__':
+            return -3;
+
+          case '_':
+            return -2;
+
+          case '=':
+            return -1;
+
+          case '^':
+            return 0;
+
+          case '^^':
+            return 1;
+
+          default:
+            return 0;
+          // this should never happen
+        }
+
+    }
+
+    return 0; // this should never happen
+  }
+})();
+
+module.exports = strTranspose;
 
 /***/ }),
 
@@ -12771,7 +13364,9 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
           volume: velocity,
           start: timeToRealTime(elem.time),
           duration: durationRounded(note.duration),
-          instrument: currentInstrument
+          instrument: currentInstrument,
+          startChar: elem.elem.startChar,
+          endChar: elem.elem.endChar
         };
         p = adjustForMicroTone(p);
 
@@ -14844,6 +15439,8 @@ var createNoteMap = function createNoteMap(sequence) {
               end: Math.round((ev.start + len - gap) * 1000000) / 1000000,
               volume: ev.volume
             };
+            if (ev.startChar) obj.startChar = ev.startChar;
+            if (ev.endChar) obj.endChar = ev.endChar;
             if (ev.style) obj.style = ev.style;
             if (ev.cents) obj.cents = ev.cents;
             map[i].push(obj);
@@ -19354,6 +19951,15 @@ AbstractEngraver.prototype.createBeam = function (isSingleLineStaff, voice, elem
   if (hint) beamelem.setHint();
 
   for (var i = 0; i < elems.length; i++) {
+    // Do a first pass to figure out the stem direction before creating the notes, so that staccatos and other decorations can be placed correctly.
+    beamelem.runningDirection(elems[i]);
+  }
+
+  beamelem.setStemDirection();
+  var tempStemDir = this.stemdir;
+  this.stemdir = beamelem.stemsUp ? 'up' : 'down';
+
+  for (i = 0; i < elems.length; i++) {
     var elem = elems[i];
     var abselem = this.createNote(elem, true, isSingleLineStaff, voice);
     abselemset.push(abselem);
@@ -19368,6 +19974,7 @@ AbstractEngraver.prototype.createBeam = function (isSingleLineStaff, voice, elem
 
   beamelem.calcDir();
   voice.addBeam(beamelem);
+  this.stemdir = tempStemDir;
   return abselemset;
 };
 
@@ -20113,6 +20720,11 @@ AbstractEngraver.prototype.createBarLine = function (voice, elem, isFirstStaff)
 
 
   abselem.extraw -= 5;
+
+  if (elem.chord !== undefined) {
+    var ret3 = addChord(this.getTextSize, abselem, elem, 0, 0, 0, false);
+  }
+
   return abselem;
 };
 
@@ -20171,6 +20783,15 @@ 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
@@ -20193,6 +20814,24 @@ 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);
 
@@ -20761,6 +21400,8 @@ var DynamicDecoration = __webpack_require__(/*! ./abc_dynamic_decoration */ "./s
 
 var CrescendoElem = __webpack_require__(/*! ./abc_crescendo_element */ "./src/write/abc_crescendo_element.js");
 
+var GlissandoElem = __webpack_require__(/*! ./abc_glissando_element */ "./src/write/abc_glissando_element.js");
+
 var glyphs = __webpack_require__(/*! ./abc_glyphs */ "./src/write/abc_glyphs.js");
 
 var RelativeElement = __webpack_require__(/*! ./abc_relative_element */ "./src/write/abc_relative_element.js");
@@ -21077,6 +21718,7 @@ function leftDecoration(decoration, abselem, roomtaken) {
 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]) {
@@ -21105,6 +21747,19 @@ Decoration.prototype.dynamicDecoration = function (voice, decoration, abselem, p
         };
         this.startCrescendoX = undefined;
         break;
+
+      case "glissando(":
+        this.startGlissandoX = abselem;
+        glissando = undefined;
+        break;
+
+      case "glissando)":
+        glissando = {
+          start: this.startGlissandoX,
+          stop: abselem
+        };
+        this.startGlissandoX = undefined;
+        break;
     }
   }
 
@@ -21115,6 +21770,10 @@ Decoration.prototype.dynamicDecoration = function (voice, decoration, abselem, p
   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) {
@@ -21239,6 +21898,7 @@ var tablatures = __webpack_require__(/*! ../api/abc_tablatures */ "./src/api/abc
 
 var EngraverController = function EngraverController(paper, params) {
   params = params || {};
+  this.oneSvgPerLine = params.oneSvgPerLine;
   this.selectionColor = params.selectionColor;
   this.dragColor = params.dragColor ? params.dragColor : params.selectionColor;
   this.dragging = !!params.dragging;
@@ -21455,8 +22115,78 @@ EngraverController.prototype.engraveTune = function (abcTune, tuneNumber, lineOf
   var ret = draw(this.renderer, this.classes, abcTune, this.width, maxWidth, this.responsive, scale, this.selectTypes, tuneNumber, lineOffset);
   this.staffgroups = ret.staffgroups;
   this.selectables = ret.selectables;
-  setupSelection(this);
-};
+
+  if (this.oneSvgPerLine) {
+    var div = this.renderer.paper.svg.parentNode;
+    this.svgs = splitSvgIntoLines(div, abcTune.metaText.title);
+  } else {
+    this.svgs = [this.renderer.paper.svg];
+  }
+
+  setupSelection(this, this.svgs);
+};
+
+function splitSvgIntoLines(output, title) {
+  // Each line is a top level <g> in the svg. To split it into separate
+  // svgs iterate through each of those and put them in a new svg. Since
+  // they are placed absolutely, the viewBox needs to be manipulated to
+  // get the correct vertical positioning.
+  // We copy all the attributes from the original svg except for the aria-label
+  // since we want that to include a count. And the height is now a fraction of the original svg.
+  if (!title) title = "Untitled";
+  var source = output.querySelector("svg");
+  var style = source.querySelector("style");
+  var width = source.getAttribute("width");
+  var sections = output.querySelectorAll("svg > g"); // each section is a line, or the top matter or the bottom matter, or text that has been inserted.
+
+  var nextTop = 0; // There are often gaps between the elements for spacing, so the actual top and height needs to be inferred.
+
+  var wrappers = []; // Create all the elements and place them at once because we use the current svg to get data. It would disappear after placing the first line.
+
+  var svgs = [];
+
+  for (var i = 0; i < sections.length; i++) {
+    var section = sections[i];
+    var box = section.getBBox();
+    var gapBetweenLines = box.y - nextTop; // take the margin into account
+
+    var height = box.height + gapBetweenLines;
+    var wrapper = document.createElement("div");
+    wrapper.setAttribute("style", "overflow: hidden;height:" + height + "px;");
+    var svg = duplicateSvg(source);
+    var fullTitle = "Sheet Music for \"" + title + "\" section " + (i + 1);
+    svg.setAttribute("aria-label", fullTitle);
+    svg.setAttribute("height", height);
+    svg.setAttribute("viewBox", "0 " + nextTop + " " + width + " " + height);
+    svg.appendChild(style.cloneNode(true));
+    var titleEl = document.createElement("title");
+    titleEl.innerText = fullTitle;
+    svg.appendChild(titleEl);
+    svg.appendChild(section);
+    wrapper.appendChild(svg);
+    svgs.push(svg);
+    output.appendChild(wrapper); //wrappers.push(wrapper)
+
+    nextTop = box.y + box.height;
+  } // for (i = 0; i < wrappers.length; i++)
+  // 	output.appendChild(wrappers[i])
+
+
+  output.removeChild(source);
+  return svgs;
+}
+
+function duplicateSvg(source) {
+  var svgNS = "http://www.w3.org/2000/svg";
+  var svg = document.createElementNS(svgNS, "svg");
+
+  for (var i = 0; i < source.attributes.length; i++) {
+    var attr = source.attributes[i];
+    if (attr.name !== "height" && attr.name != "aria-label") svg.setAttribute(attr.name, attr.value);
+  }
+
+  return svg;
+}
 
 EngraverController.prototype.getDim = function (historyEl) {
   // Get the dimensions on demand because the getBBox call is expensive.
@@ -21481,6 +22211,23 @@ module.exports = EngraverController;
 
 /***/ }),
 
+/***/ "./src/write/abc_glissando_element.js":
+/*!********************************************!*\
+  !*** ./src/write/abc_glissando_element.js ***!
+  \********************************************/
+/***/ (function(module) {
+
+var GlissandoElem = function GlissandoElem(anchor1, anchor2) {
+  this.type = "GlissandoElem";
+  this.anchor1 = anchor1; // must have a .x and a .parent property or be null (means starts at the "beginning" of the line - after keysig)
+
+  this.anchor2 = anchor2; // must have a .x property or be null (means ends at the end of the line)
+};
+
+module.exports = GlissandoElem;
+
+/***/ }),
+
 /***/ "./src/write/abc_glyphs.js":
 /*!*********************************!*\
   !*** ./src/write/abc_glyphs.js ***!
@@ -23806,8 +24553,10 @@ var Selectables = __webpack_require__(/*! ./selectables */ "./src/write/draw/sel
 
 function draw(renderer, classes, abcTune, width, maxWidth, responsive, scale, selectTypes, tuneNumber, lineOffset) {
   var selectables = new Selectables(renderer.paper, selectTypes, tuneNumber);
+  renderer.paper.openGroup();
   renderer.moveY(renderer.padding.top);
   nonMusic(renderer, abcTune.topText, selectables);
+  renderer.paper.closeGroup();
   renderer.moveY(renderer.spacing.music);
   var staffgroups = [];
 
@@ -23816,6 +24565,8 @@ function draw(renderer, classes, abcTune, width, maxWidth, responsive, scale, se
     var abcLine = abcTune.lines[line];
 
     if (abcLine.staff) {
+      renderer.paper.openGroup();
+
       if (abcLine.vskip) {
         renderer.moveY(abcLine.vskip);
       }
@@ -23825,17 +24576,22 @@ function draw(renderer, classes, abcTune, width, maxWidth, responsive, scale, se
       staffgroup.line = lineOffset + line; // If there are non-music lines then the staffgroup array won't line up with the line array, so this keeps track.
 
       staffgroups.push(staffgroup);
+      renderer.paper.closeGroup();
     } else if (abcLine.nonMusic) {
+      renderer.paper.openGroup();
       nonMusic(renderer, abcLine.nonMusic, selectables);
+      renderer.paper.closeGroup();
     }
   }
 
   classes.reset();
 
   if (abcTune.bottomText && abcTune.bottomText.rows && abcTune.bottomText.rows.length > 0) {
+    renderer.paper.openGroup();
     renderer.moveY(24); // TODO-PER: Empirically discovered. What variable should this be?
 
     nonMusic(renderer, abcTune.bottomText, selectables);
+    renderer.paper.closeGroup();
   }
 
   setPaperSize(renderer, maxWidth, scale, responsive);
@@ -23965,6 +24721,107 @@ module.exports = drawEnding;
 
 /***/ }),
 
+/***/ "./src/write/draw/glissando.js":
+/*!*************************************!*\
+  !*** ./src/write/draw/glissando.js ***!
+  \*************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var sprintf = __webpack_require__(/*! ./sprintf */ "./src/write/draw/sprintf.js");
+
+var printPath = __webpack_require__(/*! ./print-path */ "./src/write/draw/print-path.js");
+
+var roundNumber = __webpack_require__(/*! ./round-number */ "./src/write/draw/round-number.js");
+
+function drawGlissando(renderer, params, selectables) {
+  if (!params.anchor1 || !params.anchor2 || !params.anchor1.heads || !params.anchor2.heads || params.anchor1.heads.length === 0 || params.anchor2.heads.length === 0) window.console.error("Glissando Element not set.");
+  var margin = 4;
+  var leftY = renderer.calcY(params.anchor1.heads[0].pitch);
+  var rightY = renderer.calcY(params.anchor2.heads[0].pitch);
+  var leftX = params.anchor1.x + params.anchor1.w / 2;
+  var rightX = params.anchor2.x + params.anchor2.w / 2;
+  var len = lineLength(leftX, leftY, rightX, rightY);
+  var marginLeft = params.anchor1.w / 2 + margin;
+  var marginRight = params.anchor2.w / 2 + margin;
+  var s = slope(leftX, leftY, rightX, rightY);
+  var leftYAdj = getY(leftY, s, marginLeft);
+  var rightYAdj = getY(rightY, s, -marginRight);
+  var num = numSquigglies(len - marginLeft - marginRight);
+  var el = drawSquiggly(renderer, leftX + marginLeft, leftYAdj, num, s);
+  selectables.wrapSvgEl({
+    el_type: "glissando",
+    startChar: -1,
+    endChar: -1
+  }, el);
+  return [el];
+}
+
+function lineLength(leftX, leftY, rightX, rightY) {
+  // The length from notehead center to notehead center.
+  var w = rightX - leftX;
+  var h = rightY - leftY;
+  return Math.sqrt(w * w + h * h);
+}
+
+function slope(leftX, leftY, rightX, rightY) {
+  return (rightY - leftY) / (rightX - leftX);
+}
+
+function getY(y, slope, xOfs) {
+  return roundNumber(y + xOfs * slope);
+}
+
+function numSquigglies(length) {
+  var endLen = 5; // The width of the end - that is, the non repeating part
+
+  return Math.max(2, Math.floor((length - endLen * 2) / 6));
+}
+
+var leftStart = [[3.5, -4.8]];
+var right = [[1.5, -1], [.3, -.3], [-3.5, 3.8]];
+var leftEnd = [[-1.5, 2]];
+var top = [[3, 4], [3, -4]];
+var bottom = [[-3, 4], [-3, -4]];
+
+function segment(arr, slope) {
+  var ret = "";
+
+  for (var i = 0; i < arr.length; i++) {
+    ret += 'l' + arr[i][0] + ' ' + getY(arr[i][1], slope, arr[i][0]);
+  }
+
+  return ret;
+}
+
+var drawSquiggly = function drawSquiggly(renderer, x, y, num, slope) {
+  var p = sprintf("M %f %f", x, y);
+  p += segment(leftStart, slope);
+  var i;
+
+  for (i = 0; i < num; i++) {
+    p += segment(top, slope);
+  }
+
+  p += segment(right, slope);
+
+  for (i = 0; i < num; i++) {
+    p += segment(bottom, slope);
+  }
+
+  p += segment(leftEnd, slope) + 'z';
+  return printPath(renderer, {
+    path: p,
+    highlight: "stroke",
+    stroke: renderer.foregroundColor,
+    'class': renderer.controller.classes.generate('decoration'),
+    "data-name": "glissando"
+  });
+};
+
+module.exports = drawGlissando;
+
+/***/ }),
+
 /***/ "./src/write/draw/group-elements.js":
 /*!******************************************!*\
   !*** ./src/write/draw/group-elements.js ***!
@@ -24801,8 +25658,8 @@ function drawStaffGroup(renderer, params, selectables, lineNumber) {
   // renderer.y will be offset at the beginning of each staff by the amount required to make the relative pitch work.
   // If there are multiple staves, then renderer.y will be incremented for each new staff.
   var colorIndex; // An invisible marker is useful to be able to find where each system starts.
+  //addInvisibleMarker(renderer, "abcjs-top-of-system");
 
-  addInvisibleMarker(renderer, "abcjs-top-of-system");
   var startY = renderer.y; // So that it can be restored after we're done.
   // Set the absolute Y position for each staff here, so the voice drawing below can just use if.
 
@@ -24994,20 +25851,11 @@ function printBrace(renderer, absoluteY, brace, index, selectables) {
       }
     }
   }
-}
+} // function addInvisibleMarker(renderer, className) {
+// 	var y = Math.round(renderer.y);
+// 	renderer.paper.pathToBack({path:"M 0 " + y + " L 0 0", stroke:"none", fill:"none", "stroke-opacity": 0, "fill-opacity": 0, 'class': renderer.controller.classes.generate(className), 'data-vertical': y });
+// }
 
-function addInvisibleMarker(renderer, className) {
-  var y = Math.round(renderer.y);
-  renderer.paper.pathToBack({
-    path: "M 0 " + y + " L 0 0",
-    stroke: "none",
-    fill: "none",
-    "stroke-opacity": 0,
-    "fill-opacity": 0,
-    'class': renderer.controller.classes.generate(className),
-    'data-vertical': y
-  });
-}
 
 function boxAllElements(renderer, voices, which) {
   for (var i = 0; i < which.length; i++) {
@@ -25502,6 +26350,8 @@ module.exports = drawTriplet;
   \*********************************/
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+var drawGlissando = __webpack_require__(/*! ./glissando */ "./src/write/draw/glissando.js");
+
 var drawCrescendo = __webpack_require__(/*! ./crescendo */ "./src/write/draw/crescendo.js");
 
 var drawDynamics = __webpack_require__(/*! ./dynamics */ "./src/write/draw/dynamics.js");
@@ -25601,6 +26451,10 @@ function drawVoice(renderer, params, bartop, selectables, staffPos) {
       renderer.controller.classes.incrMeasure();
     } else {
       switch (child.type) {
+        case "GlissandoElem":
+          child.elemset = drawGlissando(renderer, child, selectables);
+          break;
+
         case "CrescendoElem":
           child.elemset = drawCrescendo(renderer, child, selectables);
           break;
@@ -27168,7 +28022,7 @@ module.exports = layoutVoice;
 
 var spacing = __webpack_require__(/*! ./abc_spacing */ "./src/write/abc_spacing.js");
 
-function setupSelection(engraver) {
+function setupSelection(engraver, svgs) {
   engraver.rangeHighlight = rangeHighlight;
 
   if (engraver.dragging) {
@@ -27185,14 +28039,21 @@ function setupSelection(engraver) {
     }
   }
 
-  engraver.renderer.paper.svg.addEventListener('mousedown', mouseDown.bind(engraver));
-  engraver.renderer.paper.svg.addEventListener('mousemove', mouseMove.bind(engraver));
-  engraver.renderer.paper.svg.addEventListener('mouseup', mouseUp.bind(engraver));
+  for (var i = 0; i < svgs.length; i++) {
+    svgs[i].addEventListener('touchstart', mouseDown.bind(engraver));
+    svgs[i].addEventListener('touchmove', mouseMove.bind(engraver));
+    svgs[i].addEventListener('touchend', mouseUp.bind(engraver));
+    svgs[i].addEventListener('mousedown', mouseDown.bind(engraver));
+    svgs[i].addEventListener('mousemove', mouseMove.bind(engraver));
+    svgs[i].addEventListener('mouseup', mouseUp.bind(engraver));
+  }
 }
 
-function getCoord(ev, svg) {
+function getCoord(ev) {
   var scaleX = 1;
-  var scaleY = 1; // when renderer.options.responsive === 'resize' the click coords are in relation to the HTML
+  var scaleY = 1;
+  var svg = ev.target.closest('svg');
+  var yOffset = 0; // when renderer.options.responsive === 'resize' the click coords are in relation to the HTML
   // element, we need to convert to the SVG viewBox coords
 
   if (svg.viewBox.baseVal) {
@@ -27200,6 +28061,7 @@ function getCoord(ev, svg) {
     // Chrome makes these values null when no viewBox is given.
     if (svg.viewBox.baseVal.width !== 0) scaleX = svg.viewBox.baseVal.width / svg.clientWidth;
     if (svg.viewBox.baseVal.height !== 0) scaleY = svg.viewBox.baseVal.height / svg.clientHeight;
+    yOffset = svg.viewBox.baseVal.y;
   }
 
   var svgClicked = ev.target.tagName === "svg";
@@ -27217,7 +28079,7 @@ function getCoord(ev, svg) {
   x = x * scaleX;
   y = y * scaleY; //console.log(x, y)
 
-  return [x, y];
+  return [x, y + yOffset];
 }
 
 function elementFocused(ev) {
@@ -27298,7 +28160,7 @@ function keyboardSelection(ev) {
 
 function findElementInHistory(selectables, el) {
   for (var i = 0; i < selectables.length; i++) {
-    if (el === selectables[i].svgEl) return i;
+    if (el.dataset.index === selectables[i].svgEl.dataset.index) return i;
   }
 
   return -1;
@@ -27391,7 +28253,7 @@ function getMousePosition(self, ev) {
     y = box[1]; //console.log("clicked on", clickedOn, x, y, self.selectables[clickedOn].svgEl.getBBox(), ev.target.getBBox());
   } else {
     // See if they clicked close to an element.
-    box = getCoord(ev, self.renderer.paper.svg);
+    box = getCoord(ev);
     x = box[0];
     y = box[1];
     clickedOn = findElementByCoord(self, x, y); //console.log("clicked near", clickedOn, x, y, printEl(ev.target));
@@ -27404,11 +28266,28 @@ function getMousePosition(self, ev) {
   };
 }
 
+function attachMissingTouchEventAttributes(touchEv) {
+  var rect = touchEv.target.getBoundingClientRect();
+  var offsetX = touchEv.touches[0].pageX - rect.left;
+  var offsetY = touchEv.touches[0].pageY - rect.top;
+  touchEv.touches[0].offsetX = offsetX;
+  touchEv.touches[0].offsetY = offsetY;
+  touchEv.touches[0].layerX = touchEv.touches[0].pageX;
+  touchEv.touches[0].layerY = touchEv.touches[0].pageY;
+}
+
 function mouseDown(ev) {
   // "this" is the EngraverController because of the bind(this) when setting the event listener.
-  var positioning = getMousePosition(this, ev); // Only start dragging if the user clicked close enough to an element and clicked with the main mouse button.
+  var _ev = ev;
+
+  if (ev.type === 'touchstart') {
+    attachMissingTouchEventAttributes(ev);
+    _ev = ev.touches[0];
+  }
+
+  var positioning = getMousePosition(this, _ev); // Only start dragging if the user clicked close enough to an element and clicked with the main mouse button.
 
-  if (positioning.clickedOn >= 0 && ev.button === 0) {
+  if (positioning.clickedOn >= 0 && (ev.type === 'touchstart' || ev.button === 0)) {
     this.dragTarget = this.selectables[positioning.clickedOn];
     this.dragIndex = positioning.clickedOn;
     this.dragMechanism = "mouse";
@@ -27425,9 +28304,17 @@ function mouseDown(ev) {
 }
 
 function mouseMove(ev) {
-  // "this" is the EngraverController because of the bind(this) when setting the event listener.
+  var _ev = ev;
+
+  if (ev.type === 'touchmove') {
+    attachMissingTouchEventAttributes(ev);
+    _ev = ev.touches[0];
+  }
+
+  this.lastTouchMove = ev; // "this" is the EngraverController because of the bind(this) when setting the event listener.
+
   if (!this.dragTarget || !this.dragging || !this.dragTarget.isDraggable || this.dragMechanism !== 'mouse') return;
-  var positioning = getMousePosition(this, ev);
+  var positioning = getMousePosition(this, _ev);
   var yDist = Math.round((positioning.y - this.dragMouseStart.y) / spacing.STEP);
 
   if (yDist !== this.dragYStep) {
@@ -27438,6 +28325,13 @@ function mouseMove(ev) {
 
 function mouseUp(ev) {
   // "this" is the EngraverController because of the bind(this) when setting the event listener.
+  var _ev = ev;
+
+  if (ev.type === 'touchend') {
+    attachMissingTouchEventAttributes(this.lastTouchMove);
+    _ev = this.lastTouchMove.touches[0];
+  }
+
   if (!this.dragTarget) return;
   clearSelection.bind(this)();
 
@@ -27446,7 +28340,7 @@ function mouseUp(ev) {
     this.dragTarget.absEl.highlight(undefined, this.selectionColor);
   }
 
-  notifySelect.bind(this)(this.dragTarget, this.dragYStep, this.selectables.length, this.dragIndex, ev);
+  notifySelect.bind(this)(this.dragTarget, this.dragYStep, this.selectables.length, this.dragIndex, _ev);
 
   if (this.dragTarget.svgEl && this.dragTarget.svgEl.focus) {
     this.dragTarget.svgEl.focus();
@@ -28175,7 +29069,7 @@ function TopText(metaText, metaTextInfo, formatting, lines, width, isPrint, padd
         font: 'infofont',
         klass: 'meta-top rhythm',
         absElemType: "rhythm",
-        noMove: true,
+        noMove: noMove,
         info: metaTextInfo.rhythm,
         name: "rhythm"
       }, getTextSize);
@@ -28253,7 +29147,7 @@ module.exports = unhighlight;
   \********************/
 /***/ (function(module) {
 
-var version = '6.0.3';
+var version = '6.1.1';
 module.exports = version;
 
 /***/ })