@huffduff/midi-writer-ts 3.2.0 → 3.2.2

package/README.md

@@ -1,9 +1,9 @@
 ♬ MidiWriterJS
 ===============
-[![npm version](https://img.shields.io/npm/v/midi-writer-js.svg)](https://www.npmjs.com/package/midi-writer-js)
-![Tests](https://github.com/grimmdude/MidiWriterJS/actions/workflows/lint.js.yml/badge.svg)
-![Lint](https://github.com/grimmdude/MidiWriterJS/actions/workflows/node.js.yml/badge.svg)
-[![Try midi-writer-js on RunKit](https://badge.runkitcdn.com/midi-writer-js.svg)](https://npm.runkit.com/midi-writer-js)
+![NPM Version](https://img.shields.io/npm/v/%40huffduff%2Fmidi-writer-ts)
+
+![Tests](https://github.com/tommyo/MidiWriterJS/actions/workflows/lint.js.yml/badge.svg)
+![Lint](https://github.com/tommyo/MidiWriterJS/actions/workflows/node.js.yml/badge.svg)
 
 MidiWriterJS is a JavaScript library providing an API for generating expressive multi-track MIDI files.  
 
@@ -14,32 +14,32 @@ Note that the `master` branch is in active development so if you're looking for
 Install
 ------------
 ```sh
-npm install midi-writer-js
+npm install @huffduff/midi-writer-ts
 ```
 Getting Started
 ------------
 
-```javascript
-import MidiWriter from 'midi-writer-js';
+```typescript
+import { Track, Writer, NoteEvent, ProgramChangeEvent } from '@huffduff/midi-writer-ts';
 
 // Start with a new track
-const track = new MidiWriter.Track();
+const track = new Track();
 
 // Define an instrument (optional):
-track.addEvent(new MidiWriter.ProgramChangeEvent({instrument: 1}));
+track.addEvent(new ProgramChangeEvent({instrument: 1}));
 
 // Add some notes:
-const note = new MidiWriter.NoteEvent({pitch: ['C4', 'D4', 'E4'], duration: '4'});
+const note = new NoteEvent({pitch: ['C4', 'D4', 'E4'], duration: '4'});
 track.addEvent(note);
 
 // Generate a data URI
-const write = new MidiWriter.Writer(track);
+const write = new Writer(track);
 console.log(write.dataUri());
 ```
 Documentation
 ------------
 
-### `MidiWriter.Track()`
+### `Track()`
 
 - `addEvent({event}, mapFunction)`
 - `setTempo(tempo)`
@@ -52,7 +52,7 @@ Documentation
 - `addLyric(text)`
 - `setTimeSignature(numerator, denominator)`
 
-### `MidiWriter.NoteEvent({options})`
+### `NoteEvent({options})`
 
 The MIDI spec defines that each note must have a `NoteOnEvent` and `NoteOffEvent` (or `NoteOnEvent` with zero velocity) event, marking the beginning and end of the sounding note.  While it's possible to manually add these events to a track with `Track.addEvent()`, the `NoteEvent` provides a more intuitive interface for doing this with a single, "pseudo" event.  Under the hood, the `NoteEvent` event generates the relevant `NoteOnEvent` and `NoteOffEvent` events.
 
@@ -150,7 +150,7 @@ The `NoteEvent` supports these options:
 </table>
 
 
-### `MidiWriter.Writer(tracks)`
+### `Writer(tracks)`
 The `Writer` class provides a few ways to output the file:
 - `buildFile()` *Uint8Array*
 - `base64()` *string*
@@ -160,22 +160,21 @@ The `Writer` class provides a few ways to output the file:
 ### Hot Cross Buns
 Here's an example of how everyone's favorite song "Hot Cross Buns" could be written.  Note use of the mapping function passed as the second argument of `addEvent()`.  This can be used to apply specific properties to all events.  With some 
 street smarts you could also use it for programmatic crescendos and other property 'animation'.
-```javascript
-import MidiWriter from 'midi-writer-js';
+```typescript
+import { Track, NoteEvent, Writer } from 'midi-writer-js';
 
-const track = new MidiWriter.Track();
+const track = new Track();
 
 track.addEvent([
-		new MidiWriter.NoteEvent({pitch: ['E4','D4'], duration: '4'}),
-		new MidiWriter.NoteEvent({pitch: ['C4'], duration: '2'}),
-		new MidiWriter.NoteEvent({pitch: ['E4','D4'], duration: '4'}),
-		new MidiWriter.NoteEvent({pitch: ['C4'], duration: '2'}),
-		new MidiWriter.NoteEvent({pitch: ['C4', 'C4', 'C4', 'C4', 'D4', 'D4', 'D4', 'D4'], duration: '8'}),
-		new MidiWriter.NoteEvent({pitch: ['E4','D4'], duration: '4'}),
-		new MidiWriter.NoteEvent({pitch: ['C4'], duration: '2'})
-	], function(event, index) {
-    return {sequential: true};
-  }
+		new NoteEvent({pitch: ['E4','D4'], duration: '4'}),
+		new NoteEvent({pitch: ['C4'], duration: '2'}),
+		new NoteEvent({pitch: ['E4','D4'], duration: '4'}),
+		new NoteEvent({pitch: ['C4'], duration: '2'}),
+		new NoteEvent({pitch: ['C4', 'C4', 'C4', 'C4', 'D4', 'D4', 'D4', 'D4'], duration: '8'}),
+		new NoteEvent({pitch: ['E4','D4'], duration: '4'}),
+		new NoteEvent({pitch: ['C4'], duration: '2'})
+	], 
+  (event, index) => ({ sequential: true }),
 );
 
 const write = new MidiWriter.Writer(track);
@@ -184,7 +183,7 @@ console.log(write.dataUri());
 
 ### VexFlow Integration
 MidiWriterJS can export MIDI from VexFlow voices, though this feature is still experimental.  Current usage is to use `MidiWriter.VexFlow.trackFromVoice(voice)` to create a MidiWriterJS `Track` object:
-```javascript
+```typescript
 
 // ...VexFlow code defining notes
 const voice = create_4_4_voice().addTickables(notes);

package/build/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var midi = require('@tonaljs/midi');
 
 /**
@@ -1191,29 +1193,25 @@ class Writer {
     }
 }
 
-var main = {
-    Constants,
-    ControllerChangeEvent,
-    CopyrightEvent,
-    CuePointEvent,
-    EndTrackEvent,
-    InstrumentNameEvent,
-    KeySignatureEvent,
-    LyricEvent,
-    MarkerEvent,
-    NoteOnEvent,
-    NoteOffEvent,
-    NoteEvent,
-    PitchBendEvent,
-    ProgramChangeEvent,
-    TempoEvent,
-    TextEvent,
-    TimeSignatureEvent,
-    Track,
-    TrackNameEvent,
-    Utils,
-    VexFlow,
-    Writer
-};
-
-module.exports = main;
+exports.Constants = Constants;
+exports.ControllerChangeEvent = ControllerChangeEvent;
+exports.CopyrightEvent = CopyrightEvent;
+exports.CuePointEvent = CuePointEvent;
+exports.EndTrackEvent = EndTrackEvent;
+exports.InstrumentNameEvent = InstrumentNameEvent;
+exports.KeySignatureEvent = KeySignatureEvent;
+exports.LyricEvent = LyricEvent;
+exports.MarkerEvent = MarkerEvent;
+exports.NoteEvent = NoteEvent;
+exports.NoteOffEvent = NoteOffEvent;
+exports.NoteOnEvent = NoteOnEvent;
+exports.PitchBendEvent = PitchBendEvent;
+exports.ProgramChangeEvent = ProgramChangeEvent;
+exports.TempoEvent = TempoEvent;
+exports.TextEvent = TextEvent;
+exports.TimeSignatureEvent = TimeSignatureEvent;
+exports.Track = Track;
+exports.TrackNameEvent = TrackNameEvent;
+exports.Utils = Utils;
+exports.VexFlow = VexFlow;
+exports.Writer = Writer;

package/build/index.mjs

@@ -1189,29 +1189,4 @@ class Writer {
     }
 }
 
-var main = {
-    Constants,
-    ControllerChangeEvent,
-    CopyrightEvent,
-    CuePointEvent,
-    EndTrackEvent,
-    InstrumentNameEvent,
-    KeySignatureEvent,
-    LyricEvent,
-    MarkerEvent,
-    NoteOnEvent,
-    NoteOffEvent,
-    NoteEvent,
-    PitchBendEvent,
-    ProgramChangeEvent,
-    TempoEvent,
-    TextEvent,
-    TimeSignatureEvent,
-    Track,
-    TrackNameEvent,
-    Utils,
-    VexFlow,
-    Writer
-};
-
-export { main as default };
+export { Constants, ControllerChangeEvent, CopyrightEvent, CuePointEvent, EndTrackEvent, InstrumentNameEvent, KeySignatureEvent, LyricEvent, MarkerEvent, NoteEvent, NoteOffEvent, NoteOnEvent, PitchBendEvent, ProgramChangeEvent, TempoEvent, TextEvent, TimeSignatureEvent, Track, TrackNameEvent, Utils, VexFlow, Writer };

package/build/types/main.d.ts

@@ -1,3 +1,4 @@
+import { Constants } from './constants';
 import { ControllerChangeEvent } from './midi-events/controller-change-event';
 import { CopyrightEvent } from './meta-events/copyright-event';
 import { CuePointEvent } from './meta-events/cue-point-event';
@@ -19,38 +20,4 @@ import { TrackNameEvent } from './meta-events/track-name-event';
 import { Utils } from './utils';
 import { VexFlow } from './vexflow';
 import { Writer } from './writer';
-declare const _default: {
-    Constants: {
-        VERSION: string;
-        HEADER_CHUNK_TYPE: number[];
-        HEADER_CHUNK_LENGTH: number[];
-        HEADER_CHUNK_FORMAT0: number[];
-        HEADER_CHUNK_FORMAT1: number[];
-        HEADER_CHUNK_DIVISION: number[];
-        TRACK_CHUNK_TYPE: number[];
-        META_EVENT_ID: number;
-        META_SMTPE_OFFSET: number;
-    };
-    ControllerChangeEvent: typeof ControllerChangeEvent;
-    CopyrightEvent: typeof CopyrightEvent;
-    CuePointEvent: typeof CuePointEvent;
-    EndTrackEvent: typeof EndTrackEvent;
-    InstrumentNameEvent: typeof InstrumentNameEvent;
-    KeySignatureEvent: typeof KeySignatureEvent;
-    LyricEvent: typeof LyricEvent;
-    MarkerEvent: typeof MarkerEvent;
-    NoteOnEvent: typeof NoteOnEvent;
-    NoteOffEvent: typeof NoteOffEvent;
-    NoteEvent: typeof NoteEvent;
-    PitchBendEvent: typeof PitchBendEvent;
-    ProgramChangeEvent: typeof ProgramChangeEvent;
-    TempoEvent: typeof TempoEvent;
-    TextEvent: typeof TextEvent;
-    TimeSignatureEvent: typeof TimeSignatureEvent;
-    Track: typeof Track;
-    TrackNameEvent: typeof TrackNameEvent;
-    Utils: typeof Utils;
-    VexFlow: typeof VexFlow;
-    Writer: typeof Writer;
-};
-export default _default;
+export { Constants, ControllerChangeEvent, CopyrightEvent, CuePointEvent, EndTrackEvent, InstrumentNameEvent, KeySignatureEvent, LyricEvent, MarkerEvent, NoteOnEvent, NoteOffEvent, NoteEvent, PitchBendEvent, ProgramChangeEvent, TempoEvent, TextEvent, TimeSignatureEvent, Track, TrackNameEvent, Utils, VexFlow, Writer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huffduff/midi-writer-ts",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "A fork of midi-writer-js, a library providing an API for generating MIDI files.",
   "main": "build/index.cjs",
   "module": "build/index.mjs",
@@ -47,6 +47,14 @@
     "example": "examples",
     "test": "test"
   },
+  "files": [
+    "build/**/*",
+    "LICENSE",
+    "README.md",
+    "./src/**/*",
+    "examples/**/*",
+    "test/**/*"
+  ],
   "scripts": {
     "build": "mkdir -p build && rollup -c",
     "docs": "npx typedoc --options typedoc.json",
@@ -57,7 +65,6 @@
     "watch": "watch 'npm run build' src",
     "postinstall": "node postinstall.js"
   },
-  "runkitExampleFilename": "runkit.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tommyo/MidiWriterJS.git"

package/src/abstract-event.ts

@@ -0,0 +1,8 @@
+interface AbstractEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    tick?: number;
+}
+
+export {AbstractEvent};

package/src/chunks/chunk.ts

@@ -0,0 +1,6 @@
+interface Chunk {
+    type: number[];
+    size: number[];
+}
+
+export {Chunk};

package/src/chunks/header.ts

@@ -0,0 +1,29 @@
+import {Chunk} from './chunk';
+import {Constants} from '../constants';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a header chunk section of a MIDI file.
+ * @param {number} numberOfTracks - Number of tracks
+ * @return {Header}
+ */
+class Header implements Chunk {
+	data: number[];
+	type: number[];
+	size: number[];
+
+	constructor(numberOfTracks) {
+		this.type = Constants.HEADER_CHUNK_TYPE;
+
+		const trackType = numberOfTracks > 1? Constants.HEADER_CHUNK_FORMAT1 : Constants.HEADER_CHUNK_FORMAT0;
+
+		this.data = trackType.concat(
+					Utils.numberToBytes(numberOfTracks, 2), // two bytes long,
+					Constants.HEADER_CHUNK_DIVISION
+		);
+
+		this.size = [0, 0, 0, this.data.length];
+	}
+}
+
+export {Header};

package/src/chunks/track.ts

@@ -0,0 +1,345 @@
+import { AbstractEvent } from '../abstract-event';
+import {Chunk} from './chunk';
+import {Constants} from '../constants';
+import {ControllerChangeEvent} from '../midi-events/controller-change-event';
+import {CopyrightEvent} from '../meta-events/copyright-event';
+import {CuePointEvent} from '../meta-events/cue-point-event';
+import {EndTrackEvent} from '../meta-events/end-track-event';
+import {InstrumentNameEvent} from '../meta-events/instrument-name-event';
+import {KeySignatureEvent} from '../meta-events/key-signature-event';
+import {LyricEvent} from '../meta-events/lyric-event';
+import {MarkerEvent} from '../meta-events/marker-event';
+import {NoteEvent} from '../midi-events/note-event';
+import {NoteOnEvent} from '../midi-events/note-on-event';
+import {NoteOffEvent} from '../midi-events/note-off-event';
+import {PitchBendEvent} from '../midi-events/pitch-bend-event';
+import {TempoEvent} from '../meta-events/tempo-event';
+import {TextEvent} from '../meta-events/text-event';
+import {TimeSignatureEvent} from '../meta-events/time-signature-event';
+import {TrackNameEvent} from '../meta-events/track-name-event';
+import {Utils} from '../utils';
+
+/**
+ * Holds all data for a track.
+ * @param {object} fields {type: number, data: array, size: array, events: array}
+ * @return {Track}
+ */
+class Track implements Chunk {
+	data: number[];
+	events: AbstractEvent[];
+	explicitTickEvents: NoteEvent[];
+	size: number[];
+	type: number[];
+	tickPointer: number;
+
+	constructor() {
+		this.type = Constants.TRACK_CHUNK_TYPE;
+		this.data = [];
+		this.size = [];
+		this.events = [];
+		this.explicitTickEvents = [];
+
+		// If there are any events with an explicit tick defined then we will create a "sub" track for those
+		// and merge them in and the end.
+		this.tickPointer = 0; // Each time an event is added this will increase
+	}
+
+	/**
+	 * Adds any event type to the track.
+	 * Events without a specific startTick property are assumed to be added in order of how they should output.
+	 * Events with a specific startTick property are set aside for now will be merged in during build process.
+	 *
+	 * TODO: Don't put startTick events in their own array.  Just lump everything together and sort it out during buildData();
+	 * @param {(NoteEvent|ProgramChangeEvent)} events - Event object or array of Event objects.
+	 * @param {Function} mapFunction - Callback which can be used to apply specific properties to all events.
+	 * @return {Track}
+	 */
+	addEvent(events: (AbstractEvent|AbstractEvent[]), mapFunction?: (i: number, event: AbstractEvent) => object): Track {
+		Utils.toArray(events).forEach((event, i) => {
+			if (event instanceof NoteEvent) {
+				// Handle map function if provided
+				if (typeof mapFunction === 'function') {
+					const properties = mapFunction(i, event);
+
+					if (typeof properties === 'object') {
+						Object.assign(event, properties);
+					}
+				}
+
+				// If this note event has an explicit startTick then we need to set aside for now
+				if (event.tick !== null) {
+					this.explicitTickEvents.push(event);
+
+				} else {
+					// Push each on/off event to track's event stack
+					event.buildData().events.forEach((e) => this.events.push(e));
+				}
+
+			} else {
+				this.events.push(event);
+			}
+		});
+
+		return this;
+	}
+
+	/**
+	 * Builds int array of all events.
+	 * @param {object} options
+	 * @return {Track}
+	 */
+	buildData(options = {}) {
+		// Reset
+		this.data = [];
+		this.size = [];
+		this.tickPointer = 0;
+
+		let precisionLoss = 0;
+
+		this.events.forEach((event) => {
+			// Build event & add to total tick duration
+			if (event instanceof NoteOnEvent || event instanceof NoteOffEvent) {
+				const built = event.buildData(this, precisionLoss, options);
+				precisionLoss = Utils.getPrecisionLoss(event.deltaWithPrecisionCorrection || 0);
+				this.data = this.data.concat(built.data);
+				this.tickPointer = Utils.getRoundedIfClose(event.tick);
+
+			} else if (event instanceof TempoEvent) {
+				this.tickPointer = Utils.getRoundedIfClose(event.tick);
+				this.data = this.data.concat(event.data);
+
+			} else {
+				this.data = this.data.concat(event.data);
+			}
+		});
+
+		this.mergeExplicitTickEvents();
+
+		// If the last event isn't EndTrackEvent, then tack it onto the data.
+		if (!this.events.length || !(this.events[this.events.length - 1] instanceof EndTrackEvent)) {
+			this.data = this.data.concat((new EndTrackEvent).data);
+		}
+
+		this.size = Utils.numberToBytes(this.data.length, 4); // 4 bytes long
+		return this;
+	}
+
+	mergeExplicitTickEvents() {
+		if (!this.explicitTickEvents.length) return;
+
+		// First sort asc list of events by startTick
+		this.explicitTickEvents.sort((a, b) => a.tick - b.tick);
+
+		// Now this.explicitTickEvents is in correct order, and so is this.events naturally.
+		// For each explicit tick event, splice it into the main list of events and
+		// adjust the delta on the following events so they still play normally.
+		this.explicitTickEvents.forEach((noteEvent) => {
+			// Convert NoteEvent to it's respective NoteOn/NoteOff events
+			// Note that as we splice in events the delta for the NoteOff ones will
+			// Need to change based on what comes before them after the splice.
+			noteEvent.buildData().events.forEach((e) => e.buildData(this));
+
+			// Merge each event individually into this track's event list.
+			noteEvent.events.forEach((event) => this.mergeSingleEvent(event));
+		});
+
+		// Hacky way to rebuild track with newly spliced events.  Need better solution.
+		this.explicitTickEvents = [];
+		this.buildData();
+	}
+
+	/**
+	 * Merges another track's events with this track.
+	 * @param {Track} track
+	 * @return {Track}
+	 */
+	mergeTrack(track: Track): Track {
+		// First build this track to populate each event's tick property
+		this.buildData();
+
+		// Then build track to be merged so that tick property is populated on all events & merge each event.
+		track.buildData().events.forEach((event) => this.mergeSingleEvent(event));
+		return this;
+	}
+
+	/**
+	 * Merges a single event into this track's list of events based on event.tick property.
+	 * @param {AbstractEvent} - event
+	 * @return {Track}
+	 */
+	mergeSingleEvent(event: AbstractEvent): Track {
+		// There are no events yet, so just add it in.
+		if (!this.events.length) {
+			this.addEvent(event);
+			return;
+		}
+
+		// Find index of existing event we need to follow with
+		let lastEventIndex;
+
+		for (let i = 0; i < this.events.length; i++) {
+			if (this.events[i].tick > event.tick) break;
+			lastEventIndex = i;
+		}
+
+		const splicedEventIndex = lastEventIndex + 1;
+
+		// Need to adjust the delta of this event to ensure it falls on the correct tick.
+		event.delta = event.tick - this.events[lastEventIndex].tick;
+
+		// Splice this event at lastEventIndex + 1
+		this.events.splice(splicedEventIndex, 0, event);
+
+		// Now adjust delta of all following events
+		for (let i = splicedEventIndex + 1; i < this.events.length; i++) {
+			// Since each existing event should have a tick value at this point we just need to
+			// adjust delta to that the event still falls on the correct tick.
+			this.events[i].delta = this.events[i].tick - this.events[i - 1].tick;
+		}
+	}
+
+	/**
+	 * Removes all events matching specified type.
+	 * @param {string} eventName - Event type
+	 * @return {Track}
+	 */
+	removeEventsByName(eventName: string): Track {
+		this.events.forEach((event, index) => {
+			if (event.name === eventName) {
+				this.events.splice(index, 1);
+			}
+		});
+
+		return this;
+	}
+
+	/**
+	 * Sets tempo of the MIDI file.
+	 * @param {number} bpm - Tempo in beats per minute.
+	 * @param {number} tick - Start tick.
+	 * @return {Track}
+	 */
+	setTempo(bpm: number, tick = 0): Track {
+		return this.addEvent(new TempoEvent({bpm, tick}));
+	}
+
+	/**
+	 * Sets time signature.
+	 * @param {number} numerator - Top number of the time signature.
+	 * @param {number} denominator - Bottom number of the time signature.
+	 * @param {number} midiclockspertick - Defaults to 24.
+	 * @param {number} notespermidiclock - Defaults to 8.
+	 * @return {Track}
+	 */
+	setTimeSignature(numerator: number, denominator: number, midiclockspertick: number, notespermidiclock: number): Track {
+		return this.addEvent(new TimeSignatureEvent(numerator, denominator, midiclockspertick, notespermidiclock));
+	}
+
+	/**
+	 * Sets key signature.
+	 * @param {*} sf -
+	 * @param {*} mi -
+	 * @return {Track}
+	 */
+	setKeySignature(sf, mi) {
+		return this.addEvent(new KeySignatureEvent(sf, mi));
+	}
+
+	/**
+	 * Adds text to MIDI file.
+	 * @param {string} text - Text to add.
+	 * @return {Track}
+	 */
+	addText(text: string): Track {
+		return this.addEvent(new TextEvent({text}));
+	}
+
+	/**
+	 * Adds copyright to MIDI file.
+	 * @param {string} text - Text of copyright line.
+	 * @return {Track}
+	 */
+	addCopyright(text: string): Track {
+		return this.addEvent(new CopyrightEvent({text}));
+	}
+
+	/**
+	 * Adds Sequence/Track Name.
+	 * @param {string} text - Text of track name.
+	 * @return {Track}
+	 */
+	addTrackName(text: string): Track {
+		return this.addEvent(new TrackNameEvent({text}));
+	}
+
+	/**
+	 * Sets instrument name of track.
+	 * @param {string} text - Name of instrument.
+	 * @return {Track}
+	 */
+	addInstrumentName(text: string): Track {
+		return this.addEvent(new InstrumentNameEvent({text}));
+	}
+
+	/**
+	 * Adds marker to MIDI file.
+	 * @param {string} text - Marker text.
+	 * @return {Track}
+	 */
+	addMarker(text: string): Track {
+		return this.addEvent(new MarkerEvent({text}));
+	}
+
+	/**
+	 * Adds cue point to MIDI file.
+	 * @param {string} text - Text of cue point.
+	 * @return {Track}
+	 */
+	addCuePoint(text: string): Track {
+		return this.addEvent(new CuePointEvent({text}));
+	}
+
+	/**
+	 * Adds lyric to MIDI file.
+	 * @param {string} text - Lyric text to add.
+	 * @return {Track}
+	 */
+	addLyric(text: string): Track {
+		return this.addEvent(new LyricEvent({text}));
+	}
+
+	/**
+	 * Channel mode messages
+	 * @return {Track}
+	 */
+	polyModeOn(): Track {
+		const event = new NoteOnEvent({data: [0x00, 0xB0, 0x7E, 0x00]});
+		return this.addEvent(event);
+	}
+
+
+	/**
+	 * Sets a pitch bend.
+	 * @param {float} bend - Bend value ranging [-1,1], zero meaning no bend.
+	 * @return {Track}
+	 */
+	setPitchBend(bend: number): Track {
+		return this.addEvent(new PitchBendEvent({bend}));
+	}
+
+
+	/**
+	 * Adds a controller change event
+	 * @param {number} number - Control number.
+	 * @param {number} value - Control value.
+	 * @param {number} channel - Channel to send controller change event on (1-based).
+	 * @param {number} delta - Track tick offset for cc event.
+	 * @return {Track}
+	 */
+	controllerChange(number: number, value: number, channel?: number, delta?: number): Track {
+		return this.addEvent(new ControllerChangeEvent({controllerNumber: number, controllerValue: value, channel: channel, delta: delta}));
+	}
+
+}
+
+export {Track};