@huffduff/midi-writer-ts 3.2.0

package/build/types/utils.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Static utility functions used throughout the library.
+ */
+declare class Utils {
+    /**
+     * Gets MidiWriterJS version number.
+     * @return {string}
+     */
+    static version(): string;
+    /**
+     * Convert a string to an array of bytes
+     * @param {string} string
+     * @return {array}
+     */
+    static stringToBytes(string: string): number[];
+    /**
+     * Checks if argument is a valid number.
+     * @param {*} n - Value to check
+     * @return {boolean}
+     */
+    static isNumeric(n: any): boolean;
+    /**
+     * Returns the correct MIDI number for the specified pitch.
+     * Uses Tonal Midi - https://github.com/danigb/tonal/tree/master/packages/midi
+     * @param {(string|number)} pitch - 'C#4' or midi note code
+     * @param {string} middleC
+     * @return {number}
+     */
+    static getPitch(pitch: string | number, middleC?: string | number): number;
+    /**
+     * Translates number of ticks to MIDI timestamp format, returning an array of
+     * hex strings with the time values. Midi has a very particular time to express time,
+     * take a good look at the spec before ever touching this function.
+     * Thanks to https://github.com/sergi/jsmidi
+     *
+     * @param {number} ticks - Number of ticks to be translated
+     * @return {array} - Bytes that form the MIDI time value
+     */
+    static numberToVariableLength(ticks: number): number[];
+    /**
+     * Counts number of bytes in string
+     * @param {string} s
+     * @return {number}
+     */
+    static stringByteCount(s: string): number;
+    /**
+     * Get an int from an array of bytes.
+     * @param {array} bytes
+     * @return {number}
+     */
+    static numberFromBytes(bytes: number[]): number;
+    /**
+     * Takes a number and splits it up into an array of bytes.  Can be padded by passing a number to bytesNeeded
+     * @param {number} number
+     * @param {number} bytesNeeded
+     * @return {array} - Array of bytes
+     */
+    static numberToBytes(number: number, bytesNeeded: number): number[];
+    /**
+     * Converts value to array if needed.
+     * @param {any} value
+     * @return {array}
+     */
+    static toArray(value: any): any[];
+    /**
+     * Converts velocity to value 0-127
+     * @param {number} velocity - Velocity value 1-100
+     * @return {number}
+     */
+    static convertVelocity(velocity: number): number;
+    /**
+     * Gets the total number of ticks of a specified duration.
+     * Note: type=='note' defaults to quarter note, type==='rest' defaults to 0
+     * @param {(string|array)} duration
+     * @return {number}
+     */
+    static getTickDuration(duration: (string | string[] | number)): number;
+    /**
+     * Due to rounding errors in JavaScript engines,
+     * it's safe to round when we're very close to the actual tick number
+     *
+     * @static
+     * @param {number} tick
+     * @return {number}
+     */
+    static getRoundedIfClose(tick: number): number;
+    /**
+     * Due to low precision of MIDI,
+     * we need to keep track of rounding errors in deltas.
+     * This function will calculate the rounding error for a given duration.
+     *
+     * @static
+     * @param {number} tick
+     * @return {number}
+     */
+    static getPrecisionLoss(tick: number): number;
+    /**
+     * Gets what to multiple ticks/quarter note by to get the specified duration.
+     * Note: type=='note' defaults to quarter note, type==='rest' defaults to 0
+     * @param {string} duration
+     * @return {number}
+     */
+    static getDurationMultiplier(duration: string): number;
+}
+export { Utils };

package/build/types/vexflow.d.ts

@@ -0,0 +1,30 @@
+import { Track } from './chunks/track';
+declare class VexFlow {
+    /**
+     * Support for converting VexFlow voice into MidiWriterJS track
+     * @return MidiWriter.Track object
+     */
+    trackFromVoice(voice: any, options?: {
+        addRenderedAccidentals: boolean;
+    }): Track;
+    /**
+     * Converts VexFlow pitch syntax to MidiWriterJS syntax
+     * @param pitch string
+     * @param index pitch index
+     * @param note struct from Vexflow
+     * @param addRenderedAccidentals adds Vexflow rendered accidentals
+     */
+    convertPitch(pitch: any, index: any, note: any, addRenderedAccidentals?: boolean): any;
+    /**
+     * Converts VexFlow duration syntax to MidiWriterJS syntax
+     * @param note struct from VexFlow
+     */
+    convertDuration(note: any): string;
+    /**
+     * Converts VexFlow base duration syntax to MidiWriterJS syntax
+     * @param duration Vexflow duration
+     * @returns MidiWriterJS duration
+     */
+    convertBaseDuration(duration: string): string;
+}
+export { VexFlow };

package/build/types/writer.d.ts

@@ -0,0 +1,45 @@
+import { Track } from './chunks/track';
+/**
+ * Object that puts together tracks and provides methods for file output.
+ * @param {array|Track} tracks - A single {Track} object or an array of {Track} objects.
+ * @param {object} options - {middleC: 'C4'}
+ * @return {Writer}
+ */
+declare class Writer {
+    tracks: Track[];
+    options: object;
+    constructor(tracks: any, options?: {});
+    /**
+     * Builds array of data from chunkschunks.
+     * @return {array}
+     */
+    buildData(): any[];
+    /**
+     * Builds the file into a Uint8Array
+     * @return {Uint8Array}
+     */
+    buildFile(): Uint8Array;
+    /**
+     * Convert file buffer to a base64 string.  Different methods depending on if browser or node.
+     * @return {string}
+     */
+    base64(): string;
+    /**
+     * Get the data URI.
+     * @return {string}
+     */
+    dataUri(): string;
+    /**
+     * Set option on instantiated Writer.
+     * @param {string} key
+     * @param {any} value
+     * @return {Writer}
+     */
+    setOption(key: string, value: number | string): Writer;
+    /**
+     * Output to stdout
+     * @return {string}
+     */
+    stdout(): boolean;
+}
+export { Writer };

package/examples/chopin-prelude-e-minor.js

@@ -0,0 +1,143 @@
+var MidiWriter = require('..');
+
+var tracks = [];
+tracks[0] = new MidiWriter.Track();
+
+// You can chain track methods.
+tracks[0]
+	.setTempo(60)
+	.addEvent([
+		// addEvent() accepts an array of event objects like this...
+		new MidiWriter.ProgramChangeEvent({instrument : 1}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['C5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['C5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['C5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['Bb4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd8'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: '16'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['Ab4'], duration: '2'}),
+		new MidiWriter.NoteEvent({pitch: ['A4', 'B4', 'D5', 'C5', 'E4', 'A4'], duration: '8', sequential:true}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['G4', 'Gb4', 'C4', 'B3', 'Eb4', 'Gb4'], duration: '8', sequential:true}),
+		new MidiWriter.NoteEvent({pitch: ['D5', 'C5', 'B4'], duration: '8t', sequential:true}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['C5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['C5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['C5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['B4'], duration: 'd8'}),
+		new MidiWriter.NoteEvent({pitch: ['Bb4'], duration: '16'}),
+		new MidiWriter.NoteEvent({pitch: ['Bb4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['G5'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb5'], duration: 'd8'}),
+		new MidiWriter.NoteEvent({pitch: ['E5'], duration: '16'}),
+		new MidiWriter.NoteEvent({pitch: ['E5', 'D#5', 'C6', 'D#5', 'D#5', 'E5', 'G5', 'B4'], duration: '8', sequential:true}),
+		new MidiWriter.NoteEvent({pitch: ['D5', 'C5'], duration: '8', sequential:true}),
+		new MidiWriter.NoteEvent({pitch: ['E5', 'E4', 'A4'], duration: '8t', sequential:true}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: 'd4'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: '8'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['A4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: 'd8'}),
+		new MidiWriter.NoteEvent({pitch: ['E4'], duration: '16'}),
+		new MidiWriter.NoteEvent({pitch: ['E4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['E4'], duration: 'd2'}),
+		new MidiWriter.NoteEvent({pitch: ['Gb4'], duration: '4'}),
+		new MidiWriter.NoteEvent({pitch: ['E4'], duration: '2'}),
+		new MidiWriter.NoteEvent({pitch: ['C6', 'G5', 'D5', 'C5'], duration: '2', wait: '2'}),
+		new MidiWriter.NoteEvent({pitch: ['C6', 'G5', 'D5', 'C5'], duration: '2'}),
+		new MidiWriter.NoteEvent({pitch: ['C6', 'G5', 'E5', 'C5'], duration: '4'})
+		], function(index, event) {
+			return {velocity: 100};
+		}
+	);
+
+// You can optionally pass a single event object to addEvent() if you wish
+tracks[1] = new MidiWriter.Track();
+tracks[1].addEvent(new MidiWriter.ProgramChangeEvent({instrument : 1}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8', repeat: 8}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'A3', 'F#3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D#4', 'A3', 'F#3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D#4', 'A3', 'F3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'A3', 'F3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'G#3', 'F3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'G#3', 'E3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'G3', 'E3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C#4', 'G3', 'E3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C4', 'G3', 'E3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C4', 'F#3', 'E3'], duration: '8', repeat: 8}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C4', 'F#3', 'D#3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C4', 'F#3', 'D3'], duration: '8', repeat: 8}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C4', 'F3', 'D3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B4', 'F3', 'D3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B4', 'E3', 'C3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'E3', 'C3'], duration: '8', repeat: 6}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'E3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'D#3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'E3', 'C3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'D#3', 'B3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'E3', 'C3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'D#3', 'B3'], duration: '4'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8', wait: 'd2'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'B3', 'G3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E4', 'A3', 'F#3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D#4', 'A3', 'F3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D#4', 'G#3', 'F3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'G#3', 'F3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'G3', 'E3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['D4', 'G3', 'E3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C#4', 'G3', 'E3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A#4', 'E3', 'C#3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'E3', 'C3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B3', 'B2'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A5', 'F#5', 'C4', 'A4'], duration: '8', repeat: 3}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['F#5', 'D#5', 'B4', 'G4'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E5', 'B4', 'G4'], duration: '8', repeat: 3}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E5', 'C4', 'A4'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['C4', 'F#3', 'E3'], duration: '8'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B4', 'E3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A4', 'E3', 'C3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B3', 'E3', 'B2'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A3', 'E3', 'C3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B3', 'E3', 'B2'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B3', 'D#3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A3', 'D#3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['G3', 'E3', 'C3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['Bb3', 'E3', 'C3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A3', 'E3', 'C3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['A3', 'E3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['G#3', 'E3', 'B3'], duration: '8', repeat: 2}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['G3', 'E3', 'B3'], duration: '8', repeat: 4}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['G3', 'C3', 'A#3'], duration: '2'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B3', 'B2'], duration: '2', wait: '2'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['B3', 'F#3', 'B2'], duration: '2'}));
+tracks[1].addEvent(new MidiWriter.NoteEvent({pitch: ['E2', 'E1'], duration: '1'}));
+
+var write = new MidiWriter.Writer(tracks);
+console.log(write.dataUri());
+//write.stdout();
+
+module.exports = write;

package/examples/hot-cross-buns.js

@@ -0,0 +1,24 @@
+var MidiWriter = require('..');
+
+var track = new MidiWriter.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};
+  }
+);
+
+
+var write = new MidiWriter.Writer(track);
+//console.log(track);
+//console.log(write.base64())
+console.log(write.dataUri());
+
+module.exports = write;

package/examples/mauro.giuliani-op.47-main-theme.js

@@ -0,0 +1,136 @@
+/**
+	VARIATIONS
+	Faciles
+	Pour la Guitare
+	Sur un air National Autrichien
+	Composées
+	PAR
+	MAURO GIULIANI
+	Oev: 47 Prix 3f
+	à Paris
+	chez RICHAULT...
+	Boulevard Poissonièr No 16, au 1er
+	[N.] 1303. R.
+
+	This is the main theme, the pubblication comes along with 12
+	variations, it´s a pretty good start for classical guitarists.
+**/
+var MidiWriter = require('..');
+var tracks = [];
+
+tracks[0] = new MidiWriter.Track();
+tracks[0].setTimeSignature(3, 4);
+tracks[0].setTempo(100);
+
+var notes;
+
+// melody
+tracks[1] = new MidiWriter.Track();
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4', 'C#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['B4', 'D5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['G#4', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4', 'C#5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4', 'C#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['B4', 'D5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['G#4', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4', 'C#5'], duration: '2'});
+tracks[1].addEvent(notes);
+// note how the previous rest is handled: it became the wait
+notes = new MidiWriter.NoteEvent({wait: '4', pitch:['E5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['D#5', 'F#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['D5', 'G#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'A5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['E5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['D#5', 'F#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['D5', 'G#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'A5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch:['C#5', 'E5'], duration: '2'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4', 'C#5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['C#5', 'E5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['B4', 'D5'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['G#4', 'B4'], duration: '4'});
+tracks[1].addEvent(notes);
+notes = new MidiWriter.NoteEvent({pitch:['A4'], duration: '2'});
+tracks[1].addEvent(notes);
+
+// bass
+tracks[2] = new MidiWriter.Track();
+notes = new MidiWriter.NoteEvent({pitch:['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['E3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['E3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['E3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['E3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['E3'], duration: '2'});
+tracks[2].addEvent(notes);
+notes = new MidiWriter.NoteEvent({wait: '4', pitch: ['A3'], duration: '2'});
+tracks[2].addEvent(notes);
+
+
+var write = new MidiWriter.Writer(tracks);
+
+console.log(write.dataUri());
+module.exports = write;

package/examples/notes-by-start-tick.js

@@ -0,0 +1,45 @@
+var MidiWriter = require('..');
+
+var track = new MidiWriter.Track();
+
+track.addEvent([
+			new MidiWriter.NoteEvent({
+				pitch: 'C4',
+				duration: 'T50',
+				tick: 0
+			}),
+			new MidiWriter.NoteEvent({
+				pitch: 'E4',
+				duration: 'T50',
+				tick: 50
+			}),
+			new MidiWriter.NoteEvent({
+				pitch: ['G4', 'B4'],
+				duration: 'T50',
+				tick: 100
+			}),
+			new MidiWriter.NoteEvent({
+				pitch: 'C5',
+				duration: 'T50',
+				tick: 150
+			}),
+			new MidiWriter.NoteEvent({
+				pitch: 'D5',
+				duration: 'T50',
+				tick: 200
+			}),
+			new MidiWriter.NoteEvent({
+				pitch: 'F5',
+				duration: 'T50',
+				tick: 250
+			}),
+			new MidiWriter.NoteEvent({
+				pitch: 'A5',
+				duration: 'T50',
+				tick: 300
+			}),
+	]);
+
+var write = new MidiWriter.Writer(track);
+console.log(write.dataUri());
+module.exports = write;