abcjs 6.3.0 → 6.4.0

package/dist/abcjs-basic.js

@@ -54,6 +54,7 @@ Object.keys(tuneBook).forEach(function (key) {
   abcjs[key] = tuneBook[key];
 });
 abcjs.renderAbc = __webpack_require__(/*! ./src/api/abc_tunebook_svg */ "./src/api/abc_tunebook_svg.js");
+abcjs.tuneMetrics = __webpack_require__(/*! ./src/api/tune-metrics */ "./src/api/tune-metrics.js");
 abcjs.TimingCallbacks = __webpack_require__(/*! ./src/api/abc_timing_callbacks */ "./src/api/abc_timing_callbacks.js");
 var glyphs = __webpack_require__(/*! ./src/write/creation/glyphs */ "./src/write/creation/glyphs.js");
 abcjs.setGlyph = glyphs.setSymbol;
@@ -1088,6 +1089,32 @@ module.exports = renderAbc;
 
 /***/ }),
 
+/***/ "./src/api/tune-metrics.js":
+/*!*********************************!*\
+  !*** ./src/api/tune-metrics.js ***!
+  \*********************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var tunebook = __webpack_require__(/*! ./abc_tunebook */ "./src/api/abc_tunebook.js");
+var EngraverController = __webpack_require__(/*! ../write/engraver-controller */ "./src/write/engraver-controller.js");
+var tuneMetrics = function tuneMetrics(abc, params) {
+  function callback(div, tune, tuneNumber, abcString) {
+    div = document.createElement("div");
+    div.setAttribute("style", "visibility: hidden;");
+    document.body.appendChild(div);
+    var engraver_controller = new EngraverController(div, params);
+    var widths = engraver_controller.getMeasureWidths(tune);
+    div.parentNode.removeChild(div);
+    return {
+      sections: widths
+    };
+  }
+  return tunebook.renderEngine(callback, "*", abc, params);
+};
+module.exports = tuneMetrics;
+
+/***/ }),
+
 /***/ "./src/const/key-accidentals.js":
 /*!**************************************!*\
   !*** ./src/const/key-accidentals.js ***!
@@ -1666,9 +1693,12 @@ var Tune = function Tune() {
           eventHash["event" + voiceTimeMilliseconds].measureStart = true;
           nextIsBar = false;
         }
-        if (isTiedToNext) isTiedState = voiceTimeMilliseconds;
+        // TODO-PER: There doesn't seem to be a harm in letting ties be two different notes and it fixes a bug when a tie goes to a new line. If there aren't other problems with this change, then the variable can be removed completely. 
+        // if (isTiedToNext)
+        // 	isTiedState = voiceTimeMilliseconds;
       }
     }
+
     return {
       isTiedState: isTiedState,
       duration: realDuration / timeDivider,
@@ -1896,6 +1926,14 @@ var Tune = function Tune() {
   this.deline = function (options) {
     return delineTune(this.lines, options);
   };
+  this.findSelectableElement = function (target) {
+    if (this.engraver && this.engraver.selectables) return this.engraver.findSelectableElement(target);
+    return null;
+  };
+  this.getSelectableArray = function () {
+    if (this.engraver && this.engraver.selectables) return this.engraver.selectables;
+    return [];
+  };
 };
 module.exports = Tune;
 
@@ -2151,7 +2189,7 @@ try {
   // if we aren't in a browser, this code will crash, but it is not needed then either.
 }
 var EditArea = function EditArea(textareaid) {
-  this.textarea = document.getElementById(textareaid);
+  if (typeof textareaid === "string") this.textarea = document.getElementById(textareaid);else this.textarea = textareaid;
   this.initialText = this.textarea.value;
   this.isDragging = false;
 };
@@ -2779,7 +2817,9 @@ var Parse = function Parse() {
       setupEvents: tune.setupEvents,
       setTiming: tune.setTiming,
       setUpAudio: tune.setUpAudio,
-      deline: tune.deline
+      deline: tune.deline,
+      findSelectableElement: tune.findSelectableElement,
+      getSelectableArray: tune.getSelectableArray
     };
     if (tune.lineBreaks) t.lineBreaks = tune.lineBreaks;
     if (tune.visualTranspose) t.visualTranspose = tune.visualTranspose;
@@ -4353,6 +4393,7 @@ var parseDirective = {};
       case "pageheight":
       case "pagewidth":
       case "rightmargin":
+      case "stafftopmargin":
       case "staffsep":
       case "staffwidth":
       case "subtitlespace":
@@ -4753,6 +4794,10 @@ var parseDirective = {};
             if (tokens.length !== 1 || tokens[0].type !== 'number') warn("Directive \"" + cmd + "\" requires a number as a parameter.");
             tune.formatting.fontboxpadding = tokens[0].floatt;
             break;
+          case "stafftopmargin":
+            if (tokens.length !== 1 || tokens[0].type !== 'number') warn("Directive \"" + cmd + "\" requires a number as a parameter.");
+            tune.formatting.stafftopmargin = tokens[0].floatt;
+            break;
           case "stretchlast":
             var sl = parseStretchLast(tokens);
             if (sl.value !== undefined) tune.formatting.stretchlast = sl.value;
@@ -11209,7 +11254,7 @@ module.exports = strTranspose;
 // It also extracts guitar chords to a separate voice and resolves their rhythm.
 
 var flatten;
-var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/abc_common.js");
+var ChordTrack = __webpack_require__(/*! ./chord-track */ "./src/synth/chord-track.js");
 var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pitches-to-perc.js");
 (function () {
   "use strict";
@@ -11229,25 +11274,13 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
   var lastNoteDurationPosition;
   var currentTrackName;
   var lastEventTime;
+  var chordTrack;
   var meter = {
     num: 4,
     den: 4
   };
-  var chordTrack;
-  var chordSourceTrack;
-  var chordTrackFinished;
-  var chordChannel;
-  var bassInstrument = 0;
-  var chordInstrument = 0;
   var drumInstrument = 128;
-  var boomVolume = 64;
-  var chickVolume = 48;
-  var currentChords;
-  var lastChord;
-  var chordLastBar;
   var lastBarTime;
-  var gChordTacet = false;
-  var hasRhythmHead = false;
   var doBeatAccents = true;
   var stressBeat1 = 105;
   var stressBeatDown = 95;
@@ -11285,25 +11318,10 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     currentTrackName = undefined;
     lastEventTime = 0;
     percmap = percmap_;
-
-    // For resolving chords.
     meter = {
       num: 4,
       den: 4
     };
-    chordTrack = [];
-    chordSourceTrack = false;
-    chordChannel = voices.length; // first free channel for chords
-    chordTrackFinished = false;
-    currentChords = [];
-    bassInstrument = midiOptions.bassprog && midiOptions.bassprog.length === 1 ? midiOptions.bassprog[0] : 0;
-    chordInstrument = midiOptions.chordprog && midiOptions.chordprog.length === 1 ? midiOptions.chordprog[0] : 0;
-    boomVolume = midiOptions.bassvol && midiOptions.bassvol.length === 1 ? midiOptions.bassvol[0] : 64;
-    chickVolume = midiOptions.chordvol && midiOptions.chordvol.length === 1 ? midiOptions.chordvol[0] : 48;
-    lastChord = undefined;
-    chordLastBar = undefined;
-    gChordTacet = options.chordsOff ? true : false;
-    hasRhythmHead = false;
     doBeatAccents = true;
     stressBeat1 = 105;
     stressBeatDown = 95;
@@ -11320,10 +11338,19 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     drumBars = 1;
     if (voices.length > 0 && voices[0].length > 0) pickupLength = voices[0][0].pickupLength;
 
+    // For resolving chords.
+    if (options.bassprog !== undefined && !midiOptions.bassprog) midiOptions.bassprog = [options.bassprog];
+    if (options.bassvol !== undefined && !midiOptions.bassvol) midiOptions.bassvol = [options.bassvol];
+    if (options.chordprog !== undefined && !midiOptions.chordprog) midiOptions.chordprog = [options.chordprog];
+    if (options.chordvol !== undefined && !midiOptions.chordvol) midiOptions.chordvol = [options.chordvol];
+    if (options.gchord !== undefined && !midiOptions.gchord) midiOptions.gchord = [options.gchord];
+    chordTrack = new ChordTrack(voices.length, options.chordsOff, midiOptions, meter);
+
     // First adjust the input to resolve ties, set the starting time for each note, etc. That will make the rest of the logic easier
     preProcess(voices, options);
     for (var i = 0; i < voices.length; i++) {
       transpose = 0;
+      chordTrack.setTranspose(transpose);
       lastNoteDurationPosition = -1;
       var voice = voices[i];
       currentTrack = [{
@@ -11333,6 +11360,7 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
       }];
       currentTrackName = undefined;
       lastBarTime = 0;
+      chordTrack.setLastBarTime(0);
       var voiceOff = false;
       if (options.voicesOff === true) voiceOff = true;else if (options.voicesOff && options.voicesOff.length && options.voicesOff.indexOf(i) >= 0) voiceOff = true;
       for (var j = 0; j < voice.length; j++) {
@@ -11346,8 +11374,7 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
             };
             break;
           case "note":
-            var setChordTrack = writeNote(element, voiceOff);
-            if (setChordTrack) chordSourceTrack = i;
+            writeNote(element, voiceOff);
             break;
           case "key":
             accidentals = setKeySignature(element);
@@ -11355,27 +11382,27 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
           case "meter":
             if (!startingMeter) startingMeter = element;
             meter = element;
+            chordTrack.setMeter(meter);
             beatFraction = getBeatFraction(meter);
             alignDrumToMeter();
             break;
           case "tempo":
             if (!startingTempo) startingTempo = element.qpm;else tempoChangeFactor = element.qpm ? startingTempo / element.qpm : 1;
+            chordTrack.setTempoChangeFactor(tempoChangeFactor);
             break;
           case "transpose":
             transpose = element.transpose;
+            chordTrack.setTranspose(transpose);
             break;
           case "bar":
-            if (chordTrack.length > 0 && (chordSourceTrack === false || i === chordSourceTrack)) {
-              resolveChords(lastBarTime, timeToRealTime(element.time));
-              currentChords = [];
-            }
+            chordTrack.barEnd(element);
             barAccidentals = [];
             if (i === 0)
               // Only write the drum part on the first voice so that it is not duplicated.
               writeDrum(voices.length + 1);
-            hasRhythmHead = false; // decide whether there are rhythm heads each measure.
-            chordLastBar = lastChord;
+            chordTrack.setRhythmHead(false); // decide whether there are rhythm heads each measure.
             lastBarTime = timeToRealTime(element.time);
+            chordTrack.setLastBarTime(lastBarTime);
             break;
           case "bagpipes":
             bagpipes = true;
@@ -11402,8 +11429,8 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
             drumDefinition = normalizeDrumDefinition(element.params);
             alignDrumToMeter();
             break;
-          case "gchord":
-            if (!options.chordsOff) gChordTacet = element.tacet;
+          case "gchordOn":
+            chordTrack.gChordOn(element);
             break;
           case "beat":
             stressBeat1 = element.beats[0];
@@ -11420,6 +11447,13 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
           case "beataccents":
             doBeatAccents = element.value;
             break;
+          case "gchord":
+          case "bassprog":
+          case "chordprog":
+          case "bassvol":
+          case "chordvol":
+            chordTrack.paramChange(element);
+            break;
           default:
             // This should never happen
             console.log("MIDI creation. Unknown el_type: " + element.el_type + "\n"); // jshint ignore:line
@@ -11429,16 +11463,14 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
       if (currentTrack[0].instrument === undefined) currentTrack[0].instrument = instrument ? instrument : 0;
       if (currentTrackName) currentTrack.unshift(currentTrackName);
       tracks.push(currentTrack);
-      if (!chordTrackEmpty())
-        // Don't do chords on more than one track, so turn off chord detection after we create it.
-        chordTrackFinished = true;
+      chordTrack.finish();
       if (drumTrack.length > 0)
         // Don't do drums on more than one track, so turn off drum after we create it.
         drumTrackFinished = true;
     }
     // See if any notes are octaves played at the same time. If so, raise the pitch of the higher one.
     if (options.detuneOctave) findOctaves(tracks, parseInt(options.detuneOctave, 10));
-    if (!chordTrackEmpty()) tracks.push(chordTrack);
+    chordTrack.addTrack(tracks);
     if (drumTrack.length > 0) tracks.push(drumTrack);
     return {
       tempo: startingTempo,
@@ -11455,13 +11487,6 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
       }
     }
   }
-  function chordTrackEmpty() {
-    var isEmpty = true;
-    for (var i = 0; i < chordTrack.length && isEmpty; i++) {
-      if (chordTrack[i].cmd === 'note') isEmpty = false;
-    }
-    return isEmpty;
-  }
   function timeToRealTime(time) {
     return time / 1000000;
   }
@@ -11549,48 +11574,6 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     }
     return 0.25;
   }
-  //
-  // The algorithm for chords is:
-  // - The chords are done in a separate track.
-  // - If there are notes before the first chord, then put that much silence to start the track.
-  // - The pattern of chord expression depends on the meter, and how many chords are in a measure.
-  // - There is a possibility that a measure will have an incorrect number of beats, if that is the case, then
-  // start the pattern anew on the next measure number.
-  // - If a chord root is not A-G, then ignore it as if the chord wasn't there at all.
-  // - If a chord modification isn't in our supported list, change it to a major triad.
-  //
-  // - If there is only one chord in a measure:
-  //		- If 2/4, play root chord
-  //		- If cut time, play root(1) chord(3)
-  //		- If 3/4, play root chord chord
-  //		- If 4/4 or common time, play root chord fifth chord
-  //		- If 6/8, play root(1) chord(3) fifth(4) chord(6)
-  //		- For any other meter, play the full chord on each beat. (TODO-PER: expand this as more support is added.)
-  //
-  //	- If there is a chord specified that is not on a beat, move it earlier to the previous beat, unless there is already a chord on that beat.
-  //	- Otherwise, move it later, unless there is already a chord on that beat.
-  // 	- Otherwise, ignore it. (TODO-PER: expand this as more support is added.)
-  //
-  // - If there is a chord on the second beat, play a chord for the first beat instead of a bass note.
-  // - Likewise, if there is a chord on the fourth beat of 4/4, play a chord on the third beat instead of a bass note.
-  //
-  // If there is any note in the melody that has a rhythm head, then assume the melody controls the rhythm, so that is
-  // the same as a break.
-  var breakSynonyms = ['break', '(break)', 'no chord', 'n.c.', 'tacet'];
-  function findChord(elem) {
-    if (gChordTacet) return 'break';
-
-    // TODO-PER: Just using the first chord if there are more than one.
-    if (chordTrackFinished || !elem.chord || elem.chord.length === 0) return null;
-
-    // Return the first annotation that is a regular chord: that is, it is in the default place or is a recognized "tacet" phrase.
-    for (var i = 0; i < elem.chord.length; i++) {
-      var ch = elem.chord[i];
-      if (ch.position === 'default') return ch.name;
-      if (breakSynonyms.indexOf(ch.name.toLowerCase()) >= 0) return 'break';
-    }
-    return null;
-  }
   function calcBeat(measureStart, beatLength, currTime) {
     var distanceFromStart = currTime - measureStart;
     return distanceFromStart / beatLength;
@@ -11606,7 +11589,7 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     } else if (pickupLength > beat) {
       volume = stressBeatUp;
     } else {
-      var barLength = meter.num / meter.den;
+      //var barLength = meter.num / meter.den;
       var barBeat = calcBeat(lastBarTime, getBeatFraction(meter), beat);
       if (barBeat === 0) volume = stressBeat1;else if (parseInt(barBeat, 10) === barBeat) volume = stressBeatDown;else volume = stressBeatUp;
     }
@@ -11618,34 +11601,6 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     if (volume > 127) volume = 127;
     return voiceOff ? 0 : volume;
   }
-  function processChord(elem) {
-    var firstChord = false;
-    var chord = findChord(elem);
-    if (chord) {
-      var c = interpretChord(chord);
-      // If this isn't a recognized chord, just completely ignore it.
-      if (c) {
-        // If we ever have a chord in this voice, then we add the chord track.
-        // However, if there are chords on more than one voice, then just use the first voice.
-        if (chordTrack.length === 0) {
-          firstChord = true;
-          chordTrack.push({
-            cmd: 'program',
-            channel: chordChannel,
-            instrument: chordInstrument
-          });
-        }
-        lastChord = c;
-        var barBeat = calcBeat(lastBarTime, getBeatFraction(meter), timeToRealTime(elem.time));
-        currentChords.push({
-          chord: lastChord,
-          beat: barBeat,
-          start: timeToRealTime(elem.time)
-        });
-      }
-    }
-    return firstChord;
-  }
   function findNoteModifications(elem, velocity) {
     var ret = {};
     if (elem.decoration) {
@@ -11830,9 +11785,10 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     // If there are guitar chords, then they are put in a separate track, but they have the same format.
     //
 
-    var trackStartingIndex = currentTrack.length;
+    //var trackStartingIndex = currentTrack.length;
+
     var velocity = processVolume(timeToRealTime(elem.time), voiceOff);
-    var setChordTrack = processChord(elem);
+    chordTrack.processChord(elem);
 
     // if there are grace notes, then also play them.
     // I'm not sure there is an exact rule for the length of the notes. My rule, unless I find
@@ -11884,15 +11840,7 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
       // TODO-PER: Can also make a different sound on style=x and style=harmonic
       var ePitches = elem.pitches;
       if (elem.style === "rhythm") {
-        hasRhythmHead = true;
-        if (lastChord && lastChord.chick) {
-          ePitches = [];
-          for (var i2 = 0; i2 < lastChord.chick.length; i2++) {
-            var note2 = parseCommon.clone(elem.pitches[0]);
-            note2.actualPitch = lastChord.chick[i2];
-            ePitches.push(note2);
-          }
-        }
+        ePitches = chordTrack.setRhythmHead(true, elem);
       }
       if (elem.elem) elem.elem.midiPitches = [];
       for (var i = 0; i < ePitches.length; i++) {
@@ -11944,7 +11892,6 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     }
     var realDur = getRealDuration(elem);
     lastEventTime = Math.max(lastEventTime, timeToRealTime(elem.time) + durationRounded(realDur));
-    return setChordTrack;
   }
   function getRealDuration(elem) {
     if (elem.pitches && elem.pitches.length > 0 && elem.pitches[0]) return elem.pitches[0].duration;
@@ -12093,349 +12040,6 @@ var pitchesToPerc = __webpack_require__(/*! ./pitches-to-perc */ "./src/synth/pi
     if (pitch < 0) pitch += 7;
     return pitch;
   }
-  var basses = {
-    'A': 33,
-    'B': 35,
-    'C': 36,
-    'D': 38,
-    'E': 40,
-    'F': 41,
-    'G': 43
-  };
-  function interpretChord(name) {
-    // chords have the format:
-    // [root][acc][modifier][/][bass][acc]
-    // (The chord might be surrounded by parens. Just ignore them.)
-    // root must be present and must be from A-G.
-    // acc is optional and can be # or b
-    // The modifier can be a wide variety of things, like "maj7". As they are discovered, more are supported here.
-    // If there is a slash, then there is a bass note, which can be from A-G, with an optional acc.
-    // If the root is unrecognized, then "undefined" is returned and there is no chord.
-    // If the modifier is unrecognized, a major triad is returned.
-    // If the bass notes is unrecognized, it is ignored.
-    if (name.length === 0) return undefined;
-    if (name === 'break') return {
-      chick: []
-    };
-    var root = name.substring(0, 1);
-    if (root === '(') {
-      name = name.substring(1, name.length - 2);
-      if (name.length === 0) return undefined;
-      root = name.substring(0, 1);
-    }
-    var bass = basses[root];
-    if (!bass)
-      // If the bass note isn't listed, then this was an unknown root. Only A-G are accepted.
-      return undefined;
-    // Don't transpose the chords more than an octave.
-    var chordTranspose = transpose;
-    while (chordTranspose < -8) {
-      chordTranspose += 12;
-    }
-    while (chordTranspose > 8) {
-      chordTranspose -= 12;
-    }
-    bass += chordTranspose;
-    var bass2 = bass - 5; // The alternating bass is a 4th below
-    var chick;
-    if (name.length === 1) chick = chordNotes(bass, '');
-    var remaining = name.substring(1);
-    var acc = remaining.substring(0, 1);
-    if (acc === 'b' || acc === '♭') {
-      bass--;
-      bass2--;
-      remaining = remaining.substring(1);
-    } else if (acc === '#' || acc === '♯') {
-      bass++;
-      bass2++;
-      remaining = remaining.substring(1);
-    }
-    var arr = remaining.split('/');
-    chick = chordNotes(bass, arr[0]);
-    // If the 5th is altered then the bass is altered. Normally the bass is 7 from the root, so adjust if it isn't.
-    if (chick.length >= 3) {
-      var fifth = chick[2] - chick[0];
-      bass2 = bass2 + fifth - 7;
-    }
-    if (arr.length === 2) {
-      var explicitBass = basses[arr[1].substring(0, 1)];
-      if (explicitBass) {
-        var bassAcc = arr[1].substring(1);
-        var bassShift = {
-          '#': 1,
-          '♯': 1,
-          'b': -1,
-          '♭': -1
-        }[bassAcc] || 0;
-        bass = basses[arr[1].substring(0, 1)] + bassShift + chordTranspose;
-        bass2 = bass;
-      }
-    }
-    return {
-      boom: bass,
-      boom2: bass2,
-      chick: chick
-    };
-  }
-  var chordIntervals = {
-    // diminished (all flat 5 chords)
-    'dim': [0, 3, 6],
-    '°': [0, 3, 6],
-    '˚': [0, 3, 6],
-    'dim7': [0, 3, 6, 9],
-    '°7': [0, 3, 6, 9],
-    '˚7': [0, 3, 6, 9],
-    'ø7': [0, 3, 6, 10],
-    'm7(b5)': [0, 3, 6, 10],
-    'm7b5': [0, 3, 6, 10],
-    'm7♭5': [0, 3, 6, 10],
-    '-7(b5)': [0, 3, 6, 10],
-    '-7b5': [0, 3, 6, 10],
-    '7b5': [0, 4, 6, 10],
-    '7(b5)': [0, 4, 6, 10],
-    '7♭5': [0, 4, 6, 10],
-    '7(b9,b5)': [0, 4, 6, 10, 13],
-    '7b9,b5': [0, 4, 6, 10, 13],
-    '7(#9,b5)': [0, 4, 6, 10, 15],
-    '7#9b5': [0, 4, 6, 10, 15],
-    'maj7(b5)': [0, 4, 6, 11],
-    'maj7b5': [0, 4, 6, 11],
-    '13(b5)': [0, 4, 6, 10, 14, 21],
-    '13b5': [0, 4, 6, 10, 14, 21],
-    // minor (all normal 5, minor 3 chords)
-    'm': [0, 3, 7],
-    '-': [0, 3, 7],
-    'm6': [0, 3, 7, 9],
-    '-6': [0, 3, 7, 9],
-    'm7': [0, 3, 7, 10],
-    '-7': [0, 3, 7, 10],
-    '-(b6)': [0, 3, 7, 8],
-    '-b6': [0, 3, 7, 8],
-    '-6/9': [0, 3, 7, 9, 14],
-    '-7(b9)': [0, 3, 7, 10, 13],
-    '-7b9': [0, 3, 7, 10, 13],
-    '-maj7': [0, 3, 7, 11],
-    '-9+7': [0, 3, 7, 11, 13],
-    '-11': [0, 3, 7, 11, 14, 17],
-    'm11': [0, 3, 7, 11, 14, 17],
-    '-maj9': [0, 3, 7, 11, 14],
-    '-∆9': [0, 3, 7, 11, 14],
-    'mM9': [0, 3, 7, 11, 14],
-    // major (all normal 5, major 3 chords)
-    'M': [0, 4, 7],
-    '6': [0, 4, 7, 9],
-    '6/9': [0, 4, 7, 9, 14],
-    '6add9': [0, 4, 7, 9, 14],
-    '69': [0, 4, 7, 9, 14],
-    '7': [0, 4, 7, 10],
-    '9': [0, 4, 7, 10, 14],
-    '11': [0, 7, 10, 14, 17],
-    '13': [0, 4, 7, 10, 14, 21],
-    '7b9': [0, 4, 7, 10, 13],
-    '7♭9': [0, 4, 7, 10, 13],
-    '7(b9)': [0, 4, 7, 10, 13],
-    '7(#9)': [0, 4, 7, 10, 15],
-    '7#9': [0, 4, 7, 10, 15],
-    '(13)': [0, 4, 7, 10, 14, 21],
-    '7(9,13)': [0, 4, 7, 10, 14, 21],
-    '7(#9,b13)': [0, 4, 7, 10, 15, 20],
-    '7(#11)': [0, 4, 7, 10, 14, 18],
-    '7#11': [0, 4, 7, 10, 14, 18],
-    '7(b13)': [0, 4, 7, 10, 20],
-    '7b13': [0, 4, 7, 10, 20],
-    '9(#11)': [0, 4, 7, 10, 14, 18],
-    '9#11': [0, 4, 7, 10, 14, 18],
-    '13(#11)': [0, 4, 7, 10, 18, 21],
-    '13#11': [0, 4, 7, 10, 18, 21],
-    'maj7': [0, 4, 7, 11],
-    '∆7': [0, 4, 7, 11],
-    'Δ7': [0, 4, 7, 11],
-    'maj9': [0, 4, 7, 11, 14],
-    'maj7(9)': [0, 4, 7, 11, 14],
-    'maj7(11)': [0, 4, 7, 11, 17],
-    'maj7(#11)': [0, 4, 7, 11, 18],
-    'maj7(13)': [0, 4, 7, 14, 21],
-    'maj7(9,13)': [0, 4, 7, 11, 14, 21],
-    '7sus4': [0, 5, 7, 10],
-    'm7sus4': [0, 3, 7, 10, 17],
-    'sus4': [0, 5, 7],
-    'sus2': [0, 2, 7],
-    '7sus2': [0, 2, 7, 10],
-    '9sus4': [0, 5, 7, 10, 14],
-    '13sus4': [0, 5, 7, 10, 14, 21],
-    // augmented (all sharp 5 chords)
-    'aug7': [0, 4, 8, 10],
-    '+7': [0, 4, 8, 10],
-    '+': [0, 4, 8],
-    '7#5': [0, 4, 8, 10],
-    '7♯5': [0, 4, 8, 10],
-    '7+5': [0, 4, 8, 10],
-    '9#5': [0, 4, 8, 10, 14],
-    '9♯5': [0, 4, 8, 10, 14],
-    '9+5': [0, 4, 8, 10, 14],
-    '-7(#5)': [0, 3, 8, 10],
-    '-7#5': [0, 3, 8, 10],
-    '7(#5)': [0, 4, 8, 10],
-    '7(b9,#5)': [0, 4, 8, 10, 13],
-    '7b9#5': [0, 4, 8, 10, 13],
-    'maj7(#5)': [0, 4, 8, 11],
-    'maj7#5': [0, 4, 8, 11],
-    'maj7(#5,#11)': [0, 4, 8, 11, 18],
-    'maj7#5#11': [0, 4, 8, 11, 18],
-    '9(#5)': [0, 4, 8, 10, 14],
-    '13(#5)': [0, 4, 8, 10, 14, 21],
-    '13#5': [0, 4, 8, 10, 14, 21]
-  };
-  function chordNotes(bass, modifier) {
-    var intervals = chordIntervals[modifier];
-    if (!intervals) {
-      if (modifier.slice(0, 2).toLowerCase() === 'ma' || modifier[0] === 'M') intervals = chordIntervals.M;else if (modifier[0] === 'm' || modifier[0] === '-') intervals = chordIntervals.m;else intervals = chordIntervals.M;
-    }
-    bass += 12; // the chord is an octave above the bass note.
-    var notes = [];
-    for (var i = 0; i < intervals.length; i++) {
-      notes.push(bass + intervals[i]);
-    }
-    return notes;
-  }
-  function writeBoom(boom, beatLength, volume, beat, noteLength) {
-    // undefined means there is a stop time.
-    if (boom !== undefined) chordTrack.push({
-      cmd: 'note',
-      pitch: boom,
-      volume: volume,
-      start: lastBarTime + beat * durationRounded(beatLength),
-      duration: durationRounded(noteLength),
-      gap: 0,
-      instrument: bassInstrument
-    });
-  }
-  function writeChick(chick, beatLength, volume, beat, noteLength) {
-    for (var c = 0; c < chick.length; c++) {
-      chordTrack.push({
-        cmd: 'note',
-        pitch: chick[c],
-        volume: volume,
-        start: lastBarTime + beat * durationRounded(beatLength),
-        duration: durationRounded(noteLength),
-        gap: 0,
-        instrument: chordInstrument
-      });
-    }
-  }
-  var rhythmPatterns = {
-    "2/2": ['boom', 'chick'],
-    "2/4": ['boom', 'chick'],
-    "3/4": ['boom', 'chick', 'chick'],
-    "4/4": ['boom', 'chick', 'boom2', 'chick'],
-    "5/4": ['boom', 'chick', 'chick', 'boom2', 'chick'],
-    "6/8": ['boom', '', 'chick', 'boom2', '', 'chick'],
-    "9/8": ['boom', '', 'chick', 'boom2', '', 'chick', 'boom2', '', 'chick'],
-    "12/8": ['boom', '', 'chick', 'boom2', '', 'chick', 'boom', '', 'chick', 'boom2', '', 'chick']
-  };
-  function resolveChords(startTime, endTime) {
-    var num = meter.num;
-    var den = meter.den;
-    var beatLength = 1 / den;
-    var noteLength = beatLength / 2;
-    var pattern = rhythmPatterns[num + '/' + den];
-    var thisMeasureLength = parseInt(num, 10) / parseInt(den, 10);
-    var portionOfAMeasure = thisMeasureLength - (endTime - startTime) / tempoChangeFactor;
-    if (Math.abs(portionOfAMeasure) < 0.00001) portionOfAMeasure = false;
-    if (!pattern || portionOfAMeasure) {
-      // If it is an unsupported meter, or this isn't a full bar, just chick on each beat.
-      pattern = [];
-      var beatsPresent = (endTime - startTime) / tempoChangeFactor / beatLength;
-      for (var p = 0; p < beatsPresent; p++) {
-        pattern.push("chick");
-      }
-    }
-    //console.log(startTime, pattern, currentChords, lastChord, portionOfAMeasure)
-
-    if (currentChords.length === 0) {
-      // there wasn't a new chord this measure, so use the last chord declared.
-      currentChords.push({
-        beat: 0,
-        chord: lastChord
-      });
-    }
-    if (currentChords[0].beat !== 0 && lastChord) {
-      // this is the case where there is a chord declared in the measure, but not on its first beat.
-      if (chordLastBar) currentChords.unshift({
-        beat: 0,
-        chord: chordLastBar
-      });
-    }
-    if (currentChords.length === 1) {
-      for (var m = currentChords[0].beat; m < pattern.length; m++) {
-        if (!hasRhythmHead) {
-          switch (pattern[m]) {
-            case 'boom':
-              writeBoom(currentChords[0].chord.boom, beatLength, boomVolume, m, noteLength);
-              break;
-            case 'boom2':
-              writeBoom(currentChords[0].chord.boom2, beatLength, boomVolume, m, noteLength);
-              break;
-            case 'chick':
-              writeChick(currentChords[0].chord.chick, beatLength, chickVolume, m, noteLength);
-              break;
-          }
-        }
-      }
-      return;
-    }
-
-    // If we are here it is because more than one chord was declared in the measure, so we have to sort out what chord goes where.
-
-    // First, normalize the chords on beats.
-    var mult = beatLength === 0.125 ? 3 : 1; // If this is a compound meter then the beats in the currentChords is 1/3 of the true beat
-    var beats = {};
-    for (var i = 0; i < currentChords.length; i++) {
-      var cc = currentChords[i];
-      var b = Math.round(cc.beat * mult);
-      beats['' + b] = cc;
-    }
-
-    // - If there is a chord on the second beat, play a chord for the first beat instead of a bass note.
-    // - Likewise, if there is a chord on the fourth beat of 4/4, play a chord on the third beat instead of a bass note.
-    for (var m2 = 0; m2 < pattern.length; m2++) {
-      var thisChord;
-      if (beats['' + m2]) thisChord = beats['' + m2];
-      var lastBoom;
-      if (!hasRhythmHead && thisChord) {
-        switch (pattern[m2]) {
-          case 'boom':
-            if (beats['' + (m2 + 1)])
-              // If there is not a chord change on the next beat, play a bass note.
-              writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);else {
-              writeBoom(thisChord.chord.boom, beatLength, boomVolume, m2, noteLength);
-              lastBoom = thisChord.chord.boom;
-            }
-            break;
-          case 'boom2':
-            if (beats['' + (m2 + 1)]) writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);else {
-              // If there is the same root as the last chord, use the alternating bass, otherwise play the root.
-              if (lastBoom === thisChord.chord.boom) {
-                writeBoom(thisChord.chord.boom2, beatLength, boomVolume, m2, noteLength);
-                lastBoom = undefined;
-              } else {
-                writeBoom(thisChord.chord.boom, beatLength, boomVolume, m2, noteLength);
-                lastBoom = thisChord.chord.boom;
-              }
-            }
-            break;
-          case 'chick':
-            writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);
-            break;
-          case '':
-            if (beats['' + m2])
-              // If there is an explicit chord on this beat, play it.
-              writeChick(thisChord.chord.chick, beatLength, chickVolume, m2, noteLength);
-            break;
-        }
-      }
-    }
-  }
   function normalizeDrumDefinition(params) {
     // Be very strict with the drum definition. If anything is not perfect,
     // just turn the drums off.
@@ -12928,6 +12532,7 @@ var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/ab
     var drumBars = options.drumBars || 1;
     var drumIntro = options.drumIntro || 0;
     var drumOn = drumPattern !== "";
+    var drumOffAfterIntro = !!options.drumOff;
     var style = []; // The note head style for each voice.
     var rhythmHeadThisBar = false; // Rhythm notation was detected.
     var crescendoSize = 50; // how much to increase or decrease volume when crescendo/diminuendo is encountered.
@@ -13381,13 +12986,13 @@ var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/ab
                       break;
                     case "gchordoff":
                       voices[voiceNumber].push({
-                        el_type: 'gchord',
+                        el_type: 'gchordOn',
                         tacet: true
                       });
                       break;
                     case "gchordon":
                       voices[voiceNumber].push({
-                        el_type: 'gchord',
+                        el_type: 'gchordOn',
                         tacet: false
                       });
                       break;
@@ -13410,15 +13015,21 @@ var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/ab
                       });
                       break;
                     case "vol":
+                    case "volinc":
                       voices[voiceNumber].push({
-                        el_type: 'vol',
+                        el_type: elem.cmd,
                         volume: elem.params[0]
                       });
                       break;
-                    case "volinc":
+                    case "swing":
+                    case "gchord":
+                    case "bassprog":
+                    case "chordprog":
+                    case "bassvol":
+                    case "chordvol":
                       voices[voiceNumber].push({
-                        el_type: 'volinc',
-                        volume: elem.params[0]
+                        el_type: elem.cmd,
+                        param: elem.params[0]
                       });
                       break;
                     default:
@@ -13460,16 +13071,19 @@ var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/ab
         if (voices[vv].length > insertPoint) {
           for (var w = 0; w < drumIntro; w++) {
             // If it is the last measure of intro, subtract the pickups.
-            if (pickups === 0 || w < drumIntro - 1) voices[vv].splice(insertPoint, 0, {
-              el_type: "note",
-              rest: {
-                type: "rest"
-              },
-              duration: measureLength
-            }, {
-              el_type: "bar"
-            });else {
+            if (pickups === 0 || w < drumIntro - 1) {
               voices[vv].splice(insertPoint, 0, {
+                el_type: "note",
+                rest: {
+                  type: "rest"
+                },
+                duration: measureLength
+              }, {
+                el_type: "bar"
+              });
+              insertPoint += 2;
+            } else {
+              voices[vv].splice(insertPoint++, 0, {
                 el_type: "note",
                 rest: {
                   type: "rest"
@@ -13478,6 +13092,19 @@ var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/ab
               });
             }
           }
+          if (drumOffAfterIntro) {
+            drumOn = false;
+            voices[vv].splice(insertPoint++, 0, {
+              el_type: 'drum',
+              params: {
+                pattern: drumPattern,
+                bars: drumBars,
+                intro: drumIntro,
+                on: drumOn
+              }
+            });
+            drumOffAfterIntro = false;
+          }
         }
       }
     }
@@ -13673,6 +13300,589 @@ module.exports = centsToFactor;
 
 /***/ }),
 
+/***/ "./src/synth/chord-track.js":
+/*!**********************************!*\
+  !*** ./src/synth/chord-track.js ***!
+  \**********************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+//
+// The algorithm for chords is:
+// - The chords are done in a separate track.
+// - If there are notes before the first chord, then put that much silence to start the track.
+// - The pattern of chord expression depends on the meter, and how many chords are in a measure.
+// - There is a possibility that a measure will have an incorrect number of beats, if that is the case, then
+// start the pattern anew on the next measure number.
+// - If a chord root is not A-G, then ignore it as if the chord wasn't there at all.
+// - If a chord modification isn't in our supported list, change it to a major triad.
+//
+// - There is a standard pattern of boom-chick for each time sig, or it can be overridden.
+// - For any unrecognized meter, play the full chord on each beat.
+//
+//	- If there is a chord specified that is not on a beat, move it earlier to the previous beat, unless there is already a chord on that beat.
+//	- Otherwise, move it later, unless there is already a chord on that beat.
+// 	- Otherwise, ignore it. (TODO-PER: expand this as more support is added.)
+//
+// If there is any note in the melody that has a rhythm head, then assume the melody controls the rhythm, so there is no chord added for that entire measure.
+
+var parseCommon = __webpack_require__(/*! ../parse/abc_common */ "./src/parse/abc_common.js");
+var ChordTrack = function ChordTrack(numVoices, chordsOff, midiOptions, meter) {
+  this.chordTrack = [];
+  this.chordTrackFinished = false;
+  this.chordChannel = numVoices; // first free channel for chords
+  this.currentChords = [];
+  this.lastChord;
+  this.chordLastBar;
+  this.chordsOff = !!chordsOff;
+  this.gChordTacet = this.chordsOff;
+  this.hasRhythmHead = false;
+  this.transpose = 0;
+  this.lastBarTime = 0;
+  this.meter = meter;
+  this.tempoChangeFactor = 1;
+  this.bassInstrument = midiOptions.bassprog && midiOptions.bassprog.length === 1 ? midiOptions.bassprog[0] : 0;
+  this.chordInstrument = midiOptions.chordprog && midiOptions.chordprog.length === 1 ? midiOptions.chordprog[0] : 0;
+  this.boomVolume = midiOptions.bassvol && midiOptions.bassvol.length === 1 ? midiOptions.bassvol[0] : 64;
+  this.chickVolume = midiOptions.chordvol && midiOptions.chordvol.length === 1 ? midiOptions.chordvol[0] : 48;
+  this.overridePattern = midiOptions.gchord ? parseGChord(midiOptions.gchord[0]) : undefined;
+};
+ChordTrack.prototype.setMeter = function (meter) {
+  this.meter = meter;
+};
+ChordTrack.prototype.setTempoChangeFactor = function (tempoChangeFactor) {
+  this.tempoChangeFactor = tempoChangeFactor;
+};
+ChordTrack.prototype.setLastBarTime = function (lastBarTime) {
+  this.lastBarTime = lastBarTime;
+};
+ChordTrack.prototype.setTranspose = function (transpose) {
+  this.transpose = transpose;
+};
+ChordTrack.prototype.setRhythmHead = function (isRhythmHead, elem) {
+  this.hasRhythmHead = isRhythmHead;
+  var ePitches = [];
+  if (isRhythmHead) {
+    if (this.lastChord && this.lastChord.chick) {
+      for (var i2 = 0; i2 < this.lastChord.chick.length; i2++) {
+        var note2 = parseCommon.clone(elem.pitches[0]);
+        note2.actualPitch = this.lastChord.chick[i2];
+        ePitches.push(note2);
+      }
+    }
+  }
+  return ePitches;
+};
+ChordTrack.prototype.barEnd = function (element) {
+  if (this.chordTrack.length > 0 && !this.chordTrackFinished) {
+    this.resolveChords(this.lastBarTime, timeToRealTime(element.time));
+    this.currentChords = [];
+  }
+  this.chordLastBar = this.lastChord;
+};
+ChordTrack.prototype.gChordOn = function (element) {
+  if (!this.chordsOff) this.gChordTacet = element.tacet;
+};
+ChordTrack.prototype.paramChange = function (element) {
+  switch (element.el_type) {
+    case "gchord":
+      this.overridePattern = parseGChord(element.param);
+      break;
+    case "bassprog":
+      this.bassInstrument = element.param;
+      break;
+    case "chordprog":
+      this.chordInstrument = element.param;
+      break;
+    case "bassvol":
+      this.boomVolume = element.param;
+      break;
+    case "chordvol":
+      this.chickVolume = element.param;
+      break;
+    default:
+      console.log("unhandled midi param", element);
+  }
+};
+ChordTrack.prototype.finish = function () {
+  if (!this.chordTrackEmpty())
+    // Don't do chords on more than one track, so turn off chord detection after we create it.
+    this.chordTrackFinished = true;
+};
+ChordTrack.prototype.addTrack = function (tracks) {
+  if (!this.chordTrackEmpty()) tracks.push(this.chordTrack);
+};
+ChordTrack.prototype.findChord = function (elem) {
+  if (this.gChordTacet) return 'break';
+
+  // TODO-PER: Just using the first chord if there are more than one.
+  if (this.chordTrackFinished || !elem.chord || elem.chord.length === 0) return null;
+
+  // Return the first annotation that is a regular chord: that is, it is in the default place or is a recognized "tacet" phrase.
+  for (var i = 0; i < elem.chord.length; i++) {
+    var ch = elem.chord[i];
+    if (ch.position === 'default') return ch.name;
+    if (this.breakSynonyms.indexOf(ch.name.toLowerCase()) >= 0) return 'break';
+  }
+  return null;
+};
+ChordTrack.prototype.interpretChord = function (name) {
+  // chords have the format:
+  // [root][acc][modifier][/][bass][acc]
+  // (The chord might be surrounded by parens. Just ignore them.)
+  // root must be present and must be from A-G.
+  // acc is optional and can be # or b
+  // The modifier can be a wide variety of things, like "maj7". As they are discovered, more are supported here.
+  // If there is a slash, then there is a bass note, which can be from A-G, with an optional acc.
+  // If the root is unrecognized, then "undefined" is returned and there is no chord.
+  // If the modifier is unrecognized, a major triad is returned.
+  // If the bass notes is unrecognized, it is ignored.
+  if (name.length === 0) return undefined;
+  if (name === 'break') return {
+    chick: []
+  };
+  var root = name.substring(0, 1);
+  if (root === '(') {
+    name = name.substring(1, name.length - 2);
+    if (name.length === 0) return undefined;
+    root = name.substring(0, 1);
+  }
+  var bass = this.basses[root];
+  if (!bass)
+    // If the bass note isn't listed, then this was an unknown root. Only A-G are accepted.
+    return undefined;
+  // Don't transpose the chords more than an octave.
+  var chordTranspose = this.transpose;
+  while (chordTranspose < -8) {
+    chordTranspose += 12;
+  }
+  while (chordTranspose > 8) {
+    chordTranspose -= 12;
+  }
+  bass += chordTranspose;
+  var bass2 = bass - 5; // The alternating bass is a 4th below
+  var chick;
+  if (name.length === 1) chick = this.chordNotes(bass, '');
+  var remaining = name.substring(1);
+  var acc = remaining.substring(0, 1);
+  if (acc === 'b' || acc === '♭') {
+    bass--;
+    bass2--;
+    remaining = remaining.substring(1);
+  } else if (acc === '#' || acc === '♯') {
+    bass++;
+    bass2++;
+    remaining = remaining.substring(1);
+  }
+  var arr = remaining.split('/');
+  chick = this.chordNotes(bass, arr[0]);
+  // If the 5th is altered then the bass is altered. Normally the bass is 7 from the root, so adjust if it isn't.
+  if (chick.length >= 3) {
+    var fifth = chick[2] - chick[0];
+    bass2 = bass2 + fifth - 7;
+  }
+  if (arr.length === 2) {
+    var explicitBass = this.basses[arr[1].substring(0, 1)];
+    if (explicitBass) {
+      var bassAcc = arr[1].substring(1);
+      var bassShift = {
+        '#': 1,
+        '♯': 1,
+        'b': -1,
+        '♭': -1
+      }[bassAcc] || 0;
+      bass = this.basses[arr[1].substring(0, 1)] + bassShift + chordTranspose;
+      bass2 = bass;
+    }
+  }
+  return {
+    boom: bass,
+    boom2: bass2,
+    chick: chick
+  };
+};
+ChordTrack.prototype.chordNotes = function (bass, modifier) {
+  var intervals = this.chordIntervals[modifier];
+  if (!intervals) {
+    if (modifier.slice(0, 2).toLowerCase() === 'ma' || modifier[0] === 'M') intervals = this.chordIntervals.M;else if (modifier[0] === 'm' || modifier[0] === '-') intervals = this.chordIntervals.m;else intervals = this.chordIntervals.M;
+  }
+  bass += 12; // the chord is an octave above the bass note.
+  var notes = [];
+  for (var i = 0; i < intervals.length; i++) {
+    notes.push(bass + intervals[i]);
+  }
+  return notes;
+};
+ChordTrack.prototype.writeNote = function (note, beatLength, volume, beat, noteLength, instrument) {
+  // undefined means there is a stop time.
+  if (note !== undefined) this.chordTrack.push({
+    cmd: 'note',
+    pitch: note,
+    volume: volume,
+    start: this.lastBarTime + beat * durationRounded(beatLength, this.tempoChangeFactor),
+    duration: durationRounded(noteLength, this.tempoChangeFactor),
+    gap: 0,
+    instrument: instrument
+  });
+};
+ChordTrack.prototype.chordTrackEmpty = function () {
+  var isEmpty = true;
+  for (var i = 0; i < this.chordTrack.length && isEmpty; i++) {
+    if (this.chordTrack[i].cmd === 'note') isEmpty = false;
+  }
+  return isEmpty;
+};
+ChordTrack.prototype.resolveChords = function (startTime, endTime) {
+  // If there is a rhythm head anywhere in the measure then don't add a separate rhythm track
+  if (this.hasRhythmHead) return;
+  var num = this.meter.num;
+  var den = this.meter.den;
+  var beatLength = 1 / den;
+  var noteLength = beatLength / 2;
+  var thisMeasureLength = parseInt(num, 10) / parseInt(den, 10);
+  var portionOfAMeasure = thisMeasureLength - (endTime - startTime) / this.tempoChangeFactor;
+  if (Math.abs(portionOfAMeasure) < 0.00001) portionOfAMeasure = 0;
+
+  // there wasn't a new chord this measure, so use the last chord declared.
+  // also the case where there is a chord declared in the measure, but not on its first beat.
+  if (this.currentChords.length === 0 || this.currentChords[0].beat !== 0) {
+    this.currentChords.unshift({
+      beat: 0,
+      chord: this.chordLastBar
+    });
+  }
+
+  //console.log(this.currentChords)
+  var currentChordsExpanded = expandCurrentChords(this.currentChords, 8 * num / den, beatLength);
+  //console.log(currentChordsExpanded)
+  var thisPattern = this.overridePattern ? this.overridePattern : this.rhythmPatterns[num + '/' + den];
+  if (portionOfAMeasure) {
+    thisPattern = [];
+    var beatsPresent = (endTime - startTime) / this.tempoChangeFactor * 8;
+    for (var p = 0; p < beatsPresent / 2; p += 2) {
+      thisPattern.push("chick");
+      thisPattern.push("");
+    }
+  }
+  if (!thisPattern) {
+    thisPattern = [];
+    for (var p = 0; p < 8 * num / den / 2; p++) {
+      thisPattern.push('chick');
+      thisPattern.push("");
+    }
+  }
+  var firstBoom = true;
+  // If the pattern is overridden, it might be longer than the length of a measure. If so, then ignore the rest of it
+  var minLength = Math.min(thisPattern.length, currentChordsExpanded.length);
+  for (var p = 0; p < minLength; p++) {
+    if (p > 0 && currentChordsExpanded[p - 1] && currentChordsExpanded[p] && currentChordsExpanded[p - 1].boom !== currentChordsExpanded[p].boom) firstBoom = true;
+    var type = thisPattern[p];
+    var isBoom = type.indexOf('boom') >= 0;
+    // If we changed chords at a time when we're not expecting a bass note, then add an extra bass note in.
+    var newBass = !isBoom && p !== 0 && (!currentChordsExpanded[p - 1] || currentChordsExpanded[p - 1].boom !== currentChordsExpanded[p].boom);
+    var pitches = resolvePitch(currentChordsExpanded[p], type, firstBoom, newBass);
+    if (isBoom) firstBoom = false;
+    for (var oo = 0; oo < pitches.length; oo++) {
+      this.writeNote(pitches[oo], 0.125, isBoom || newBass ? this.boomVolume : this.chickVolume, p, noteLength, isBoom || newBass ? this.bassInstrument : this.chordInstrument);
+      if (newBass) newBass = false;else isBoom = false; // only the first note in a chord is a bass note. This handles the case where bass and chord are played at the same time.
+    }
+  }
+
+  return;
+};
+ChordTrack.prototype.processChord = function (elem) {
+  if (this.chordTrackFinished) return;
+  var chord = this.findChord(elem);
+  if (chord) {
+    var c = this.interpretChord(chord);
+    // If this isn't a recognized chord, just completely ignore it.
+    if (c) {
+      // If we ever have a chord in this voice, then we add the chord track.
+      // However, if there are chords on more than one voice, then just use the first voice.
+      if (this.chordTrack.length === 0) {
+        this.chordTrack.push({
+          cmd: 'program',
+          channel: this.chordChannel,
+          instrument: this.chordInstrument
+        });
+      }
+      this.lastChord = c;
+      var barBeat = calcBeat(this.lastBarTime, timeToRealTime(elem.time));
+      this.currentChords.push({
+        chord: this.lastChord,
+        beat: barBeat,
+        start: timeToRealTime(elem.time)
+      });
+    }
+  }
+};
+function resolvePitch(currentChord, type, firstBoom, newBass) {
+  var ret = [];
+  if (!currentChord) return ret;
+  if (type.indexOf('boom') >= 0) ret.push(firstBoom ? currentChord.boom : currentChord.boom2);else if (newBass) ret.push(currentChord.boom);
+  if (type.indexOf('chick') >= 0) {
+    for (var i = 0; i < currentChord.chick.length; i++) {
+      ret.push(currentChord.chick[i]);
+    }
+  }
+  switch (type) {
+    case 'DO':
+      ret.push(currentChord.chick[0]);
+      break;
+    case 'MI':
+      ret.push(currentChord.chick[1]);
+      break;
+    case 'SOL':
+      ret.push(currentChord.chick[2]);
+      break;
+    case 'TI':
+      currentChord.chick.length > 3 ? ret.push(currentChord.chick[2]) : ret.push(currentChord.chick[0] + 12);
+      break;
+    case 'TOP':
+      currentChord.chick.length > 4 ? ret.push(currentChord.chick[2]) : ret.push(currentChord.chick[1] + 12);
+      break;
+    case 'do':
+      ret.push(currentChord.chick[0] + 12);
+      break;
+    case 'mi':
+      ret.push(currentChord.chick[1] + 12);
+      break;
+    case 'sol':
+      ret.push(currentChord.chick[2] + 12);
+      break;
+    case 'ti':
+      currentChord.chick.length > 3 ? ret.push(currentChord.chick[2] + 12) : ret.push(currentChord.chick[0] + 24);
+      break;
+    case 'top':
+      currentChord.chick.length > 4 ? ret.push(currentChord.chick[2] + 12) : ret.push(currentChord.chick[1] + 24);
+      break;
+  }
+  return ret;
+}
+function parseGChord(gchord) {
+  // TODO-PER: The spec is more complicated than this but for now this will not try to do anything with error cases like the wrong number of beats.
+  var pattern = [];
+  for (var i = 0; i < gchord.length; i++) {
+    var ch = gchord[i];
+    switch (ch) {
+      case 'z':
+        pattern.push('');
+        break;
+      case '2':
+        pattern.push('');
+        break;
+      // TODO-PER: This should extend the last note, but that's a small effect
+      case 'c':
+        pattern.push('chick');
+        break;
+      case 'b':
+        pattern.push('boom&chick');
+        break;
+      case 'f':
+        pattern.push('boom');
+        break;
+      case 'G':
+        pattern.push('DO');
+        break;
+      case 'H':
+        pattern.push('MI');
+        break;
+      case 'I':
+        pattern.push('SOL');
+        break;
+      case 'J':
+        pattern.push('TI');
+        break;
+      case 'K':
+        pattern.push('TOP');
+        break;
+      case 'g':
+        pattern.push('do');
+        break;
+      case 'h':
+        pattern.push('mi');
+        break;
+      case 'i':
+        pattern.push('sol');
+        break;
+      case 'j':
+        pattern.push('ti');
+        break;
+      case 'k':
+        pattern.push('top');
+        break;
+    }
+  }
+  return pattern;
+}
+
+// This returns an array that has a chord for each 1/8th note position in the current measure
+function expandCurrentChords(currentChords, num8thNotes, beatLength) {
+  beatLength = beatLength * 8; // this is expressed as a fraction, so that 0.25 is a quarter notes. We want it to be the number of 8th notes
+  var chords = [];
+  if (currentChords.length === 0) return chords;
+  var currentChord = currentChords[0].chord;
+  for (var i = 1; i < currentChords.length; i++) {
+    var current = currentChords[i];
+    while (chords.length < current.beat) {
+      chords.push(currentChord);
+    }
+    currentChord = current.chord;
+  }
+  while (chords.length < num8thNotes) {
+    chords.push(currentChord);
+  }
+  return chords;
+}
+function calcBeat(measureStart, currTime) {
+  var distanceFromStart = currTime - measureStart;
+  return distanceFromStart * 8;
+}
+ChordTrack.prototype.breakSynonyms = ['break', '(break)', 'no chord', 'n.c.', 'tacet'];
+ChordTrack.prototype.basses = {
+  'A': 33,
+  'B': 35,
+  'C': 36,
+  'D': 38,
+  'E': 40,
+  'F': 41,
+  'G': 43
+};
+ChordTrack.prototype.chordIntervals = {
+  // diminished (all flat 5 chords)
+  'dim': [0, 3, 6],
+  '°': [0, 3, 6],
+  '˚': [0, 3, 6],
+  'dim7': [0, 3, 6, 9],
+  '°7': [0, 3, 6, 9],
+  '˚7': [0, 3, 6, 9],
+  'ø7': [0, 3, 6, 10],
+  'm7(b5)': [0, 3, 6, 10],
+  'm7b5': [0, 3, 6, 10],
+  'm7♭5': [0, 3, 6, 10],
+  '-7(b5)': [0, 3, 6, 10],
+  '-7b5': [0, 3, 6, 10],
+  '7b5': [0, 4, 6, 10],
+  '7(b5)': [0, 4, 6, 10],
+  '7♭5': [0, 4, 6, 10],
+  '7(b9,b5)': [0, 4, 6, 10, 13],
+  '7b9,b5': [0, 4, 6, 10, 13],
+  '7(#9,b5)': [0, 4, 6, 10, 15],
+  '7#9b5': [0, 4, 6, 10, 15],
+  'maj7(b5)': [0, 4, 6, 11],
+  'maj7b5': [0, 4, 6, 11],
+  '13(b5)': [0, 4, 6, 10, 14, 21],
+  '13b5': [0, 4, 6, 10, 14, 21],
+  // minor (all normal 5, minor 3 chords)
+  'm': [0, 3, 7],
+  '-': [0, 3, 7],
+  'm6': [0, 3, 7, 9],
+  '-6': [0, 3, 7, 9],
+  'm7': [0, 3, 7, 10],
+  '-7': [0, 3, 7, 10],
+  '-(b6)': [0, 3, 7, 8],
+  '-b6': [0, 3, 7, 8],
+  '-6/9': [0, 3, 7, 9, 14],
+  '-7(b9)': [0, 3, 7, 10, 13],
+  '-7b9': [0, 3, 7, 10, 13],
+  '-maj7': [0, 3, 7, 11],
+  '-9+7': [0, 3, 7, 11, 13],
+  '-11': [0, 3, 7, 11, 14, 17],
+  'm11': [0, 3, 7, 11, 14, 17],
+  '-maj9': [0, 3, 7, 11, 14],
+  '-∆9': [0, 3, 7, 11, 14],
+  'mM9': [0, 3, 7, 11, 14],
+  // major (all normal 5, major 3 chords)
+  'M': [0, 4, 7],
+  '6': [0, 4, 7, 9],
+  '6/9': [0, 4, 7, 9, 14],
+  '6add9': [0, 4, 7, 9, 14],
+  '69': [0, 4, 7, 9, 14],
+  '7': [0, 4, 7, 10],
+  '9': [0, 4, 7, 10, 14],
+  '11': [0, 7, 10, 14, 17],
+  '13': [0, 4, 7, 10, 14, 21],
+  '7b9': [0, 4, 7, 10, 13],
+  '7♭9': [0, 4, 7, 10, 13],
+  '7(b9)': [0, 4, 7, 10, 13],
+  '7(#9)': [0, 4, 7, 10, 15],
+  '7#9': [0, 4, 7, 10, 15],
+  '(13)': [0, 4, 7, 10, 14, 21],
+  '7(9,13)': [0, 4, 7, 10, 14, 21],
+  '7(#9,b13)': [0, 4, 7, 10, 15, 20],
+  '7(#11)': [0, 4, 7, 10, 14, 18],
+  '7#11': [0, 4, 7, 10, 14, 18],
+  '7(b13)': [0, 4, 7, 10, 20],
+  '7b13': [0, 4, 7, 10, 20],
+  '9(#11)': [0, 4, 7, 10, 14, 18],
+  '9#11': [0, 4, 7, 10, 14, 18],
+  '13(#11)': [0, 4, 7, 10, 18, 21],
+  '13#11': [0, 4, 7, 10, 18, 21],
+  'maj7': [0, 4, 7, 11],
+  '∆7': [0, 4, 7, 11],
+  'Δ7': [0, 4, 7, 11],
+  'maj9': [0, 4, 7, 11, 14],
+  'maj7(9)': [0, 4, 7, 11, 14],
+  'maj7(11)': [0, 4, 7, 11, 17],
+  'maj7(#11)': [0, 4, 7, 11, 18],
+  'maj7(13)': [0, 4, 7, 14, 21],
+  'maj7(9,13)': [0, 4, 7, 11, 14, 21],
+  '7sus4': [0, 5, 7, 10],
+  'm7sus4': [0, 3, 7, 10, 17],
+  'sus4': [0, 5, 7],
+  'sus2': [0, 2, 7],
+  '7sus2': [0, 2, 7, 10],
+  '9sus4': [0, 5, 7, 10, 14],
+  '13sus4': [0, 5, 7, 10, 14, 21],
+  // augmented (all sharp 5 chords)
+  'aug7': [0, 4, 8, 10],
+  '+7': [0, 4, 8, 10],
+  '+': [0, 4, 8],
+  '7#5': [0, 4, 8, 10],
+  '7♯5': [0, 4, 8, 10],
+  '7+5': [0, 4, 8, 10],
+  '9#5': [0, 4, 8, 10, 14],
+  '9♯5': [0, 4, 8, 10, 14],
+  '9+5': [0, 4, 8, 10, 14],
+  '-7(#5)': [0, 3, 8, 10],
+  '-7#5': [0, 3, 8, 10],
+  '7(#5)': [0, 4, 8, 10],
+  '7(b9,#5)': [0, 4, 8, 10, 13],
+  '7b9#5': [0, 4, 8, 10, 13],
+  'maj7(#5)': [0, 4, 8, 11],
+  'maj7#5': [0, 4, 8, 11],
+  'maj7(#5,#11)': [0, 4, 8, 11, 18],
+  'maj7#5#11': [0, 4, 8, 11, 18],
+  '9(#5)': [0, 4, 8, 10, 14],
+  '13(#5)': [0, 4, 8, 10, 14, 21],
+  '13#5': [0, 4, 8, 10, 14, 21]
+};
+ChordTrack.prototype.rhythmPatterns = {
+  "2/2": ['boom', '', '', '', 'chick', '', '', ''],
+  "3/2": ['boom', '', '', '', 'chick', '', '', '', 'chick', '', '', ''],
+  "4/2": ['boom', '', '', '', 'chick', '', '', '', 'boom', '', '', '', 'chick', '', '', ''],
+  "2/4": ['boom', '', 'chick', ''],
+  "3/4": ['boom', '', 'chick', '', 'chick', ''],
+  "4/4": ['boom', '', 'chick', '', 'boom', '', 'chick', ''],
+  "5/4": ['boom', '', 'chick', '', 'chick', '', 'boom', '', 'chick', ''],
+  "6/4": ['boom', '', 'chick', '', 'boom', '', 'chick', '', 'boom', '', 'chick', ''],
+  "3/8": ['boom', '', 'chick'],
+  "6/8": ['boom', '', 'chick', 'boom', '', 'chick'],
+  "9/8": ['boom', '', 'chick', 'boom', '', 'chick', 'boom', '', 'chick'],
+  "12/8": ['boom', '', 'chick', 'boom', '', 'chick', 'boom', '', 'chick', 'boom', '', 'chick']
+};
+
+// TODO-PER: these are repeated in flattener. Can it be shared?
+
+function timeToRealTime(time) {
+  return time / 1000000;
+}
+function durationRounded(duration, tempoChangeFactor) {
+  return Math.round(duration * tempoChangeFactor * 1000000) / 1000000;
+}
+module.exports = ChordTrack;
+
+/***/ }),
+
 /***/ "./src/synth/create-note-map.js":
 /*!**************************************!*\
   !*** ./src/synth/create-note-map.js ***!
@@ -13699,13 +13909,14 @@ var createNoteMap = function createNoteMap(sequence) {
           // ev contains:
           // {"cmd":"note","pitch":72,"volume":95,"start":0.125,"duration":0.25,"instrument":0,"gap":0}
           // where start and duration are in whole notes, gap is in 1/1920 of a second (i.e. MIDI ticks)
+          var inst = ev.instrument !== undefined ? instrumentIndexToName[ev.instrument] : currentInstrument;
           if (ev.duration > 0) {
             var gap = ev.gap ? ev.gap : 0;
             var len = ev.duration;
             gap = Math.min(gap, len * 2 / 3);
             var obj = {
               pitch: ev.pitch,
-              instrument: currentInstrument,
+              instrument: inst,
               start: Math.round(ev.start * 1000000) / 1000000,
               end: Math.round((ev.start + len - gap) * 1000000) / 1000000,
               volume: ev.volume
@@ -13968,12 +14179,13 @@ function CreateSynth() {
   self.audioBuffers = []; // cache of the buffers so starting play can be fast.
   self.duration = undefined; // the duration of the tune in seconds.
   self.isRunning = false; // whether there is currently a sound buffer running.
-  //	self.options = undefined
+  self.options = undefined;
+  self.pickupLength = 0;
 
   // Load and cache all needed sounds
   self.init = function (options) {
     if (!options) options = {};
-    //		self.options = options
+    if (options.options) self.options = options.options;
     registerAudioContext(options.audioContext); // This works no matter what - if there is already an ac it is a nop; if the context is not passed in, then it creates one.
     var startTime = activeAudioContext().currentTime;
     self.debugCallback = options.debugCallback;
@@ -14042,12 +14254,14 @@ function CreateSynth() {
       self.flattened = options.visualObj.setUpAudio(params);
       var meter = options.visualObj.getMeterFraction();
       if (meter.den) self.meterSize = options.visualObj.getMeterFraction().num / options.visualObj.getMeterFraction().den;
+      self.pickupLength = options.visualObj.getPickupLength();
     } else if (options.sequence) self.flattened = options.sequence;else return Promise.reject(new Error("Must pass in either a visualObj or a sequence"));
     self.millisecondsPerMeasure = options.millisecondsPerMeasure ? options.millisecondsPerMeasure : options.visualObj ? options.visualObj.millisecondsPerMeasure(self.flattened.tempo) : 1000;
     self.beatsPerMeasure = options.visualObj ? options.visualObj.getBeatsPerMeasure() : 4;
     self.sequenceCallback = params.sequenceCallback;
     self.callbackContext = params.callbackContext;
     self.onEnded = params.onEnded;
+    self.meterFraction = options.visualObj.getMeterFraction();
     var allNotes = {};
     var cached = [];
     var errorNotes = [];
@@ -14058,14 +14272,15 @@ function CreateSynth() {
         if (event.pitch !== undefined) {
           var pitchNumber = event.pitch;
           var noteName = pitchToNoteName[pitchNumber];
+          var inst = event.instrument !== undefined ? instrumentIndexToName[event.instrument] : currentInstrument;
           if (noteName) {
-            if (!allNotes[currentInstrument]) allNotes[currentInstrument] = {};
-            if (!soundsCache[currentInstrument] || !soundsCache[currentInstrument][noteName]) allNotes[currentInstrument][noteName] = true;else {
-              var label2 = currentInstrument + ":" + noteName;
+            if (!allNotes[inst]) allNotes[inst] = {};
+            if (!soundsCache[inst] || !soundsCache[inst][noteName]) allNotes[inst][noteName] = true;else {
+              var label2 = inst + ":" + noteName;
               if (cached.indexOf(label2) < 0) cached.push(label2);
             }
           } else {
-            var label = currentInstrument + ":" + noteName;
+            var label = inst + ":" + noteName;
             console.log("Can't find note: ", pitchNumber, label);
             if (errorNotes.indexOf(label) < 0) errorNotes.push(label);
           }
@@ -14206,8 +14421,7 @@ function CreateSynth() {
       // There might be a previous run that needs to be turned off.
       self.stop();
       var noteMapTracks = createNoteMap(self.flattened);
-      // if (self.options.swing)
-      // 	addSwing(noteMapTracks, self.options.swing, self.beatsPerMeasure)
+      if (self.options.swing) addSwing(noteMapTracks, self.options.swing, self.meterFraction, self.pickupLength);
       if (self.sequenceCallback) self.sequenceCallback(noteMapTracks, self.callbackContext);
       var panDistances = setPan(noteMapTracks.length, self.pan);
 
@@ -14420,41 +14634,65 @@ function CreateSynth() {
       };
     }
   };
-
-  // // this is a first attempt at adding a little bit of swing to the output, but the algorithm isn't correct.
-  // function addSwing(noteMapTracks, swing, beatsPerMeasure) {
-  // 	console.log("addSwing", noteMapTracks, swing, beatsPerMeasure)
-  // 	// Swing should be between -0.9 and 0.9. Make sure the input is between them.
-  // 	// Then that is the percentage to add to the first beat, so a negative number moves the second beat earlier.
-  // 	// A value of zero is the same as no swing at all.
-  // 	// This only works when there are an even number of beats in a measure.
-  // 	if (beatsPerMeasure % 2 !== 0)
-  // 		return;
-  // 	swing = parseFloat(swing)
-  // 	if (isNaN(swing))
-  // 		return
-  // 	if (swing < -0.9)
-  // 		swing = -0.9
-  // 	if (swing > 0.9)
-  // 		swing = 0.9
-  // 	var beatLength = (1 / beatsPerMeasure)*2
-  // 	swing = beatLength * swing
-  // 	for (var t = 0; t < noteMapTracks.length; t++) {
-  // 		var track = noteMapTracks[t];
-  // 		for (var i = 0; i < track.length; i++) {
-  // 			var event = track[i];
-  // 			if (event.start % beatLength) {
-  // 				// This is the off beat
-  // 				event.start += swing;
-  // 			} else {
-  // 				// This is the beat
-  // 				event.end += swing;
-  // 			}
-  // 		}
-  // 	}
-  // }
+  function addSwing(noteMapTracks, swing, meterFraction, pickupLength) {
+    // we can only swing in X/4 and X/8 meters.
+    if (meterFraction.den != 4 && meterFraction.den != 8) return;
+    swing = parseFloat(swing);
+
+    // 50 (or less) is no swing, 
+    if (isNaN(swing) || swing <= 50) return;
+
+    // 66 is triplet swing 2:1, and 
+    // 60 is swing with a ratio of 3:2. 
+    // 75 is the maximum swing where the first eight is played as a dotted eight and the second as a sixteenth. 
+    if (swing > 75) swing = 75;
+
+    // convert the swing percentage to a percentage of increase for the first half of the beat
+    swing = swing / 50 - 1;
+
+    // The volume of the swung notes is increased by this factor
+    // could be also in the settings. Try out values such 0.1, 0.2
+    var volumeIncrease = 0.0;
+
+    // the beatLength in X/8 meters
+    var beatLength = 0.25;
+
+    // in X/8 meters the 16s swing so the beatLength is halved
+    if (meterFraction.den === 8) beatLength = beatLength / 2;
+
+    // duration of a half beat
+    var halfbeatLength = beatLength / 2;
+
+    // the extra duration of the first swung notes and the delay of the second notes
+    var swingDuration = halfbeatLength * swing;
+    for (var t = 0; t < noteMapTracks.length; t++) {
+      var track = noteMapTracks[t];
+      for (var i = 0; i < track.length; i++) {
+        var event = track[i];
+        if (
+        // is halfbeat
+        (event.start - pickupLength) % halfbeatLength == 0 && (event.start - pickupLength) % beatLength != 0 && (
+        // the previous note is on the beat or before OR there is no previous note 
+        i == 0 || track[i - 1].start <= track[i].start - halfbeatLength) && (
+        // the next note is on the beat or after OR there is no next note
+        i == track.length - 1 || track[i + 1].start >= track[i].start + halfbeatLength)) {
+          var oldEventStart = event.start;
+          event.start += swingDuration;
+
+          // Increase volume of swung notes
+          event.volume *= 1 + volumeIncrease;
+
+          // if there is a previous note ending at the start of this note, extend its end
+          // and decrease its volume
+          if (i > 0 && track[i - 1].end == oldEventStart) {
+            track[i - 1].end = event.start;
+            track[i - 1].volume *= 1 - volumeIncrease;
+          }
+        }
+      }
+    }
+  }
 }
-
 module.exports = CreateSynth;
 
 /***/ }),
@@ -17747,7 +17985,10 @@ AbstractEngraver.prototype.createNote = function (elem, nostem, isSingleLineStaf
     roomtaken += this.addGraceNotes(elem, voice, abselem, notehead, this.stemHeight * this.voiceScale, this.isBagpipes, roomtaken);
   }
   if (elem.decoration) {
-    this.decoration.createDecoration(voice, elem.decoration, abselem.top, notehead ? notehead.w : 0, abselem, roomtaken, dir, abselem.bottom, elem.positioning, this.hasVocals, this.accentAbove);
+    // TODO-PER: nostem is true if this is beamed. In that case we don't know where to place the decoration yet so just make a guess. This should be refactored to not place decorations until after the beams are determined.
+    // This should probably be combined with moveDecorations()
+    var bottom = nostem ? Math.min(-3, abselem.bottom - 6) : abselem.bottom;
+    this.decoration.createDecoration(voice, elem.decoration, abselem.top, notehead ? notehead.w : 0, abselem, roomtaken, dir, bottom, elem.positioning, this.hasVocals, this.accentAbove);
   }
   if (elem.barNumber) {
     abselem.addFixed(new RelativeElement(elem.barNumber, -10, 0, 0, {
@@ -18742,7 +18983,8 @@ var stackedDecoration = function stackedDecoration(decoration, width, abselem, y
     y = placement === 'above' ? y + height / 2 : y - height / 2; // Center the element vertically.
     abselem.addFixedX(new RelativeElement(symbol, deltaX, glyphs.getSymbolWidth(symbol), y, {
       klass: 'ornament',
-      thickness: glyphs.symbolHeightInPitches(symbol)
+      thickness: glyphs.symbolHeightInPitches(symbol),
+      position: placement
     }));
     incrementPlacement(placement, height);
   }
@@ -18939,7 +19181,8 @@ Decoration.prototype.createDecoration = function (voice, decoration, pitch, widt
   // yPos is an object containing 'above' and 'below'. That is the placement of the next symbol on either side.
 
   yPos.above = Math.max(yPos.above, this.minTop);
-  var hasOne = stackedDecoration(decoration, width, abselem, yPos, positioning.ornamentPosition, this.minTop, this.minBottom, accentAbove);
+  yPos.below = Math.min(yPos.below, minPitch);
+  var hasOne = stackedDecoration(decoration, width, abselem, yPos, positioning.ornamentPosition, this.minTop, minPitch, accentAbove);
   //if (hasOne) {
   //			abselem.top = Math.max(yPos.above + 3, abselem.top); // TODO-PER: Not sure why we need this fudge factor.
   //}
@@ -20208,6 +20451,23 @@ TieElem.prototype.calcSlurY = function () {
       this.endY = midPoint;
       this.endX += Math.round(this.anchor2.w / 2); // When going to the middle of the stem, bump the line to the right a little bit to make it look right.
     } else this.endY = this.above && beamInterferes ? this.anchor2.highestVert : this.anchor2.pitch;
+    if (this.anchor1.scalex === 1) {
+      // Need a way to tell if this is a grace note - if so then keep the slur as close as possible. TODO-PER-HACK: this should be more declaratively determined.
+      var hasBeam1 = !!this.anchor1.parent.beam;
+      var hasBeam2 = !!this.anchor2.parent.beam;
+      if (hasBeam1) {
+        var isLastInBeam = this.anchor1.parent === this.anchor1.parent.beam.elems[this.anchor1.parent.beam.elems.length - 1];
+        if (!isLastInBeam) {
+          if (this.above) this.startY = this.anchor1.parent.fixed.t;else this.startY = this.anchor1.parent.fixed.b;
+        }
+      }
+      if (hasBeam2) {
+        var isFirstInBeam = this.anchor2.parent === this.anchor2.parent.beam.elems[0];
+        if (!isFirstInBeam) {
+          if (this.above) this.endY = this.anchor2.parent.fixed.t;else this.endY = this.anchor2.parent.fixed.b;
+        }
+      }
+    }
   } else if (this.anchor1) {
     this.startY = this.endY = this.anchor1.pitch;
   } else if (this.anchor2) {
@@ -21507,7 +21767,7 @@ function draw(renderer, classes, abcTune, width, maxWidth, responsive, scale, se
     classes.incrLine();
     var abcLine = abcTune.lines[line];
     if (abcLine.staff) {
-      if (classes.shouldAddClasses) groupClasses.klass = "abcjs-staff l" + classes.lineNumber;
+      if (classes.shouldAddClasses) groupClasses.klass = "abcjs-staff-wrapper abcjs-l" + classes.lineNumber;
       renderer.paper.openGroup(groupClasses);
       if (abcLine.vskip) {
         renderer.moveY(abcLine.vskip);
@@ -23257,6 +23517,7 @@ var GetFontAndAttr = __webpack_require__(/*! ./helpers/get-font-and-attr */ "./s
 var GetTextSize = __webpack_require__(/*! ./helpers/get-text-size */ "./src/write/helpers/get-text-size.js");
 var draw = __webpack_require__(/*! ./draw/draw */ "./src/write/draw/draw.js");
 var tablatures = __webpack_require__(/*! ../api/abc_tablatures */ "./src/api/abc_tablatures.js");
+var findSelectableElement = __webpack_require__(/*! ./interactive/find-selectable-element */ "./src/write/interactive/find-selectable-element.js");
 
 /**
  * @class
@@ -23272,6 +23533,7 @@ var tablatures = __webpack_require__(/*! ../api/abc_tablatures */ "./src/api/abc
  */
 var EngraverController = function EngraverController(paper, params) {
   params = params || {};
+  this.findSelectableElement = findSelectableElement;
   this.oneSvgPerLine = params.oneSvgPerLine;
   this.selectionColor = params.selectionColor;
   this.dragColor = params.dragColor ? params.dragColor : params.selectionColor;
@@ -23280,6 +23542,7 @@ var EngraverController = function EngraverController(paper, params) {
   this.responsive = params.responsive;
   this.space = 3 * spacing.SPACE;
   this.initialClef = params.initialClef;
+  this.timeBasedLayout = params.timeBasedLayout;
   this.expandToWidest = !!params.expandToWidest;
   this.scale = params.scale ? parseFloat(params.scale) : 0;
   this.classes = new Classes({
@@ -23359,7 +23622,7 @@ EngraverController.prototype.getMeasureWidths = function (abcTune) {
   this.constructTuneElements(abcTune);
   // layout() sets the x-coordinate of the abcTune element here:
   // abcTune.lines[0].staffGroup.voices[0].children[0].x
-  layout(this.renderer, abcTune, 0, this.space);
+  layout(this.renderer, abcTune, 0, this.space, this.timeBasedLayout);
   var ret = [];
   var section;
   var needNewSection = true;
@@ -23414,6 +23677,7 @@ EngraverController.prototype.setupTune = function (abcTune, tuneNumber) {
     percmap: abcTune.formatting.percmap,
     initialClef: this.initialClef,
     jazzchords: this.jazzchords,
+    timeBasedLayout: this.timeBasedLayout,
     accentAbove: this.accentAbove,
     germanAlphabet: this.germanAlphabet
   });
@@ -23472,7 +23736,7 @@ EngraverController.prototype.engraveTune = function (abcTune, tuneNumber, lineOf
   //Set the top text now that we know the width
 
   // Do all the positioning, both horizontally and vertically
-  var maxWidth = layout(this.renderer, abcTune, this.width, this.space, this.expandToWidest);
+  var maxWidth = layout(this.renderer, abcTune, this.width, this.space, this.expandToWidest, this.timeBasedLayout);
 
   //Set the top text now that we know the width
   if (this.expandToWidest && maxWidth > this.width + 1) {
@@ -23516,14 +23780,14 @@ EngraverController.prototype.engraveTune = function (abcTune, tuneNumber, lineOf
   this.selectables = ret.selectables;
   if (this.oneSvgPerLine) {
     var div = this.renderer.paper.svg.parentNode;
-    this.svgs = splitSvgIntoLines(this.renderer, div, abcTune.metaText.title, this.responsive);
+    this.svgs = splitSvgIntoLines(this.renderer, div, abcTune.metaText.title, this.responsive, scale);
   } else {
     this.svgs = [this.renderer.paper.svg];
   }
   setupSelection(this, this.svgs);
   this.jazzchords = origJazzChords;
 };
-function splitSvgIntoLines(renderer, output, title, responsive) {
+function splitSvgIntoLines(renderer, output, title, responsive, scale) {
   // 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
@@ -23546,7 +23810,7 @@ function splitSvgIntoLines(renderer, output, title, responsive) {
     var height = box.height + gapBetweenLines;
     var wrapper = document.createElement("div");
     var divStyles = "overflow: hidden;";
-    if (responsive !== 'resize') divStyles += "height:" + height + "px;";
+    if (responsive !== 'resize') divStyles += "height:" + height * scale + "px;";
     wrapper.setAttribute("style", divStyles);
     var svg = duplicateSvg(source);
     var fullTitle = "Sheet Music for \"" + title + "\" section " + (i + 1);
@@ -23873,6 +24137,98 @@ module.exports = spacing;
 
 /***/ }),
 
+/***/ "./src/write/interactive/create-analysis.js":
+/*!**************************************************!*\
+  !*** ./src/write/interactive/create-analysis.js ***!
+  \**************************************************/
+/***/ (function(module) {
+
+function findNumber(klass, match, target, name) {
+  if (klass.indexOf(match) === 0) {
+    var value = klass.replace(match, '');
+    var num = parseInt(value, 10);
+    if ('' + num === value) target[name] = num;
+  }
+}
+function createAnalysis(target, ev) {
+  var classes = [];
+  if (target.absEl.elemset) {
+    var classObj = {};
+    for (var j = 0; j < target.absEl.elemset.length; j++) {
+      var es = target.absEl.elemset[j];
+      if (es) {
+        var klass = es.getAttribute("class").split(' ');
+        for (var k = 0; k < klass.length; k++) {
+          classObj[klass[k]] = true;
+        }
+      }
+    }
+    for (var kk = 0; kk < Object.keys(classObj).length; kk++) {
+      classes.push(Object.keys(classObj)[kk]);
+    }
+  }
+  var analysis = {};
+  for (var ii = 0; ii < classes.length; ii++) {
+    findNumber(classes[ii], "abcjs-v", analysis, "voice");
+    findNumber(classes[ii], "abcjs-l", analysis, "line");
+    findNumber(classes[ii], "abcjs-m", analysis, "measure");
+  }
+  if (target.staffPos) analysis.staffPos = target.staffPos;
+  var closest = ev.target;
+  while (closest && closest.dataset && !closest.dataset.name && closest.tagName.toLowerCase() !== 'svg') {
+    closest = closest.parentNode;
+  }
+  var parent = ev.target;
+  while (parent && parent.dataset && !parent.dataset.index && parent.tagName.toLowerCase() !== 'svg') {
+    parent = parent.parentNode;
+  }
+  if (parent && parent.dataset) {
+    analysis.name = parent.dataset.name;
+    analysis.clickedName = closest.dataset.name;
+    analysis.parentClasses = parent.classList;
+  }
+  if (closest && closest.classList) analysis.clickedClasses = closest.classList;
+  analysis.selectableElement = target.svgEl;
+  return {
+    classes: classes,
+    analysis: analysis
+  };
+}
+module.exports = createAnalysis;
+
+/***/ }),
+
+/***/ "./src/write/interactive/find-selectable-element.js":
+/*!**********************************************************!*\
+  !*** ./src/write/interactive/find-selectable-element.js ***!
+  \**********************************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var createAnalysis = __webpack_require__(/*! ./create-analysis */ "./src/write/interactive/create-analysis.js");
+function findSelectableElement(event) {
+  var selectable = event;
+  while (selectable && selectable.attributes && selectable.tagName.toLowerCase() !== 'svg' && !selectable.attributes.selectable) {
+    selectable = selectable.parentNode;
+  }
+  if (selectable && selectable.attributes && selectable.attributes.selectable) {
+    var index = selectable.attributes['data-index'].nodeValue;
+    if (index) {
+      index = parseInt(index, 10);
+      if (index >= 0 && index < this.selectables.length) {
+        var element = this.selectables[index];
+        var ret = createAnalysis(element, event);
+        ret.index = index;
+        ret.element = element;
+        return ret;
+      }
+    }
+  }
+  return null;
+}
+module.exports = findSelectableElement;
+
+/***/ }),
+
 /***/ "./src/write/interactive/highlight.js":
 /*!********************************************!*\
   !*** ./src/write/interactive/highlight.js ***!
@@ -23896,6 +24252,7 @@ module.exports = highlight;
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 var spacing = __webpack_require__(/*! ../helpers/spacing */ "./src/write/helpers/spacing.js");
+var createAnalysis = __webpack_require__(/*! ./create-analysis */ "./src/write/interactive/create-analysis.js");
 function setupSelection(engraver, svgs) {
   engraver.rangeHighlight = rangeHighlight;
   if (engraver.dragging) {
@@ -24201,44 +24558,9 @@ function setSelection(dragIndex) {
   }
 }
 function notifySelect(target, dragStep, dragMax, dragIndex, ev) {
-  var classes = [];
-  if (target.absEl.elemset) {
-    var classObj = {};
-    for (var j = 0; j < target.absEl.elemset.length; j++) {
-      var es = target.absEl.elemset[j];
-      if (es) {
-        var klass = es.getAttribute("class").split(' ');
-        for (var k = 0; k < klass.length; k++) {
-          classObj[klass[k]] = true;
-        }
-      }
-    }
-    for (var kk = 0; kk < Object.keys(classObj).length; kk++) {
-      classes.push(Object.keys(classObj)[kk]);
-    }
-  }
-  var analysis = {};
-  for (var ii = 0; ii < classes.length; ii++) {
-    findNumber(classes[ii], "abcjs-v", analysis, "voice");
-    findNumber(classes[ii], "abcjs-l", analysis, "line");
-    findNumber(classes[ii], "abcjs-m", analysis, "measure");
-  }
-  if (target.staffPos) analysis.staffPos = target.staffPos;
-  var closest = ev.target;
-  while (closest && closest.dataset && !closest.dataset.name && closest.tagName.toLowerCase() !== 'svg') {
-    closest = closest.parentNode;
-  }
-  var parent = ev.target;
-  while (parent && parent.dataset && !parent.dataset.index && parent.tagName.toLowerCase() !== 'svg') {
-    parent = parent.parentNode;
-  }
-  if (parent && parent.dataset) {
-    analysis.name = parent.dataset.name;
-    analysis.clickedName = closest.dataset.name;
-    analysis.parentClasses = parent.classList;
-  }
-  if (closest && closest.classList) analysis.clickedClasses = closest.classList;
-  analysis.selectableElement = target.svgEl;
+  var ret = createAnalysis(target, ev);
+  var classes = ret.classes;
+  var analysis = ret.analysis;
   for (var i = 0; i < this.listeners.length; i++) {
     this.listeners[i](target.absEl.abcelem, target.absEl.tuneNumber, classes.join(' '), analysis, {
       step: dragStep,
@@ -24248,13 +24570,6 @@ function notifySelect(target, dragStep, dragMax, dragIndex, ev) {
     }, ev);
   }
 }
-function findNumber(klass, match, target, name) {
-  if (klass.indexOf(match) === 0) {
-    var value = klass.replace(match, '');
-    var num = parseInt(value, 10);
-    if ('' + num === value) target[name] = num;
-  }
-}
 function clearSelection() {
   for (var i = 0; i < this.selected.length; i++) {
     this.selected[i].unhighlight(undefined, this.renderer.foregroundColor);
@@ -24609,6 +24924,94 @@ module.exports = getLeftEdgeOfStaff;
 
 /***/ }),
 
+/***/ "./src/write/layout/layout-in-grid.js":
+/*!********************************************!*\
+  !*** ./src/write/layout/layout-in-grid.js ***!
+  \********************************************/
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var getLeftEdgeOfStaff = __webpack_require__(/*! ./get-left-edge-of-staff */ "./src/write/layout/get-left-edge-of-staff.js");
+function layoutInGrid(renderer, staffGroup, timeBasedLayout) {
+  var leftEdge = getLeftEdgeOfStaff(renderer, staffGroup.getTextSize, staffGroup.voices, staffGroup.brace, staffGroup.bracket);
+  var ret = getTotalDuration(staffGroup, timeBasedLayout.minPadding);
+  var totalDuration = ret.totalDuration;
+  var minSpacing = ret.minSpacing;
+  var totalWidth = minSpacing * totalDuration;
+  if (timeBasedLayout.minWidth) totalWidth = Math.max(totalWidth, timeBasedLayout.minWidth);
+  var leftAlignPadding = timeBasedLayout.minPadding ? timeBasedLayout.minPadding / 2 : 2; // If the padding isn't specified still give it some
+
+  staffGroup.startx = leftEdge;
+  staffGroup.w = totalWidth + leftEdge;
+  for (var i = 0; i < staffGroup.voices.length; i++) {
+    var voice = staffGroup.voices[i];
+    voice.startx = leftEdge;
+    voice.w = totalWidth + leftEdge;
+    var x = leftEdge;
+    var afterFixedLeft = false;
+    var durationUnit = 0;
+    for (var j = 0; j < voice.children.length; j++) {
+      var child = voice.children[j];
+      if (!afterFixedLeft) {
+        if (child.duration !== 0) {
+          // We got to the first music element on the line
+          afterFixedLeft = true;
+          durationUnit = (totalWidth + leftEdge - x) / totalDuration;
+          staffGroup.gridStart = x;
+        } else {
+          // We are still doing the preliminary stuff - clef, time sig, etc.
+          child.x = x;
+          x += child.w + child.minspacing;
+        }
+      }
+      if (afterFixedLeft) {
+        if (timeBasedLayout.align === 'center') child.x = x + child.duration * durationUnit / 2 - child.w / 2;else {
+          // left align with padding - but no padding for barlines, they should be right aligned.
+          // TODO-PER: it looks better to move bar lines one pixel to right. Not sure why.
+          if (child.duration === 0) {
+            child.x = x + 1 - child.w;
+          } else {
+            // child.extraw has the width of the accidentals - push the note to the right to take that into consideration. It will be 0 if there is nothing to the left.
+            child.x = x + leftAlignPadding - child.extraw;
+          }
+        }
+        x += child.duration * durationUnit;
+      }
+      for (var k = 0; k < child.children.length; k++) {
+        var grandchild = child.children[k];
+        // some elements don't have a dx - Tempo, for instance
+        var dx = grandchild.dx ? grandchild.dx : 0;
+        grandchild.x = child.x + dx;
+      }
+    }
+    staffGroup.gridEnd = x;
+  }
+  return totalWidth;
+}
+function getTotalDuration(staffGroup, timeBasedLayout) {
+  var maxSpacing = 0;
+  var maxCount = 0;
+  for (var i = 0; i < staffGroup.voices.length; i++) {
+    var count = 0;
+    var voice = staffGroup.voices[i];
+    for (var j = 0; j < voice.children.length; j++) {
+      var element = voice.children[j];
+      count += element.duration;
+      if (element.duration) {
+        var width = (element.w + timeBasedLayout) / element.duration;
+        maxSpacing = Math.max(maxSpacing, width);
+      }
+    }
+    maxCount = Math.max(maxCount, count);
+  }
+  return {
+    totalDuration: maxCount,
+    minSpacing: maxSpacing
+  };
+}
+module.exports = layoutInGrid;
+
+/***/ }),
+
 /***/ "./src/write/layout/layout.js":
 /*!************************************!*\
   !*** ./src/write/layout/layout.js ***!
@@ -24619,7 +25022,12 @@ var layoutVoice = __webpack_require__(/*! ./voice */ "./src/write/layout/voice.j
 var setUpperAndLowerElements = __webpack_require__(/*! ./set-upper-and-lower-elements */ "./src/write/layout/set-upper-and-lower-elements.js");
 var layoutStaffGroup = __webpack_require__(/*! ./staff-group */ "./src/write/layout/staff-group.js");
 var getLeftEdgeOfStaff = __webpack_require__(/*! ./get-left-edge-of-staff */ "./src/write/layout/get-left-edge-of-staff.js");
-var layout = function layout(renderer, abctune, width, space, expandToWidest) {
+var layoutInGrid = __webpack_require__(/*! ./layout-in-grid */ "./src/write/layout/layout-in-grid.js");
+
+// This sets the "x" attribute on all the children in abctune.lines
+// It also sets the "w" and "startx" attributes on "voices"
+// It also sets the "w" and "startx" attributes on "voices.children"
+var layout = function layout(renderer, abctune, width, space, expandToWidest, timeBasedLayout) {
   var i;
   var abcLine;
   // Adjust the x-coordinates to their absolute positions
@@ -24628,7 +25036,8 @@ var layout = function layout(renderer, abctune, width, space, expandToWidest) {
     abcLine = abctune.lines[i];
     if (abcLine.staff) {
       // console.log("=== line", i)
-      var thisWidth = setXSpacing(renderer, maxWidth, space, abcLine.staffGroup, abctune.formatting, i === abctune.lines.length - 1, false);
+      var thisWidth;
+      if (timeBasedLayout !== undefined) thisWidth = layoutInGrid(renderer, abcLine.staffGroup, timeBasedLayout);else thisWidth = setXSpacing(renderer, maxWidth, space, abcLine.staffGroup, abctune.formatting, i === abctune.lines.length - 1, false);
       // console.log(thisWidth, maxWidth)
       if (Math.round(thisWidth) > Math.round(maxWidth)) {
         // to take care of floating point weirdness
@@ -24663,40 +25072,34 @@ var layout = function layout(renderer, abctune, width, space, expandToWidest) {
 var setXSpacing = function setXSpacing(renderer, width, space, staffGroup, formatting, isLastLine, debug) {
   var leftEdge = getLeftEdgeOfStaff(renderer, staffGroup.getTextSize, staffGroup.voices, staffGroup.brace, staffGroup.bracket);
   var newspace = space;
+  //dumpGroup("before", staffGroup)
   for (var it = 0; it < 8; it++) {
     // TODO-PER: shouldn't need multiple passes, but each pass gets it closer to the right spacing. (Only affects long lines: normal lines break out of this loop quickly.)
     // console.log("iteration", it)
-    // dumpGroup("before", staffGroup)
-    var ret = layoutStaffGroup(newspace, renderer, debug, staffGroup, leftEdge);
-    // dumpGroup("after",staffGroup)
+    var ret = layoutStaffGroup(newspace, renderer.minPadding, debug, staffGroup, leftEdge);
     newspace = calcHorizontalSpacing(isLastLine, formatting.stretchlast, width + renderer.padding.left, staffGroup.w, newspace, ret.spacingUnits, ret.minSpace, renderer.padding.left + renderer.padding.right);
     if (debug) console.log("setXSpace", it, staffGroup.w, newspace, staffGroup.minspace);
     if (newspace === null) break;
   }
+  //dumpGroup("after",staffGroup)
   centerWholeRests(staffGroup.voices);
   return staffGroup.w - leftEdge;
 };
-
-// function dumpGroup(label, staffGroup) {
-// 	var output = {
-// 		line: staffGroup.line,
-// 		w: staffGroup.w,
-// 		voice: {
-// 			i: staffGroup.voices[0].i,
-// 			minx: staffGroup.voices[0].minx,
-// 			nextx: staffGroup.voices[0].nextx,
-// 			spacingduration: staffGroup.voices[0].spacingduration,
-// 			w: staffGroup.voices[0].w,
-// 			children: [],
-// 		}
-// 	}
-// 	for (var i = 0; i < staffGroup.voices[0].children.length; i++) {
-// 		var child = staffGroup.voices[0].children[i]
-// 		output.voice.children.push({ fixedW: child.fixed.w, w: child.w, x: child.x, type: child.type })
-// 	}
-// 	console.log(label,output)
-// }
-
+function replacer(key, value) {
+  // Filtering out properties
+  if (key === 'parent') {
+    return 'parent';
+  }
+  if (key === 'beam') {
+    return 'beam';
+  }
+  return value;
+}
+function dumpGroup(label, staffGroup) {
+  console.log("=================== " + label + " =========================");
+  console.log(staffGroup);
+  console.log(JSON.stringify(staffGroup, replacer, "\t"));
+}
 function calcHorizontalSpacing(isLastLine, stretchLast, targetWidth, lineWidth, spacing, spacingUnits, minSpace, padding) {
   if (isLastLine) {
     if (stretchLast === undefined) {
@@ -24827,6 +25230,7 @@ var setUpperAndLowerElements = function setUpperAndLowerElements(renderer, staff
       var addedSpace = minSpacingInPitches - forcedSpacingBetween;
       if (addedSpace > 0) staff.top += addedSpace;
     }
+    staff.top += renderer.spacing.staffTopMargin / spacing.STEP;
     lastStaffBottom = 2 - staff.bottom; // the staff starts at position 2 and the bottom variable is negative. Therefore to find out how large the bottom is, we reverse the sign of the bottom, and add the 2 in.
 
     // Now we need a little margin on the top, so we'll just throw that in.
@@ -24985,7 +25389,7 @@ function checkLastBarX(voices) {
     }
   }
 }
-var layoutStaffGroup = function layoutStaffGroup(spacing, renderer, debug, staffGroup, leftEdge) {
+var layoutStaffGroup = function layoutStaffGroup(spacing, minPadding, debug, staffGroup, leftEdge) {
   var epsilon = 0.0000001; // Fudging for inexactness of floating point math.
   var spacingunits = 0; // number of times we will have ended up using the spacing distance (as opposed to fixed width distances)
   var minspace = 1000; // a big number to start off with - used to find out what the smallest space between two notes is -- GD 2014.1.7
@@ -25041,7 +25445,7 @@ var layoutStaffGroup = function layoutStaffGroup(spacing, renderer, debug, staff
       if (v.voicenumber === 0) lastTopVoice = i;
       var topVoice = lastTopVoice !== undefined && currentvoices[lastTopVoice].voicenumber !== v.voicenumber ? currentvoices[lastTopVoice] : undefined;
       if (!isSameStaff(v, topVoice)) topVoice = undefined;
-      var voicechildx = layoutVoiceElements.layoutOneItem(x, spacing, v, renderer.minPadding, topVoice);
+      var voicechildx = layoutVoiceElements.layoutOneItem(x, spacing, v, minPadding, topVoice);
       var dx = voicechildx - x;
       if (dx > 0) {
         x = voicechildx; //update x
@@ -25267,7 +25671,7 @@ VoiceElement.shiftRight = function (dx, voice) {
 
 // call when spacingduration has been updated
 VoiceElement.updateNextX = function (x, spacing, voice) {
-  voice.nextx = x + spacing * Math.sqrt(voice.spacingduration * 8);
+  voice.nextx = x + spacing * this.getSpacingUnits(voice);
 };
 VoiceElement.updateIndices = function (voice) {
   if (!this.layoutEnded(voice)) {
@@ -25332,7 +25736,7 @@ function moveDecorations(beam) {
       var top = yAtNote(child, beam);
       for (var i = 0; i < child.children.length; i++) {
         var el = child.children[i];
-        if (el.klass === 'ornament') {
+        if (el.klass === 'ornament' && el.position !== 'below') {
           if (el.bottom - padding < top) {
             var distance = top - el.bottom + padding; // Find the distance that it needs to move and add a little margin so the element doesn't touch the beam.
             el.bottom += distance;
@@ -25536,6 +25940,7 @@ Renderer.prototype.initVerticalSpace = function () {
     // Set the slur height factor.
     staffSeparation: 61.33,
     // Do not put a staff system closer than <unit> from the previous system.
+    staffTopMargin: 0,
     stemHeight: 26.67 + 10,
     // Set the stem height.
     subtitle: 3.78,
@@ -25587,6 +25992,7 @@ Renderer.prototype.setVerticalSpace = function (formatting) {
   if (formatting.musicspace !== undefined) this.spacing.music = formatting.musicspace * 4 / 3;
   if (formatting.titlespace !== undefined) this.spacing.title = formatting.titlespace * 4 / 3;
   if (formatting.sysstaffsep !== undefined) this.spacing.systemStaffSeparation = formatting.sysstaffsep * 4 / 3;
+  if (formatting.stafftopmargin !== undefined) this.spacing.staffTopMargin = formatting.stafftopmargin * 4 / 3;
   if (formatting.subtitlespace !== undefined) this.spacing.subtitle = formatting.subtitlespace * 4 / 3;
   if (formatting.topspace !== undefined) this.spacing.top = formatting.topspace * 4 / 3;
   if (formatting.vocalspace !== undefined) this.spacing.vocal = formatting.vocalspace * 4 / 3;
@@ -25970,7 +26376,7 @@ module.exports = Svg;
   \********************/
 /***/ (function(module) {
 
-var version = '6.3.0';
+var version = '6.4.0';
 module.exports = version;
 
 /***/ })