abcjs 6.4.1 → 6.4.3

package/src/tablatures/render/tab-absolute-elements.js

@@ -0,0 +1,303 @@
+/**
+ * Tablature Absolute elements factory
+ */
+var AbsoluteElement = require('../../write/creation/elements/absolute-element');
+var RelativeElement = require('../../write/creation/elements/relative-element');
+
+function isObject(a) { return a != null && a.constructor === Object; }
+function cloneObject(dest, src) {
+	for (var prop in src) {
+		if (src.hasOwnProperty(prop)) {
+			if (!(Array.isArray(src[prop]) || isObject(src[prop]))) {
+				dest[prop] = src[prop];
+			}
+		}
+	}
+}
+
+function cloneAbsolute(absSrc) {
+	var returned = new AbsoluteElement('', 0, 0, '', 0);
+	cloneObject(returned, absSrc);
+	returned.top = 0;
+	returned.bottom = -1;
+	if (absSrc.abcelem) {
+		returned.abcelem = {};
+		cloneObject(returned.abcelem, absSrc.abcelem);
+		if (returned.abcelem.el_type === "note")
+			returned.abcelem.el_type = 'tabNumber';
+	}
+	// TODO-PER: This fixes the classes because the element isn't created at the right time.
+	absSrc.cloned = returned
+	return returned;
+}
+
+function cloneAbsoluteAndRelatives(absSrc, plugin) {
+	var returned = cloneAbsolute(absSrc);
+	if (plugin) {
+		var children = absSrc.children;
+		// proceed with relative as well
+		var first = true;
+		for (var ii = 0; ii < children.length; ii++) {
+			var child = children[ii];
+			var relative = new RelativeElement('', 0, 0, 0, '');
+			cloneObject(relative, child);
+			first = plugin.tablature.setRelative(child, relative, first);
+			returned.children.push(relative);
+		}
+	}
+	return returned;
+}
+
+function buildTabAbsolute(plugin, absX, relX) {
+	var tabIcon = 'tab.tiny';
+	var tabYPos = 7.5;
+	if (plugin.isTabBig) {
+		tabIcon = 'tab.big';
+		tabYPos = 10;
+	}
+	var element = {
+		el_type: "tab",
+		icon: tabIcon,
+		Ypos: tabYPos
+	};
+
+	// Offset the TAB symbol position if specified in the tab description
+	tabYPos += plugin.tabSymbolOffset;
+
+	// For tablature like whistle tab where you want the TAB symbol hidden
+	if (!plugin.hideTabSymbol) {
+
+		var tabAbsolute = new AbsoluteElement(element, 0, 0, "symbol", 0);
+		tabAbsolute.x = absX;
+		var tabRelative = new RelativeElement(tabIcon, 0, 0, 7.5, "tab");
+		tabRelative.x = relX;
+		tabAbsolute.children.push(tabRelative);
+		if (tabAbsolute.abcelem.el_type == 'tab') {
+			tabRelative.pitch = tabYPos;
+		}
+
+	}
+	return tabAbsolute;
+}
+
+function lyricsDim(abs) {
+	if (abs.extra) {
+		for (var ii = 0; ii < abs.extra.length; ii++) {
+			var extra = abs.extra[ii];
+			if (extra.type == 'lyric') {
+				return {
+					bottom: extra.bottom,
+					height: extra.height
+				};
+			}
+		}
+	}
+	return null;
+}
+function TabAbsoluteElements() {
+	//console.log("RENDER TabAbsoluteElements constructor")
+	this.accidentals = null;
+}
+
+function getInitialStaffSize(staffGroup) {
+	var returned = 0;
+	for (var ii = 0; ii < staffGroup.length; ii++) {
+		if (!staffGroup[ii].tabNameInfos) returned++;
+	}
+	return returned;
+}
+
+function buildRelativeTabNote(plugin, relX, def, curNote, isGrace) {
+	var strNote = curNote.num;
+	if (curNote.note.quarter != null) {
+		// add tab quarter => needs to string conversion then 
+		strNote = strNote.toString();
+		strNote += curNote.note.quarter;
+	}
+	var pitch = plugin.semantics.stringToPitch(curNote.str);
+	def.notes.push({ num: strNote, str: curNote.str, pitch: curNote.note.emit() });
+	var opt = {
+		type: 'tabNumber'
+	};
+	var tabNoteRelative = new RelativeElement(
+		strNote, 0, 0, pitch + 0.3, opt);
+	tabNoteRelative.x = relX;
+	tabNoteRelative.isGrace = isGrace;
+	tabNoteRelative.isAltered = curNote.note.isAltered;
+	return tabNoteRelative;
+}
+
+function getXGrace(abs, index) {
+	var found = 0;
+	if (abs.extra) {
+		for (var ii = 0; ii < abs.extra.length; ii++) {
+			if (abs.extra[ii].c.indexOf('noteheads') >= 0) {
+				if (found === index) {
+					return abs.extra[ii].x + abs.extra[ii].w / 2;
+				} else {
+					found++;
+				}
+			}
+		}
+	}
+	return -1;
+}
+
+function graceInRest(absElem) {
+	if (absElem.abcelem) {
+		var elem = absElem.abcelem;
+		if (elem.rest) {
+			return elem.gracenotes;
+		}
+	}
+	return null;
+}
+
+function convertToNumber(plugin, pitches, graceNotes) {
+	var tabPos = plugin.semantics.notesToNumber(pitches, graceNotes);
+	if (tabPos.error) {
+		plugin.setError(tabPos.error);
+		return tabPos; // give up on error here
+	}
+	if (tabPos.graces && tabPos.notes) {
+		// add graces to last note in notes
+		var posNote = tabPos.notes.length - 1;
+		tabPos.notes[posNote].graces = tabPos.graces;
+	}
+	return tabPos;
+}
+
+function buildGraceRelativesForRest(plugin, abs, absChild, graceNotes, tabVoice) {
+	for (var mm = 0; mm < graceNotes.length; mm++) {
+		var defGrace = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [], grace: true };
+		var graceX = getXGrace(absChild, mm);
+		var curGrace = graceNotes[mm];
+		var tabGraceRelative = buildRelativeTabNote(plugin, graceX, defGrace, curGrace, true);
+		abs.children.push(tabGraceRelative);
+		tabVoice.push(defGrace);
+	}
+}
+
+/**
+ * Build tab absolutes by scanning current staff line absolute array
+ * @param {*} staffAbsolute
+ */
+TabAbsoluteElements.prototype.build = function (plugin,
+	staffAbsolute,
+	tabVoice,
+	voiceIndex,
+	staffIndex,
+	keySig,
+	tabVoiceIndex) {
+	//console.log("RENDER TabAbsoluteElements build")
+	var staffSize = getInitialStaffSize(staffAbsolute);
+	var source = staffAbsolute[staffIndex + voiceIndex];
+	var dest = staffAbsolute[tabVoiceIndex];
+	var tabPos = null;
+	var defNote = null;
+	if (source.children[0].abcelem.el_type != 'clef') {
+		// keysig missing => provide one for tabs
+		if (keySig != 'none') {
+			source.children.splice(0, 0, keySig);
+		}
+	}
+	for (var ii = 0; ii < source.children.length; ii++) {
+		var absChild = source.children[ii];
+		var absX = absChild.x;
+		var relX = absX;
+		// if (absChild.children.length > 0) {
+		//   relX = absChild.children[0].x;
+		// }
+		if ((absChild.isClef)) {
+			dest.children.push(buildTabAbsolute(plugin, absX, relX));
+			if (absChild.abcelem.type.indexOf('-8') >= 0) plugin.semantics.clefTranspose = -12
+			if (absChild.abcelem.type.indexOf('+8') >= 0) plugin.semantics.clefTranspose = 12
+		}
+		switch (absChild.type) {
+			case 'staff-extra key-signature':
+				// refresh key accidentals
+				this.accidentals = absChild.abcelem.accidentals;
+				plugin.semantics.accidentals = this.accidentals;
+				break;
+			case 'bar':
+				plugin.semantics.measureAccidentals = {}
+				var lastBar = false;
+				if (ii === source.children.length - 1) {
+					// used for final line bar drawing
+					// for multi tabs / multi staves
+					lastBar = true;
+				}
+				var cloned = cloneAbsoluteAndRelatives(absChild, plugin);
+				if (cloned.abcelem.barNumber) {
+					delete cloned.abcelem.barNumber;
+					for (var bn = 0; bn < cloned.children.length; bn++) {
+						if (cloned.children[bn].type === "barNumber") {
+							cloned.children.splice(bn, 1);
+							break;
+						}
+					}
+				}
+				cloned.abcelem.lastBar = lastBar;
+				dest.children.push(cloned);
+				tabVoice.push({
+					el_type: absChild.abcelem.el_type,
+					type: absChild.abcelem.type,
+					endChar: absChild.abcelem.endChar,
+					startChar: absChild.abcelem.startChar,
+					abselem: cloned
+				});
+				break;
+			case 'rest':
+				var restGraces = graceInRest(absChild);
+				if (restGraces) {
+					// to number conversion 
+					tabPos = convertToNumber(plugin, null, restGraces);
+					if (tabPos.error) return;
+					// build relative for grace
+					defGrace = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [], grace: true };
+					buildGraceRelativesForRest(plugin, abs, absChild, tabPos.graces, tabVoice);
+				}
+				break;
+			case 'note':
+				var abs = cloneAbsolute(absChild);
+				abs.x = absChild.heads[0].x + absChild.heads[0].w / 2; // center the number
+				abs.lyricDim = lyricsDim(absChild);
+				var pitches = absChild.abcelem.pitches;
+				var graceNotes = absChild.abcelem.gracenotes;
+				abs.type = 'tabNumber';
+				// to number conversion 
+				tabPos = convertToNumber(plugin, pitches, graceNotes);
+				if (tabPos.error) return;
+				if (tabPos.graces) {
+					// add graces to last note in notes
+					var posNote = tabPos.notes.length - 1;
+					tabPos.notes[posNote].graces = tabPos.graces;
+				}
+				// build relative
+				defNote = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [] };
+				for (var ll = 0; ll < tabPos.notes.length; ll++) {
+					var curNote = tabPos.notes[ll];
+					if (curNote.graces) {
+						for (var mm = 0; mm < curNote.graces.length; mm++) {
+							var defGrace = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [], grace: true };
+							var graceX = getXGrace(absChild, mm);
+							var curGrace = curNote.graces[mm];
+							var tabGraceRelative = buildRelativeTabNote(plugin, graceX, defGrace, curGrace, true);
+							abs.children.push(tabGraceRelative);
+							tabVoice.push(defGrace);
+						}
+					}
+					var tabNoteRelative = buildRelativeTabNote(plugin, abs.x + absChild.heads[ll].dx, defNote, curNote, false);
+					abs.children.push(tabNoteRelative);
+				}
+				if (defNote.notes.length > 0) {
+					defNote.abselem = abs;
+					tabVoice.push(defNote);
+					dest.children.push(abs);
+				}
+				break;
+		}
+	}
+};
+
+module.exports = TabAbsoluteElements;

package/src/tablatures/render/tab-renderer.js

@@ -0,0 +1,244 @@
+/* eslint-disable no-debugger */
+var VoiceElement = require('../../write/creation/elements/voice-element');
+var TabAbsoluteElements = require('./tab-absolute-elements');
+var spacing = require('../../write/helpers/spacing');
+
+function initSpecialY() {
+	return {
+		tempoHeightAbove: 0,
+		partHeightAbove: 0,
+		volumeHeightAbove: 0,
+		dynamicHeightAbove: 0,
+		endingHeightAbove: 0,
+		chordHeightAbove: 0,
+		lyricHeightAbove: 0,
+		lyricHeightBelow: 0,
+		chordHeightBelow: 0,
+		volumeHeightBelow: 0,
+		dynamicHeightBelow: 0
+	};
+}
+
+function getLyricHeight(voice) {
+	var maxLyricHeight = 0;
+	for (var ii = 0; ii < voice.children.length; ii++) {
+		var curAbs = voice.children[ii];
+		if (curAbs.specialY) {
+			if (curAbs.specialY.lyricHeightBelow > maxLyricHeight) {
+				maxLyricHeight = curAbs.specialY.lyricHeightBelow;
+			}
+		}
+	}
+	return maxLyricHeight; // add spacing
+}
+
+function buildTabName(plugin, renderer, dest) {
+	var stringSemantics = plugin.semantics;
+	var textSize = renderer.controller.getTextSize;
+	var tabName = stringSemantics.tabInfos(plugin);
+	var suppress = stringSemantics.suppress(plugin);
+	var doDraw = true;
+
+	if (suppress) {
+		doDraw = false
+	}
+
+
+	if (doDraw) {
+		var size = textSize.calc(tabName, 'tablabelfont', 'text instrumentname');
+		dest.tabNameInfos = {
+			textSize: { height: size.height, width: size.width },
+			name: tabName
+		};
+		return size.height;
+	}
+	return 0
+
+}
+
+function islastTabInStaff(index, staffGroup) {
+	if (staffGroup[index].isTabStaff) {
+		if (index === staffGroup.length - 1) return true;
+		if (staffGroup[index + 1].isTabStaff) {
+			return false;
+		} else {
+			return true;
+		}
+	}
+	return false;
+}
+
+function getStaffNumbers(staffs) {
+	var nbStaffs = 0;
+	for (var ii = 0; ii < staffs.length; ii++) {
+		if (!staffs[ii].isTabStaff) {
+			nbStaffs++;
+		}
+	}
+	return nbStaffs;
+}
+
+function getParentStaffIndex(staffs, index) {
+	for (var ii = index; ii >= 0; ii--) {
+		if (!staffs[ii].isTabStaff) {
+			return ii;
+		}
+	}
+	return -1;
+}
+
+
+function linkStaffAndTabs(staffs) {
+	for (var ii = 0; ii < staffs.length; ii++) {
+		if (staffs[ii].isTabStaff) {
+			// link to parent staff
+			var parentIndex = getParentStaffIndex(staffs, ii);
+			staffs[ii].hasStaff = staffs[parentIndex];
+			if (!staffs[parentIndex].hasTab) staffs[parentIndex].hasTab = [];
+			staffs[parentIndex].hasTab.push(staffs[ii]);
+		}
+	}
+}
+
+function isMultiVoiceSingleStaff(staffs, parent) {
+	if (getStaffNumbers(staffs) === 1) {
+		if (parent.voices.length > 1) return true;
+	}
+	return false;
+}
+
+
+function getNextTabPos(tabIndex, staffGroup) {
+	var startIndex = 0;
+	var handledVoices = 0;
+	var inProgress = true;
+	var nbVoices = 0;
+	while (inProgress) {
+		//for (var ii = 0; ii < staffGroup.length; ii++) {
+		if (!staffGroup[startIndex])
+			return -1;
+		if (!staffGroup[startIndex].isTabStaff) {
+			nbVoices = staffGroup[startIndex].voices.length; // get number of staff voices
+		}
+		if (staffGroup[startIndex].isTabStaff) {
+			handledVoices++;
+			if (islastTabInStaff(startIndex, staffGroup)) {
+				if (handledVoices < nbVoices) return startIndex + 1;
+			}
+		} else {
+			handledVoices = 0;
+			if (startIndex >= tabIndex) {
+				if (startIndex + 1 == staffGroup.length) return startIndex + 1;
+				if (!staffGroup[startIndex + 1].isTabStaff) return startIndex + 1;
+			}
+		}
+		startIndex++;
+		// out of space case
+		if (startIndex > staffGroup.length) return -1;
+	}
+}
+
+function getLastStaff(staffs, lastTab) {
+	for (var ii = lastTab; ii >= 0; ii--) {
+		if (!staffs[ii].isTabStaff) {
+			return staffs[ii];
+		}
+	}
+	return null;
+}
+
+function checkVoiceKeySig(voices, ii) {
+	var curVoice = voices[ii];
+	// on multivoice multistaff only the first voice has key signature
+	// folling consecutive do not have one => we should provide the first voice key sig back then
+	var elem0 = curVoice.children[0].abcelem;
+	if (elem0.el_type === 'clef') return null;
+	if (ii == 0) {
+		// not found => clef=none case
+		return 'none';
+	}
+	return voices[ii - 1].children[0];
+}
+
+function tabRenderer(plugin, renderer, line, staffIndex) {
+	//console.log("RENDER tabRenderer")
+	var absolutes = new TabAbsoluteElements();
+	var tabStaff = {
+		clef: {
+			type: 'TAB'
+		}
+	};
+	var tabSize = (plugin.linePitch * plugin.nbLines);
+	var staffs = line.staff;
+	if (staffs) {
+		// give up on staffline=0 in key 
+		var firstStaff = staffs[0];
+		if (firstStaff) {
+			if (firstStaff.clef) {
+				if (firstStaff.clef.stafflines == 0) {
+					plugin.setError("No tablatures when stafflines=0");
+					return;
+				}
+			}
+		}
+		staffs.splice(
+			staffs.length, 0,
+			tabStaff
+		);
+	}
+	var staffGroup = line.staffGroup;
+
+	var voices = staffGroup.voices;
+	var firstVoice = voices[0];
+	// take lyrics into account if any
+	var lyricsHeight = getLyricHeight(firstVoice);
+	var padd = 3;
+	var prevIndex = staffIndex;
+	var previousStaff = staffGroup.staffs[prevIndex];
+	var tabTop = tabSize + padd - previousStaff.bottom - lyricsHeight;
+	if (previousStaff.isTabStaff) {
+		tabTop = previousStaff.top;
+	}
+	var staffGroupInfos = {
+		bottom: -1,
+		isTabStaff: true,
+		specialY: initSpecialY(),
+		lines: plugin.nbLines,
+		linePitch: plugin.linePitch,
+		dy: 0.15,
+		top: tabTop,
+	};
+	var nextTabPos = getNextTabPos(staffIndex, staffGroup.staffs);
+	if (nextTabPos === -1)
+		return;
+	staffGroupInfos.parentIndex = nextTabPos - 1;
+	staffGroup.staffs.splice(nextTabPos, 0, staffGroupInfos);
+	// staffGroup.staffs.push(staffGroupInfos);
+	staffGroup.height += tabSize + padd;
+	var parentStaff = getLastStaff(staffGroup.staffs, nextTabPos);
+	var nbVoices = 1;
+	if (isMultiVoiceSingleStaff(staffGroup.staffs, parentStaff)) {
+		nbVoices = parentStaff.voices.length;
+	}
+	// build from staff
+	tabStaff.voices = [];
+	for (var ii = 0; ii < nbVoices; ii++) {
+		var tabVoice = new VoiceElement(0, 0);
+		if (ii > 0) tabVoice.duplicate = true;
+		var nameHeight = buildTabName(plugin, renderer, tabVoice) / spacing.STEP;
+		nameHeight = Math.max(nameHeight, 1) // If there is no label for the tab line, then there needs to be a little padding
+		// This was pushing down the top staff by the tab label height
+		//staffGroup.staffs[staffIndex].top += nameHeight;
+		staffGroup.staffs[staffIndex].top += 1;
+		staffGroup.height += nameHeight;
+		tabVoice.staff = staffGroupInfos;
+		var tabVoiceIndex = voices.length
+		voices.splice(voices.length, 0, tabVoice);
+		var keySig = checkVoiceKeySig(voices, ii + staffIndex);
+		tabStaff.voices[ii] = [];
+		absolutes.build(plugin, voices, tabStaff.voices[ii], ii, staffIndex, keySig, tabVoiceIndex);
+	}
+	linkStaffAndTabs(staffGroup.staffs); // crossreference tabs and staff
+}
+
+module.exports = tabRenderer;

package/src/test/abc_parser_lint.js

@@ -48,7 +48,6 @@
 // Expanded:
 // MIDI is now { cmd, param }
 
-var parseCommon = require('../parse/abc_common');
 var JSONSchema = require('./jsonschema-b4');
 
 var ParserLint = function() {
@@ -76,7 +75,7 @@ var ParserLint = function() {
 	};
 
 	var appendPositioning = function(properties) {
-		var ret = parseCommon.clone(properties);
+		var ret = Object.assign({},properties);
 		ret.startChar = { type: 'number' }; //, output: 'hidden' };
 		ret.endChar = { type: 'number' }; //, output: 'hidden' };
 		return ret;
@@ -580,7 +579,7 @@ var ParserLint = function() {
 	};
 
 	var addProhibits = function(obj, arr) {
-		var ret = parseCommon.clone(obj);
+		var ret = Object.assign({},obj);
 		ret.prohibits = arr;
 		return ret;
 	};

package/src/write/creation/abstract-engraver.js

@@ -833,7 +833,7 @@ AbstractEngraver.prototype.createNote = function (elem, nostem, isSingleLineStaf
 	if (elem.decoration) {
 		// 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
+		var bottom = nostem && dir !== 'up' ? 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);
 	}
 

package/src/write/creation/elements/tie-element.js

@@ -225,4 +225,30 @@ TieElem.prototype.avoidCollisionAbove = function () {
 	}
 };
 
+TieElem.prototype.getYBounds = function () {
+	var lineStartX = 10 // TODO-PER: I'm not sure where to get this number from but it probably doesn't matter much
+	var lineEndX = 1000 // TODO-PER: I'm not sure where to get this number from but it probably doesn't matter much
+	if (this.isTie) {
+		this.calcTieDirection();
+		this.calcX(lineStartX, lineEndX);
+		this.calcTieY();
+
+	} else {
+		this.calcSlurDirection();
+		this.calcX(lineStartX, lineEndX);
+		this.calcSlurY();
+	}
+	var top;
+	var bottom;
+	// TODO-PER: It's hard to tell how far the arc is, so I'm just using 3 as the max
+	if (this.above) {
+		bottom = Math.min(this.startY, this.endY)
+		top = bottom + 3
+	} else {
+		top = Math.min(this.startY, this.endY)
+		bottom = top - 3
+	}
+	return [ top, bottom ]
+};
+
 module.exports = TieElem;

package/src/write/engraver-controller.js

@@ -16,7 +16,7 @@ var Classes = require('./helpers/classes');
 var GetFontAndAttr = require('./helpers/get-font-and-attr');
 var GetTextSize = require('./helpers/get-text-size');
 var draw = require('./draw/draw');
-var tablatures = require('../api/abc_tablatures');
+var tablatures = require('../tablatures/abc_tablatures');
 var findSelectableElement = require('./interactive/find-selectable-element');
 
 /**

package/src/write/layout/set-upper-and-lower-elements.js

@@ -128,6 +128,14 @@ function setUpperAndLowerVoiceElements(positionY, voice, spacing) {
 			case 'EndingElem':
 				setUpperAndLowerEndingElements(positionY, abselem);
 				break;
+			case 'TieElem':
+				// If a tie element is the highest or lowest thing then space might need to make room for it.
+				var yBounds = abselem.getYBounds()
+				voice.staff.top = Math.max(voice.staff.top, yBounds[0])
+				voice.staff.top = Math.max(voice.staff.top, yBounds[1])
+				voice.staff.bottom = Math.min(voice.staff.bottom, yBounds[0])
+				voice.staff.bottom = Math.min(voice.staff.bottom, yBounds[1])
+				break;
 		}
 	}
 }

package/test.js

@@ -1,5 +1,5 @@
 /**!
-Copyright (c) 2009-2023 Paul Rosen and Gregory Dyke
+Copyright (c) 2009-2024 Paul Rosen and Gregory Dyke
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/types/index.d.ts

@@ -379,7 +379,7 @@ declare module 'abcjs' {
 		chordprog?: number;
 		chordvol?: number;
 		gchord?: string;
-}
+	}
 
 	export interface SynthVisualOptions {
 		displayLoop?: boolean;
@@ -886,7 +886,7 @@ declare module 'abcjs' {
 		getBarLength: NumberFunction;
 		getBeatLength: NumberFunction;
 		getBeatsPerMeasure: NumberFunction;
-		getBpm: NumberFunction;
+		getBpm: (tempo?:TempoProperties) => number;
 		getMeter: () => Meter;
 		getMeterFraction: () => MeterFraction;
 		getPickupLength: NumberFunction;

package/version.js

@@ -1,3 +1,3 @@
-var version = '6.4.1';
+var version = '6.4.3';
 
 module.exports = version;