abcjs 6.0.0-beta.7 → 6.0.0

package/src/api/abc_timing_callbacks.js

@@ -1,18 +1,3 @@
-//    Copyright (C) 2015-2020 Paul Rosen (paul at paulrosen dot net)
-//
-//    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-//    documentation files (the "Software"), to deal in the Software without restriction, including without limitation
-//    the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
-//    to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-//
-//    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-//
-//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
-//    BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-//    DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
 var TimingCallbacks = function(target, params) {
 	var self = this;
 	if (!params) params = {};
@@ -27,166 +12,299 @@ var TimingCallbacks = function(target, params) {
 	self.lineEndCallback = params.lineEndCallback;   // This is called when the end of a line is approaching.
 	self.lineEndAnticipation = params.lineEndAnticipation ? parseInt(params.lineEndAnticipation, 10) : 0;   // How many milliseconds before the end should the call happen.
 	self.beatSubdivisions = params.beatSubdivisions ? parseInt(params.beatSubdivisions, 10) : 1; // how many callbacks per beat is desired.
+	self.joggerTimer = null;
 
 	self.replaceTarget = function(newTarget) {
-		newTarget.setTiming(self.qpm, self.extraMeasuresAtBeginning);
+		self.noteTimings = newTarget.setTiming(self.qpm, self.extraMeasuresAtBeginning);
 		if (newTarget.noteTimings.length === 0)
 			newTarget.setTiming(0,0);
 		if (self.lineEndCallback) {
 			self.lineEndTimings = getLineEndTimings(newTarget.noteTimings, self.lineEndAnticipation);
 		}
-		self.noteTimings = newTarget.noteTimings;
+		self.startTime = null;
+		self.currentBeat = 0;
+		self.currentEvent = 0;
+		self.currentLine = 0;
+		self.currentTime = 0;
+		self.isPaused = false;
+		self.isRunning = false;
+		self.pausedPercent = null;
+		self.justUnpaused = false;
+		self.newSeekPercent = 0;
+		self.lastTimestamp = 0;
+
+		if (self.noteTimings.length === 0)
+			return;
+		// noteTimings contains an array of events sorted by time. Events that happen at the same time are in the same element of the array.
+		self.millisecondsPerBeat = 1000 / (self.qpm / 60) / self.beatSubdivisions;
+		self.lastMoment = self.noteTimings[self.noteTimings.length-1].milliseconds;
+		self.totalBeats = Math.round(self.lastMoment / self.millisecondsPerBeat);
 	};
 
 	self.replaceTarget(target);
-	if (self.noteTimings.length === 0)
-		return;
-
-	// noteTimings contains an array of events sorted by time. Events that happen at the same time are in the same element of the array.
-	self.noteTimings = target.noteTimings;
-	self.millisecondsPerBeat = 1000 / (self.qpm / 60) / self.beatSubdivisions;
-	self.lastMoment = self.noteTimings[self.noteTimings.length-1].milliseconds;
-	self.totalBeats = Math.round(self.lastMoment / self.millisecondsPerBeat);
-
-	self.startTime = null;
-	self.currentBeat = 0;
-	self.currentEvent = 0;
-	self.isPaused = false;
-	self.isRunning = false;
-	self.pausedTime = null;
-	self.justUnpaused = false;
-
-	self.newSeekPercent = 0;
-	self.justSeeked = false;
-
-	function setCurrentLocation(timestamp) {
-		// First find the relative amount to move: that is, the difference between the current percentage and the passed in percent.
-		var currentPercent = (timestamp - self.startTime) / self.lastMoment;
-		var percentDifference = currentPercent - self.newSeekPercent;
-		var timeDifference = self.lastMoment * percentDifference;
-		self.startTime = self.startTime + timeDifference;
-
-		var currentTime = timestamp - self.startTime;
-		currentTime += 16; // Add a little slop because this function isn't called exactly.
-
-		var oldBeat = self.currentBeat;
-		self.currentBeat = Math.floor(currentTime / self.millisecondsPerBeat);
-		if (self.beatCallback && oldBeat !== self.currentBeat) // If the movement caused the beat to change, then immediately report it to the client.
-			self.beatCallback(self.currentBeat / self.beatSubdivisions, self.totalBeats / self.beatSubdivisions, self.lastMoment);
-
-		self.currentEvent = 0;
-		while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < currentTime) {
-			self.currentEvent++;
-		}
-		if (self.eventCallback && self.currentEvent > 0 && self.noteTimings[self.currentEvent - 1].type === 'event')
-			self.eventCallback(self.noteTimings[self.currentEvent - 1]);
-
-		// console.log("currentPercent="+currentPercent+
-		// 	" newSeekPercent="+self.newSeekPercent+
-		// 	" percentDifference="+percentDifference+
-		// 	" timeDifference=",timeDifference+
-		// 	" currentBeat="+self.currentBeat+
-		// 	" currentEvent="+self.currentEvent);
-	}
 
-	self.lastTimestamp = 0;
 	self.doTiming = function (timestamp) {
 		// This is called 60 times a second, that is, every 16 msecs.
 		//console.log("doTiming", timestamp, timestamp-self.lastTimestamp);
 		if (self.lastTimestamp === timestamp)
-			return; // If there are multiple seeks or other calls, then we can easily get multiple callbacks for the same instance.
+			return; // If there are multiple seeks or other calls, then we can easily get multiple callbacks for the same instant.
 		self.lastTimestamp = timestamp;
 		if (!self.startTime) {
 			self.startTime = timestamp;
-		} else if (self.justUnpaused) {
-			// Add the amount we paused to the start time to get the right place.
-			var timePaused = (timestamp - self.pausedTime);
-			self.startTime += timePaused;
 		}
-		self.justUnpaused = false;
 
-		if (self.justSeeked) {
-			setCurrentLocation(timestamp);
-			self.justSeeked = false;
-		}
-		if (self.isPaused) {
-			self.pausedTime = timestamp;
-		} else if (self.isRunning) {
-			var currentTime = timestamp - self.startTime;
-			currentTime += 16; // Add a little slop because this function isn't called exactly.
-			while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < currentTime) {
-				if (self.eventCallback && self.noteTimings[self.currentEvent].type === 'event')
+		if (!self.isPaused && self.isRunning) {
+			self.currentTime = timestamp - self.startTime;
+			self.currentTime += 16; // Add a little slop because this function isn't called exactly.
+			while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < self.currentTime) {
+				if (self.eventCallback && self.noteTimings[self.currentEvent].type === 'event') {
+					var thisStartTime = self.startTime; // the event callback can call seek and change the position from beneath us.
 					self.eventCallback(self.noteTimings[self.currentEvent]);
+					if (thisStartTime !== self.startTime) {
+						self.currentTime = timestamp - self.startTime;
+					}
+				}
 				self.currentEvent++;
 			}
-			if (currentTime < self.lastMoment) {
+			if (self.lineEndCallback && self.lineEndTimings.length > self.currentLine && self.lineEndTimings[self.currentLine].milliseconds < self.currentTime && self.currentEvent < self.noteTimings.length) {
+				var leftEvent = self.noteTimings[self.currentEvent].milliseconds === self.currentTime ? self.noteTimings[self.currentEvent] : self.noteTimings[self.currentEvent-1]
+				self.lineEndCallback(self.lineEndTimings[self.currentLine], leftEvent, { line: self.currentLine, endTimings: self.lineEndTimings, currentTime: self.currentTime });
+				self.currentLine++;
+			}
+			if (self.currentTime < self.lastMoment) {
 				requestAnimationFrame(self.doTiming);
-				if (self.currentBeat * self.millisecondsPerBeat < currentTime) {
-					if (self.beatCallback)
-						self.beatCallback(self.currentBeat / self.beatSubdivisions, self.totalBeats / self.beatSubdivisions, self.lastMoment);
-					self.currentBeat++;
+				if (self.currentBeat * self.millisecondsPerBeat < self.currentTime) {
+					var ret = self.doBeatCallback(timestamp);
+					if (ret !== null)
+						self.currentTime = ret;
 				}
 			} else if (self.currentBeat <= self.totalBeats) {
 				// Because of timing issues (for instance, if the browser tab isn't active), the beat callbacks might not have happened when they are supposed to. To keep the client programs from having to deal with that, this will keep calling the loop until all of them have been sent.
 				if (self.beatCallback) {
-					self.beatCallback(self.currentBeat / self.beatSubdivisions, self.totalBeats / self.beatSubdivisions, self.lastMoment);
-					self.currentBeat++;
+					var ret2 = self.doBeatCallback(timestamp);
+					if (ret2 !== null)
+						self.currentTime = ret2;
 					requestAnimationFrame(self.doTiming);
 				}
 			}
 
-			if (self.lineEndCallback && self.lineEndTimings.length && self.lineEndTimings[0].milliseconds <= currentTime) {
-				self.lineEndCallback(self.lineEndTimings[0]);
-				self.lineEndTimings.shift();
+			if (self.currentTime >= self.lastMoment) {
+				if (self.eventCallback) {
+					// At the end, the event callback can return "continue" to keep from stopping.
+					// The event callback can either be a promise or not.
+					var promise = self.eventCallback(null);
+					self.shouldStop(promise).then(function(shouldStop) {
+						if (shouldStop)
+							self.stop();
+					})
+				} else
+					self.stop();
+			}
+		}
+	};
+
+	self.shouldStop = function(promise) {
+		// The return of the last event callback can be "continue" or a promise that returns "continue".
+		// If it is then don't call stop. Any other value calls stop.
+		return new Promise(function (resolve) {
+			if (!promise)
+				return resolve(true);
+			if (promise === "continue")
+				return resolve(false);
+			if (promise.then) {
+				promise.then(function (result) {
+					resolve(result !== "continue");
+				});
+			}
+		});
+	};
+
+	self.doBeatCallback = function(timestamp) {
+		if (self.beatCallback) {
+			var next = self.currentEvent;
+			while (next < self.noteTimings.length && self.noteTimings[next].left === null)
+				next++;
+			var endMs;
+			var ev;
+			if (next < self.noteTimings.length) {
+				endMs = self.noteTimings[next].milliseconds;
+				next = self.currentEvent - 1;
+				while (next >= 0 && self.noteTimings[next].left === null)
+					next--;
+
+				ev = self.noteTimings[next];
 			}
 
-			if (currentTime >= self.lastMoment && self.eventCallback)
-				self.eventCallback(null);
+			var position = {};
+			var debugInfo = {};
+			if (ev) {
+				position.top = ev.top;
+				position.height = ev.height;
+
+				// timestamp = the time passed in from the animation timer
+				// self.startTime = the time that the tune was started (if there was seeking or pausing, it is adjusted to keep the math the same)
+				// ev = the event that is either happening now or has most recently passed.
+				// ev.milliseconds = the time that the current event starts (relative to self.startTime)
+				// endMs = the time that the next event starts
+				// ev.endX = the x coordinate that the next event happens (or the end of the line or repeat measure)
+				// ev.left = the x coordinate of the current event
+				//
+				// The output is the X coordinate of the current cursor location. It is calculated with the ratio of the length of the event and the width of it.
+				var offMs = Math.max(0, timestamp-self.startTime-ev.milliseconds); // Offset in time from the last beat
+				var gapMs = endMs - ev.milliseconds; // Length of this event in time
+				var gapPx = ev.endX - ev.left; // The length in pixels
+				var offPx = offMs * gapPx / gapMs;
+				position.left = ev.left + offPx;
+				debugInfo = {
+					timestamp: timestamp,
+					startTime: self.startTime,
+					ev: ev,
+					endMs: endMs,
+					offMs: offMs,
+					offPs: offPx,
+					gapMs: gapMs,
+					gapPx: gapPx
+				};
+			} else {
+				debugInfo = {
+					timestamp: timestamp,
+					startTime: self.startTime,
+				};
+			}
+
+			var thisStartTime = self.startTime; // the beat callback can call seek and change the position from beneath us.
+			self.beatCallback(
+				self.currentBeat / self.beatSubdivisions,
+				self.totalBeats / self.beatSubdivisions,
+				self.lastMoment,
+				position,
+				debugInfo);
+			if (thisStartTime !== self.startTime) {
+				return timestamp - self.startTime;
+			} else
+				self.currentBeat++;
 		}
+		return null;
 	};
 
-	self.start = function(offsetPercent) {
+	// In general music doesn't need a timer at 60 fps because notes don't happen that fast.
+	// For instance, at 120 beats per minute, a sixteenth note takes 125ms. So just as a
+	// compromise value between performance and jank this is set about half that.
+	var JOGGING_INTERVAL = 60;
+
+	self.animationJogger = function() {
+		// There are some cases where the animation timer doesn't work: for instance when
+		// this isn't running in a visible tab and sometimes on mobile devices. We compensate
+		// by having a backup timer using setTimeout. This won't be accurate so the performance
+		// will be jerky, but without it the requestAnimationFrame might be skipped and so
+		// not called again.
+		if (self.isRunning) {
+			self.doTiming(performance.now());
+			self.joggerTimer = setTimeout(self.animationJogger, JOGGING_INTERVAL);
+		}
+	};
+
+	self.start = function(offsetPercent, units) {
 		self.isRunning = true;
 		if (self.isPaused) {
 			self.isPaused = false;
-			self.justUnpaused = true;
+			if (offsetPercent === undefined)
+				self.justUnpaused = true;
 		}
 		if (offsetPercent) {
-			self.setProgress(offsetPercent);
-		} else {
-			requestAnimationFrame(self.doTiming);
+			self.setProgress(offsetPercent, units);
+		} else if (offsetPercent === 0) {
+			self.reset();
+		} else if (self.pausedPercent !== null) {
+			var now = performance.now();
+			self.currentTime = self.lastMoment * self.pausedPercent;
+			self.startTime = now - self.currentTime;
+			self.pausedPercent = null;
+			self.reportNext = true;
 		}
+		requestAnimationFrame(self.doTiming);
+		self.joggerTimer = setTimeout(self.animationJogger, JOGGING_INTERVAL);
 	};
 	self.pause = function() {
 		self.isPaused = true;
+		var now = performance.now();
+		self.pausedPercent = (now - self.startTime) / self.lastMoment;
 		self.isRunning = false;
+		if (self.joggerTimer) {
+			clearTimeout(self.joggerTimer);
+			self.joggerTimer = null;
+		}
+	};
+	self.currentMillisecond = function() {
+		return self.currentTime;
 	};
 	self.reset = function() {
 		self.currentBeat = 0;
 		self.currentEvent = 0;
+		self.currentLine = 0;
 		self.startTime = null;
-		self.pausedTime = null;
-		if (self.lineEndCallback) {
-			self.lineEndTimings = getLineEndTimings(self.noteTimings, self.lineEndAnticipation);
-		}
+		self.pausedPercent = null;
 	};
 	self.stop = function() {
 		self.pause();
 		self.reset();
 	};
-	self.setProgress = function(percent) {
-		// this is passed a value between 0 and 1.
+	self.setProgress = function(position, units) {
 		// the effect of this function is to move startTime so that the callbacks happen correctly for the new seek.
-		if (percent < 0) percent = 0;
-		if (percent > 1) percent = 1;
+		var percent;
+		switch (units) {
+			case "seconds":
+				self.currentTime = position * 1000;
+				if (self.currentTime < 0) self.currentTime = 0;
+				if (self.currentTime > self.lastMoment) self.currentTime = self.lastMoment;
+				percent = self.currentTime / self.lastMoment;
+				break;
+			case "beats":
+				self.currentTime = position * self.millisecondsPerBeat * self.beatSubdivisions;
+				if (self.currentTime < 0) self.currentTime = 0;
+				if (self.currentTime > self.lastMoment) self.currentTime = self.lastMoment;
+				percent = self.currentTime / self.lastMoment;
+				break;
+			default:
+				// this is "percent" or any illegal value
+				// this is passed a value between 0 and 1.
+				percent = position;
+				if (percent < 0) percent = 0;
+				if (percent > 1) percent = 1;
+				self.currentTime = self.lastMoment * percent;
+				break;
+		}
+
+		if (!self.isRunning)
+			self.pausedPercent = percent;
+
+		var now = performance.now();
+		self.startTime = now - self.currentTime;
+
+		var oldEvent = self.currentEvent;
+		self.currentEvent = 0;
+		while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < self.currentTime) {
+			self.currentEvent++;
+		}
 
-		self.newSeekPercent = percent;
-		self.justSeeked = true;
-		self.doTiming(performance.now());
-		//requestAnimationFrame(self.doTiming);
 		if (self.lineEndCallback) {
-			self.lineEndTimings = getLineEndTimings(self.noteTimings, self.lineEndAnticipation);
+			self.currentLine = 0;
+			while (self.lineEndTimings.length > self.currentLine && self.lineEndTimings[self.currentLine].milliseconds + self.lineEndAnticipation < self.currentTime) {
+				self.currentLine++;
+			}
 		}
+
+		var oldBeat = self.currentBeat;
+		self.currentBeat = Math.floor(self.currentTime / self.millisecondsPerBeat);
+		if (self.beatCallback && oldBeat !== self.currentBeat) // If the movement caused the beat to change, then immediately report it to the client.
+			self.doBeatCallback(self.startTime+self.currentTime);
+
+		if (self.eventCallback && self.currentEvent >= 0 && self.noteTimings[self.currentEvent].type === 'event')
+			self.eventCallback(self.noteTimings[self.currentEvent]);
+		if (self.lineEndCallback)
+			self.lineEndCallback(self.lineEndTimings[self.currentLine], self.noteTimings[self.currentEvent], { line: self.currentLine, endTimings: self.lineEndTimings });
+
+		self.joggerTimer = setTimeout(self.animationJogger, JOGGING_INTERVAL);
 	};
 };
 
@@ -197,8 +315,8 @@ function getLineEndTimings(timings, anticipation) {
 	var lastTop = null;
 	for (var i = 0; i < timings.length; i++) {
 		var timing = timings[i];
-		if (timing.top !== lastTop) {
-			callbackTimes.push({ milliseconds: timing.milliseconds - anticipation, top: timing.top, bottom: timing.top+timing.height });
+		if (timing.type !== 'end' && timing.top !== lastTop) {
+			callbackTimes.push({ measureNumber: timing.measureNumber, milliseconds: timing.milliseconds-anticipation, top: timing.top, bottom: timing.top+timing.height });
 			lastTop = timing.top;
 		}
 	}

package/src/api/abc_tunebook.js

@@ -1,24 +1,9 @@
 //    abc_tunebook.js: splits a string representing ABC Music Notation into individual tunes.
-//    Copyright (C) 2010-2020 Paul Rosen (paul at paulrosen dot net)
-//
-//    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-//    documentation files (the "Software"), to deal in the Software without restriction, including without limitation
-//    the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
-//    to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-//
-//    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-//
-//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
-//    BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-//    DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-//    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-/*global document */
-/*global window, ABCJS, console */
-
-var parseCommon = require('../parse/abc_common');
 var Parse = require('../parse/abc_parse');
+var bookParser = require('../parse/abc_parse_book');
+var tablatures = require('./abc_tablatures');
+
 
 var tunebook = {};
 
@@ -33,52 +18,9 @@ var tunebook = {};
 	};
 
 	var TuneBook = tunebook.TuneBook = function(book) {
-		var This = this;
-		var directives = "";
-		book = parseCommon.strip(book);
-		var tunes = book.split("\nX:");
-		for (var i = 1; i < tunes.length; i++)	// Put back the X: that we lost when splitting the tunes.
-			tunes[i] = "X:" + tunes[i];
-		// Keep track of the character position each tune starts with.
-		var pos = 0;
-		This.tunes = [];
-		parseCommon.each(tunes, function(tune) {
-			This.tunes.push({ abc: tune, startPos: pos});
-			pos += tune.length + 1; // We also lost a newline when splitting, so count that.
-		});
-		if (This.tunes.length > 1 && !parseCommon.startsWith(This.tunes[0].abc, 'X:')) {	// If there is only one tune, the X: might be missing, otherwise assume the top of the file is "intertune"
-			// There could be file-wide directives in this, if so, we need to insert it into each tune. We can probably get away with
-			// just looking for file-wide directives here (before the first tune) and inserting them at the bottom of each tune, since
-			// the tune is parsed all at once. The directives will be seen before the engraver begins processing.
-			var dir = This.tunes.shift();
-			var arrDir = dir.abc.split('\n');
-			parseCommon.each(arrDir, function(line) {
-				if (parseCommon.startsWith(line, '%%'))
-					directives += line + '\n';
-			});
-		}
-		This.header = directives;
-
-		// Now, the tune ends at a blank line, so truncate it if needed. There may be "intertune" stuff.
-		parseCommon.each(This.tunes, function(tune) {
-			var end = tune.abc.indexOf('\n\n');
-			if (end > 0)
-				tune.abc = tune.abc.substring(0, end);
-			tune.pure = tune.abc;
-			tune.abc = directives + tune.abc;
-
-			// for the user's convenience, parse and store the title separately. The title is between the first T: and the next \n
-			var title = tune.pure.split("T:");
-			if (title.length > 1) {
-				title = title[1].split("\n");
-				tune.title = title[0].replace(/^\s+|\s+$/g, '');
-			} else
-				tune.title = "";
-
-			// for the user's convenience, parse and store the id separately. The id is between the first X: and the next \n
-			var id = tune.pure.substring(2, tune.pure.indexOf("\n"));
-			tune.id = id.replace(/^\s+|\s+$/g, '');
-		});
+		var parsed = bookParser(book);
+		this.header = parsed.header;
+		this.tunes = parsed.tunes;
 	};
 
 	TuneBook.prototype.getTuneById = function(id) {
@@ -98,7 +40,6 @@ var tunebook = {};
 	};
 
 	tunebook.parseOnly = function(abc, params) {
-		var tunes = [];
 		var numTunes = tunebook.numberOfTunes(abc);
 
 		// this just needs to be passed in because this tells the engine how many tunes to process.
@@ -142,16 +83,26 @@ var tunebook = {};
 				if (currentTune >= 0 && currentTune < book.tunes.length) {
 					abcParser.parse(book.tunes[currentTune].abc, params, book.tunes[currentTune].startPos - book.header.length);
 					var tune = abcParser.getTune();
+					//
+					// Init tablatures plugins
+					//
+					if (params.tablature) {
+						tablatures.init();
+						tune.tablatures = tablatures.preparePlugins(tune, currentTune, params);
+					}
+					var warnings = abcParser.getWarnings();
+					if (warnings)
+						tune.warnings = warnings;
 					var override = callback(div, tune, i, book.tunes[currentTune].abc);
 					ret.push(override ? override : tune);
 				} else {
-					if (div.hasOwnProperty('innerHTML'))
+					if (div['innerHTML'])
 						div.innerHTML = "";
 				}
 			}
 			currentTune++;
 		}
-		return ret;
+	  return ret;
 	};
 
 	function flattenTune(tuneObj) {