abcjs 6.0.0-beta.32 → 6.0.0-beta.36

package/src/synth/abc_midi_sequencer.js

@@ -143,9 +143,10 @@ var parseCommon = require("../parse/abc_common");
 		var startRepeatPlaceholder = []; // There is a place holder for each voice.
 		var skipEndingPlaceholder = []; // This is the place where the first ending starts.
 		var startingDrumSet = false;
-		for (var i = 0; i < abctune.lines.length; i++) {
+		var lines = abctune.lines; //abctune.deline(); TODO-PER: can switch to this, then simplify the loops below.
+		for (var i = 0; i < lines.length; i++) {
 			// For each group of staff lines in the tune.
-			var line = abctune.lines[i];
+			var line = lines[i];
 			if (line.staff) {
 				var staves = line.staff;
 				var voiceNumber = 0;
@@ -171,13 +172,10 @@ var parseCommon = require("../parse/abc_common");
 									voices[voiceNumber][cl].program = PERCUSSION_PROGRAM;
 							}
 						} else if (staff.key) {
-							if (staff.key.root === 'HP')
-								voices[voiceNumber].push({el_type: 'key', accidentals: [{acc: 'natural', note: 'g'}, {acc: 'sharp', note: 'f'}, {acc: 'sharp', note: 'c'}]});
-							else
-								voices[voiceNumber].push({el_type: 'key', accidentals: staff.key.accidentals });
+							addKey(voices[voiceNumber], staff.key);
 						}
 						if (staff.meter) {
-							voices[voiceNumber].push(interpretMeter(staff.meter));
+							addMeter(voices[voiceNumber], staff.meter);
 						}
 						if (!startingDrumSet && drumOn) { // drum information is only needed once, so use the first line and track 0.
 							voices[voiceNumber].push({el_type: 'drum', params: {pattern: drumPattern, bars: drumBars, on: drumOn, intro: drumIntro}});
@@ -237,6 +235,15 @@ var parseCommon = require("../parse/abc_common");
 										if (elem.startTriplet) {
 											tripletMultiplier = elem.tripletMultiplier;
 											tripletDurationTotal = elem.startTriplet * tripletMultiplier * elem.duration;
+											if (elem.startTriplet != elem.tripletR) { // most commonly (3:2:2
+												if (v + elem.tripletR <= voice.length) {
+													var durationTotal = 0;
+													for (var w = v; w < v + elem.tripletR; w++) {
+														durationTotal += voice[w].duration;
+													}
+													tripletDurationTotal = tripletMultiplier * durationTotal;
+												}
+											}
 											noteElem.duration = noteElem.duration * tripletMultiplier;
 											noteElem.duration = Math.round(noteElem.duration*1000000)/1000000;
 											tripletDurationCount = noteElem.duration;
@@ -266,13 +273,11 @@ var parseCommon = require("../parse/abc_common");
 									}
 									break;
 								case "key":
-									if (elem.root === 'HP')
-										voices[voiceNumber].push({el_type: 'key', accidentals: [{acc: 'natural', note: 'g'}, {acc: 'sharp', note: 'f'}, {acc: 'sharp', note: 'c'}]});
-									else
-										voices[voiceNumber].push({el_type: 'key', accidentals: elem.accidentals });
+								case "keySignature":
+									addKey(voices[voiceNumber], elem);
 									break;
 								case "meter":
-									voices[voiceNumber].push(interpretMeter(elem));
+									addMeter(voices[voiceNumber], elem);
 									break;
 								case "clef": // need to keep this to catch the "transpose" element.
 									if (elem.transpose)
@@ -332,6 +337,8 @@ var parseCommon = require("../parse/abc_common");
 									break;
 								case 'stem':
 								case 'scale':
+								case 'break':
+								case 'font':
 									// These elements don't affect sound
 									break;
 								case 'midi':
@@ -351,7 +358,7 @@ var parseCommon = require("../parse/abc_common");
 												voices[voiceNumber].push({ el_type: 'instrument', program: PERCUSSION_PROGRAM });
 											break;
 										case "program":
-											voices[voiceNumber].push({ el_type: 'instrument', program: elem.params[0] });
+											addIfDifferent(voices[voiceNumber], { el_type: 'instrument', program: elem.params[0] });
 											channelExplicitlySet = true;
 											break;
 										case "transpose":
@@ -601,6 +608,38 @@ var parseCommon = require("../parse/abc_common");
 		measureLength = meter.num/meter.den;
 		return meter;
 	}
+
+	function removeNaturals(accidentals) {
+		var acc = [];
+		for (var i = 0; i < accidentals.length; i++) {
+			if (accidentals[i].acc !== "natural")
+				acc.push(accidentals[i])
+		}
+		return acc;
+	}
+	function addKey(arr, key) {
+		var newKey;
+		if (key.root === 'HP')
+			newKey = {el_type: 'key', accidentals: [{acc: 'natural', note: 'g'}, {acc: 'sharp', note: 'f'}, {acc: 'sharp', note: 'c'}]};
+		else
+			newKey = {el_type: 'key', accidentals: removeNaturals(key.accidentals) };
+		addIfDifferent(arr, newKey);
+	}
+	function addMeter(arr, meter) {
+		var newMeter = interpretMeter(meter);
+		addIfDifferent(arr, newMeter);
+	}
+	function addIfDifferent(arr, item) {
+		for (var i = arr.length-1; i >= 0; i--) {
+			if (arr[i].el_type === item.el_type) {
+				if (JSON.stringify(arr[i]) !== JSON.stringify(item))
+					arr.push(item);
+				return;
+			}
+		}
+		arr.push(item);
+	}
+
 })();
 
 module.exports = sequence;

package/src/synth/create-synth.js

@@ -43,7 +43,7 @@ function CreateSynth() {
 		self.soundFontUrl = params.soundFontUrl ? params.soundFontUrl : defaultSoundFontUrl;
 		if (self.soundFontUrl[self.soundFontUrl.length-1] !== '/')
 			self.soundFontUrl += '/';
-		if (params.soundFontVolumeMultiplier)
+		if (params.soundFontVolumeMultiplier || params.soundFontVolumeMultiplier === 0)
 			self.soundFontVolumeMultiplier = params.soundFontVolumeMultiplier;
 		else if (self.soundFontUrl === alternateSoundFontUrl || self.soundFontUrl === alternateSoundFontUrl2)
 			self.soundFontVolumeMultiplier = 5.0;
@@ -65,7 +65,6 @@ function CreateSynth() {
 		p = params.noteEnd !== undefined ? parseInt(params.noteEnd,10) : NaN;
 		self.noteEnd = isNaN(p) ? 0 : p;
 
-		self.millisecondsPerMeasure = options.millisecondsPerMeasure ? options.millisecondsPerMeasure : (options.visualObj ? options.visualObj.millisecondsPerMeasure(options.bpm) : 1000);
 		self.pan = params.pan;
 		self.meterSize = 1;
 		if (options.visualObj) {
@@ -77,6 +76,8 @@ function CreateSynth() {
 			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;
@@ -257,7 +258,7 @@ function CreateSynth() {
 			for (var key2 = 0; key2 < Object.keys(uniqueSounds).length; key2++) {
 				var k = Object.keys(uniqueSounds)[key2];
 				var parts = k.split(":");
-				var cents = parts[6] !== "undefined" ? parseFloat(parts[6]) : undefined;
+				var cents = parts[6] !== undefined ? parseFloat(parts[6]) : 0;
  				parts = { instrument: parts[0], pitch: parseInt(parts[1],10), volume: parseInt(parts[2], 10), len: parseFloat(parts[3]), pan: parseFloat(parts[4]), tempoMultiplier: parseFloat(parts[5]), cents: cents};
 				allPromises.push(placeNote(audioBuffer, activeAudioContext().sampleRate, parts, uniqueSounds[k], self.soundFontVolumeMultiplier, self.programOffsets[parts.instrument], fadeTimeSec, self.noteEnd/1000));
 			}
@@ -344,16 +345,28 @@ function CreateSynth() {
 		if (self.debugCallback)
 			self.debugCallback("pause called");
 
-	 	self.stop();
-		self.pausedTimeSec = activeAudioContext().currentTime - self.startTimeSec;
+		self.pausedTimeSec = self.stop();
+		return self.pausedTimeSec;
 	};
 
 	self.resume = function() {
 		self.start();
 	};
 
-	self.seek = function(percent) {
-		var offset = (self.duration-self.fadeLength/1000) * percent;
+	self.seek = function(position, units) {
+		var offset;
+		switch (units) {
+			case "seconds":
+				offset = position;
+				break;
+			case "beats":
+				offset = position * self.millisecondsPerMeasure / self.beatsPerMeasure / 1000;
+				break;
+			default:
+				// this is "percent" or any illegal value
+				offset = (self.duration-self.fadeLength/1000) * position;
+				break;
+		}
 
 		// TODO-PER: can seek when paused or when playing
 		if (!self.audioBufferPossible)
@@ -382,6 +395,8 @@ function CreateSynth() {
 			}
 		});
 		self.directSource = [];
+		var elapsed = activeAudioContext().currentTime - self.startTimeSec;
+		return elapsed;
 	};
 	self.finished = function() {
 		self.startTimeSec = undefined;

package/src/synth/load-note.js

@@ -2,74 +2,40 @@
 // url = the base url for the soundfont
 // instrument = the instrument name (e.g. "acoustic_grand_piano")
 // name = the pitch name (e.g. "A3")
-var soundsCache = require('./sounds-cache');
+var soundsCache = require("./sounds-cache");
 
-var getNote = function(url, instrument, name, audioContext) {
-	return new Promise(function (resolve, reject) {
-		if (!soundsCache[instrument])
-			soundsCache[instrument] = {};
-		var instrumentCache = soundsCache[instrument];
+var getNote = function (url, instrument, name, audioContext) {
+	if (!soundsCache[instrument]) soundsCache[instrument] = {};
+	var instrumentCache = soundsCache[instrument];
 
-		if (instrumentCache[name] === 'error') {
-			return resolve({instrument: instrument, name: name, status: "error", message: "Unable to load sound font" + ' ' + url + ' ' + instrument + ' ' + name });
-		}
-		if (instrumentCache[name] === 'pending') {
-			return resolve({instrument: instrument, name: name, status: "pending"});
-		}
-		if (instrumentCache[name]) {
-			return resolve({instrument: instrument, name: name, status: "cached"});
-		}
-
-		// if (this.debugCallback)
-		// 	this.debugCallback(`Loading sound: ${instrument} ${name}`);
-		instrumentCache[name] = "pending"; // This can be called in parallel, so don't call it a second time before the first one has loaded.
-		var xhr = new XMLHttpRequest();
-		xhr.open('GET', url+instrument+'-mp3/'+name+'.mp3', true);
-		xhr.responseType = 'arraybuffer';
-
-		var self = this;
-		function onSuccess(audioBuffer) {
-			instrumentCache[name] = audioBuffer;
-			// if (self.debugCallback)
-			// 	self.debugCallback(`Sound loaded: ${instrument} ${name} ${url}`);
-			resolve({instrument: instrument, name: name, status: "loaded"});
-		}
-
-		function onFailure(error) {
-			error = "Can't decode sound. " + url + ' ' + instrument + ' ' + name + ' ' + error;
-			if (self.debugCallback)
-				self.debugCallback(error);
-			return resolve({instrument: instrument, name: name, status: "error", message: error });
-		}
-
-		xhr.onload = function (e) {
-			if (this.status === 200) {
-				try {
-					var promise = audioContext.decodeAudioData(this.response, onSuccess, onFailure);
-					// older browsers only have the callback. Newer ones will report an unhandled
-					// rejection if catch isn't handled so we need both. We don't need to report it twice, though.
-					if (promise && promise.catch)
-						promise.catch(function () {});
-				} catch(error) {
-					reject(error);
+	if (!instrumentCache[name])
+		instrumentCache[name] = new Promise(function (resolve, reject) {
+			var xhr = new XMLHttpRequest();
+			let noteUrl = url + instrument + "-mp3/" + name + ".mp3";
+			xhr.open("GET", noteUrl, true);
+			xhr.responseType = "arraybuffer";
+			xhr.onload = function () {
+				if (xhr.status !== 200) {
+					reject(Error("Can't load sound at " + noteUrl));
+					return
 				}
-			} else {
-				instrumentCache[name] = "error"; // To keep this from trying to load repeatedly.
-				var cantLoadMp3 = "Onload error loading sound: " +  name + " " + url + " " + e.currentTarget.status + " " + e.currentTarget.statusText;
-				if (self.debugCallback)
-					self.debugCallback(cantLoadMp3);
-				return resolve({instrument: instrument, name: name, status: "error", message: cantLoadMp3 });
-			}
-		};
-		xhr.addEventListener("error", function () {
-			instrumentCache[name] = "error"; // To keep this from trying to load repeatedly.
-			var cantLoadMp3 = "Error in loading sound: " + " " + url;
-			if (self.debugCallback)
-				self.debugCallback(cantLoadMp3);
-			return resolve({instrument: instrument, name: name, status: "error", message: cantLoadMp3 });
-		}, false);
-		xhr.send();
-	});
+				var maybePromise = audioContext.decodeAudioData(xhr.response, resolve, function () {
+					reject(Error("Can't decode sound at " + noteUrl));
+				});
+				// In older browsers `BaseAudioContext.decodeAudio()` did not return a promise
+				if (maybePromise && typeof maybePromise.catch === "function") maybePromise.catch(reject);
+			};
+			xhr.onerror = function () {
+				reject(Error("Can't load sound at " + noteUrl));
+			};
+			xhr.send();
+		})
+			.catch(err => {
+				console.error("Didn't load note", instrument, name, ":", err.message);
+				throw err;
+			});
+
+	return instrumentCache[name];
 };
 
 module.exports = getNote;

package/src/synth/place-note.js

@@ -17,74 +17,73 @@ function placeNote(outputAudioBuffer, sampleRate, sound, startArray, volumeMulti
 		len = 0.005; // Have some small audible length no matter how short the note is.
 	var offlineCtx = new OfflineAC(2,Math.floor((len+fadeTimeSec)*sampleRate),sampleRate);
 	var noteName = pitchToNoteName[sound.pitch];
-	var noteBuffer = soundsCache[sound.instrument][noteName];
-	if (noteBuffer === "error" || noteBuffer === "pending") { // If the note isn't available, just leave a blank spot
-		// If the note is still pending by now that means an error happened when loading. There was probably a timeout.
-		console.log("Didn't load note", sound.instrument, noteName, noteBuffer);
-		return;
-	}
+	var noteBufferPromise = soundsCache[sound.instrument][noteName];
 
-	// create audio buffer
-	var source = offlineCtx.createBufferSource();
-	source.buffer = noteBuffer;
+	noteBufferPromise
+		.then(function (audioBuffer) {
+			// create audio buffer
+			var source = offlineCtx.createBufferSource();
+			source.buffer = audioBuffer;
 
-	// add gain
-	// volume can be between 1 to 127. This translation to gain is just trial and error.
-	// The smaller the first number, the more dynamic range between the quietest to loudest.
-	// The larger the second number, the louder it will be in general.
-	var volume = (sound.volume / 96) * volumeMultiplier;
-	source.gainNode = offlineCtx.createGain();
+			// add gain
+			// volume can be between 1 to 127. This translation to gain is just trial and error.
+			// The smaller the first number, the more dynamic range between the quietest to loudest.
+			// The larger the second number, the louder it will be in general.
+			var volume = (sound.volume / 96) * volumeMultiplier;
+			source.gainNode = offlineCtx.createGain();
 
-	// add pan if supported and present
-	if (sound.pan && offlineCtx.createStereoPanner) {
-		source.panNode = offlineCtx.createStereoPanner();
-		source.panNode.pan.setValueAtTime(sound.pan, 0);
-	}
-	source.gainNode.gain.value = volume; // Math.min(2, Math.max(0, volume));
-	source.gainNode.gain.linearRampToValueAtTime(source.gainNode.gain.value, len);
-	source.gainNode.gain.linearRampToValueAtTime(0.0, len + fadeTimeSec);
+			// add pan if supported and present
+			if (sound.pan && offlineCtx.createStereoPanner) {
+				source.panNode = offlineCtx.createStereoPanner();
+				source.panNode.pan.setValueAtTime(sound.pan, 0);
+			}
+			source.gainNode.gain.value = volume; // Math.min(2, Math.max(0, volume));
+			source.gainNode.gain.linearRampToValueAtTime(source.gainNode.gain.value, len);
+			source.gainNode.gain.linearRampToValueAtTime(0.0, len + fadeTimeSec);
 
-	if (sound.cents) {
-		source.playbackRate.value = centsToFactor(sound.cents);
-	}
+			if (sound.cents) {
+				source.playbackRate.value = centsToFactor(sound.cents);
+			}
 
-	// connect all the nodes
-	if (source.panNode) {
-		source.panNode.connect(offlineCtx.destination);
-		source.gainNode.connect(source.panNode);
-	} else {
-		source.gainNode.connect(offlineCtx.destination);
-	}
-	source.connect(source.gainNode);
+			// connect all the nodes
+			if (source.panNode) {
+				source.panNode.connect(offlineCtx.destination);
+				source.gainNode.connect(source.panNode);
+			} else {
+				source.gainNode.connect(offlineCtx.destination);
+			}
+			source.connect(source.gainNode);
 
-	// Do the process of creating the sound and placing it in the buffer
-	source.start(0);
+			// Do the process of creating the sound and placing it in the buffer
+			source.start(0);
 
-	if (source.noteOff) {
-		source.noteOff(len + fadeTimeSec);
-	} else {
-		source.stop(len + fadeTimeSec);
-	}
-	var fnResolve;
-	offlineCtx.oncomplete = function(e) {
-		if (e.renderedBuffer) { // If the system gets overloaded then this can start failing. Just drop the note if so.
-			for (var i = 0; i < startArray.length; i++) {
-				//Math.floor(startArray[i] * sound.tempoMultiplier * sampleRate)
-				var start = startArray[i] * sound.tempoMultiplier;
-				if (ofsMs)
-					start -=ofsMs/1000;
-				if (start < 0)
-					start = 0; // If the item that is moved back is at the very beginning of the buffer then don't move it back. To do that would be to push everything else forward. TODO-PER: this should probably be done at some point but then it would change timing in existing apps.
-				start = Math.floor(start*sampleRate);
-				copyToChannel(outputAudioBuffer, e.renderedBuffer, start);
+			if (source.noteOff) {
+				source.noteOff(len + fadeTimeSec);
+			} else {
+				source.stop(len + fadeTimeSec);
 			}
-		}
-		fnResolve();
-	};
-	offlineCtx.startRendering();
-	return new Promise(function(resolve, reject) {
-		fnResolve = resolve;
-	});
+			var fnResolve;
+			offlineCtx.oncomplete = function(e) {
+				if (e.renderedBuffer) { // If the system gets overloaded then this can start failing. Just drop the note if so.
+					for (var i = 0; i < startArray.length; i++) {
+						//Math.floor(startArray[i] * sound.tempoMultiplier * sampleRate)
+						var start = startArray[i] * sound.tempoMultiplier;
+						if (ofsMs)
+							start -=ofsMs/1000;
+						if (start < 0)
+							start = 0; // If the item that is moved back is at the very beginning of the buffer then don't move it back. To do that would be to push everything else forward. TODO-PER: this should probably be done at some point but then it would change timing in existing apps.
+						start = Math.floor(start*sampleRate);
+						copyToChannel(outputAudioBuffer, e.renderedBuffer, start);
+					}
+				}
+				fnResolve();
+			};
+			offlineCtx.startRendering();
+			return new Promise(function(resolve) {
+				fnResolve = resolve;
+			});
+		})
+		.catch(function () {});
 }
 
 var copyToChannel = function(toBuffer, fromBuffer, start) {

package/src/synth/register-audio-context.js

@@ -10,7 +10,10 @@ function registerAudioContext(ac) {
 		// no audio context passed in, so create it unless there is already one from before.
 		if (!window.abcjsAudioContext) {
 			var AudioContext = window.AudioContext || window.webkitAudioContext;
-			window.abcjsAudioContext = new AudioContext();
+			if (AudioContext)
+				window.abcjsAudioContext = new AudioContext();
+			else
+				return false;
 		}
 	}
 	return window.abcjsAudioContext.state !== "suspended";

package/src/synth/supports-audio.js

@@ -11,17 +11,18 @@ var activeAudioContext = require('./active-audio-context');
 // But then, call it again after a user interaction to test for resume.
 
 function supportsAudio() {
-	var aac = activeAudioContext();
-	if (aac)
-		return aac.resume !== undefined;
-
 	if (!window.Promise)
 		return false;
 
-	return !!window.AudioContext ||
-		!!window.webkitAudioContext ||
-		!!navigator.mozAudioContext ||
-		!!navigator.msAudioContext;
+	if (!window.AudioContext &&
+		!window.webkitAudioContext &&
+		!navigator.mozAudioContext &&
+		!navigator.msAudioContext)
+		return false;
+
+	var aac = activeAudioContext();
+	if (aac)
+		return aac.resume !== undefined;
 }
 
 module.exports = supportsAudio;

package/src/synth/synth-controller.js

@@ -204,9 +204,11 @@ function SynthController() {
 		return Promise.resolve({status: "ok"});
 	};
 
-	self.seek = function (percent) {
-		self.timer.setProgress(percent);
-		self.midiBuffer.seek(percent);
+	self.seek = function (percent, units) {
+		if (self.timer && self.midiBuffer) {
+			self.timer.setProgress(percent, units);
+			self.midiBuffer.seek(percent, units);
+		}
 	};
 
 	self.setWarp = function (newWarp) {

package/src/tablatures/instruments/guitar/guitar-fonts.js

@@ -0,0 +1,19 @@
+
+/**
+ * Dedicated fonts for violin tabs
+ */
+
+/**
+ * Set here the fonts used by renderer/drawer 
+ * for the violin plugin
+ * @param {} tune 
+ */
+// eslint-disable-next-line no-unused-vars
+function setGuitarFonts(tune) {
+  /* enhance or change instrument fonts here */
+  // tune.formatting.tabnumberfont = { face: "\"Times New Roman\"", size: 9, weight: "normal", style: "normal", decoration: "none" };
+  // tune.formatting.tabgracefont = { face: "\"Times New Roman\"", size: 7, weight: "normal", style: "normal", decoration: "none" };
+}
+
+module.exports = setGuitarFonts;
+

package/src/tablatures/instruments/guitar/guitar-patterns.js

@@ -0,0 +1,23 @@
+var StringPatterns = require('../string-patterns');
+
+function GuitarPatterns(plugin) {
+  this.tuning = plugin._super.params.tuning;
+  if (!this.tuning) {
+    this.tuning = ['E,', 'A', 'D', 'G' , 'B' , 'e'];
+  }
+  plugin.tuning = this.tuning;
+  this.strings = new StringPatterns(plugin);
+}
+
+GuitarPatterns.prototype.notesToNumber = function (notes, graces) {
+  var converter = this.strings;
+  return converter.notesToNumber(notes, graces);
+};
+
+GuitarPatterns.prototype.stringToPitch = function (stringNumber) {
+  var converter = this.strings;
+  return converter.stringToPitch(stringNumber);
+};
+
+
+module.exports = GuitarPatterns;

package/src/tablatures/instruments/guitar/tab-guitar.js

@@ -0,0 +1,50 @@
+/*
+Emit tab for Guitar staff
+*/
+var StringTablature = require('../string-tablature');
+var TabCommon = require('../../tab-common');
+var TabRenderer = require('../../tab-renderer');
+var GuitarPatterns = require('./guitar-patterns');
+var setGuitarFonts = require('./guitar-fonts');
+
+/**
+* upon init mainly store provided instances for later usage
+* @param {*} abcTune  the parsed tune AST tree
+*  @param {*} tuneNumber  the parsed tune AST tree
+* @param {*} params  complementary args provided to Tablature Plugin
+*/
+Plugin.prototype.init = function (abcTune, tuneNumber, params) {
+  var _super = new TabCommon(abcTune, tuneNumber, params);
+  this._super = _super;
+  this.abcTune = abcTune;
+  this.linePitch = 3;
+  this.nbLines = 6;
+  this.isTabBig = true;
+  this.capo = params.capo;
+  this.transpose = params.visualTranspose;
+  this.tablature = new StringTablature(this.nbLines,
+    this.linePitch);
+
+  var semantics = new GuitarPatterns(this);
+  this.semantics = semantics;
+};
+
+Plugin.prototype.render = function (renderer, line, staffIndex) {
+  if (this._super.inError) return;
+  if (this.tablature.bypass(line)) return;
+  setGuitarFonts(this.abcTune);
+  var rndrer = new TabRenderer(this, renderer, line, staffIndex);
+  rndrer.doLayout();
+};
+
+function Plugin() {}
+
+//
+// Tablature plugin definition
+//
+var AbcGuitarTab = function () {
+  return { name: 'GuitarTab', tablature: Plugin };
+};
+
+
+module.exports = AbcGuitarTab;