tone 14.8.36 → 14.8.37

package/Tone/component/analysis/Meter.test.ts

@@ -5,6 +5,8 @@ import { ONLINE_TESTING } from "test/helper/Supports";
 import { Signal } from "Tone/signal/Signal";
 import { Oscillator } from "Tone/source/oscillator/Oscillator";
 import { Meter } from "./Meter";
+import { Panner } from "Tone/component/channel/Panner";
+import { Merge } from "Tone/component/channel/Merge";
 
 describe("Meter", () => {
 
@@ -86,6 +88,29 @@ describe("Meter", () => {
 					done();
 				}, 400);
 			});
+
+			it("can get the rms levels for multiple channels", (done) => {
+				const meter = new Meter({
+					channelCount: 2,
+					smoothing: 0.5,
+				});
+				const merge = new Merge().connect(meter);
+				const osc0 = new Oscillator().connect(merge, 0, 0).start();
+				const osc1 = new Oscillator().connect(merge, 0, 1).start();
+				osc0.volume.value = -6;
+				osc1.volume.value = -18;
+				setTimeout(() => {
+					const values = meter.getValue();
+					expect(values).to.have.lengthOf(2);
+					expect(values[0]).to.be.closeTo(-9, 1);
+					expect(values[1]).to.be.closeTo(-21, 1);
+					meter.dispose();
+					merge.dispose();
+					osc0.dispose();
+					osc1.dispose();
+					done();
+				}, 400);
+			});
 		}
 	});
 });

package/Tone/component/analysis/Meter.ts

@@ -42,9 +42,9 @@ export class Meter extends MeterBase<MeterOptions> {
 	smoothing: number;
 
 	/**
-	 * The previous frame's value
+	 * The previous frame's value for each channel.
 	 */
-	private _rms = 0;
+	private _rms: number[];
 
 	/**
 	 * @param smoothing The amount of smoothing applied between frames.
@@ -64,6 +64,8 @@ export class Meter extends MeterBase<MeterOptions> {
 
 		this.smoothing = options.smoothing,
 		this.normalRange = options.normalRange;
+		this._rms = new Array(options.channelCount);
+		this._rms.fill(0);
 	}
 
 	static getDefaults(): MeterOptions {
@@ -93,13 +95,13 @@ export class Meter extends MeterBase<MeterOptions> {
 	getValue(): number | number[] {
 		const aValues = this._analyser.getValue();
 		const channelValues = this.channels === 1 ? [aValues as Float32Array] : aValues as Float32Array[];
-		const vals = channelValues.map(values => {
+		const vals = channelValues.map((values, index) => {
 			const totalSquared = values.reduce((total, current) => total + current * current, 0);
 			const rms = Math.sqrt(totalSquared / values.length);
 			// the rms can only fall at the rate of the smoothing
 			// but can jump up instantly
-			this._rms = Math.max(rms, this._rms * this.smoothing);
-			return this.normalRange ? this._rms : gainToDb(this._rms);
+			this._rms[index] = Math.max(rms, this._rms[index]  * this.smoothing);
+			return this.normalRange ? this._rms[index] : gainToDb(this._rms[index]);
 		});
 		if (this.channels === 1) {
 			return vals[0];

package/Tone/core/clock/Ticker.ts

@@ -16,7 +16,12 @@ export class Ticker {
 	/**
 	 * The update interval of the worker
 	 */
-	private _updateInterval: Seconds;
+	private _updateInterval!: Seconds;
+
+	/**
+	 * The lowest allowable interval, preferably calculated from context sampleRate
+	 */
+	private _minimumUpdateInterval: Seconds;
 
 	/**
 	 * The callback to invoke at regular intervals
@@ -33,11 +38,12 @@ export class Ticker {
 	 */
 	private _worker!: Worker;
 
-	constructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds) {
+	constructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds, contextSampleRate?: number) {
 
 		this._callback = callback;
 		this._type = type;
-		this._updateInterval = updateInterval;
+		this._minimumUpdateInterval = Math.max( 128/(contextSampleRate || 44100), .001 );
+		this.updateInterval = updateInterval;
 
 		// create the clock source for the first time
 		this._createClock();
@@ -121,9 +127,9 @@ export class Ticker {
 		return this._updateInterval;
 	}
 	set updateInterval(interval: Seconds) {
-		this._updateInterval = Math.max(interval, 128 / 44100);
+		this._updateInterval = Math.max(interval, this._minimumUpdateInterval);
 		if (this._type === "worker") {
-			this._worker.postMessage(Math.max(interval * 1000, 1));
+			this._worker?.postMessage(this._updateInterval * 1000);
 		}
 	}
 

package/Tone/core/context/Context.test.ts

@@ -75,8 +75,10 @@ describe("Context", () => {
 				clockSource: "timeout",
 				latencyHint: "playback",
 				lookAhead: 0.2,
+				updateInterval: 0.1
 			});
 			expect(ctx.lookAhead).to.equal(0.2);
+			expect(ctx.updateInterval).to.equal(0.1);
 			expect(ctx.latencyHint).to.equal("playback");
 			expect(ctx.clockSource).to.equal("timeout");
 			ctx.dispose();

package/Tone/core/context/Context.ts

@@ -3,7 +3,7 @@ import { Seconds } from "../type/Units";
 import { isAudioContext } from "../util/AdvancedTypeCheck";
 import { optionsFromArguments } from "../util/Defaults";
 import { Timeline } from "../util/Timeline";
-import { isDefined, isString } from "../util/TypeCheck";
+import { isDefined } from "../util/TypeCheck";
 import {
 	AnyAudioContext,
 	createAudioContext,
@@ -39,13 +39,6 @@ export interface ContextTimeoutEvent {
 export class Context extends BaseContext {
 	readonly name: string = "Context";
 
-	/**
-	 * The amount of time into the future events are scheduled. Giving Web Audio
-	 * a short amount of time into the future to schedule events can reduce clicks and
-	 * improve performance. This value can be set to 0 to get the lowest latency.
-	 */
-	lookAhead: Seconds;
-
 	/**
 	 * private reference to the BaseAudioContext
 	 */
@@ -116,16 +109,20 @@ export class Context extends BaseContext {
 
 		if (options.context) {
 			this._context = options.context;
+			// custom context provided, latencyHint unknown (unless explicitly provided in options)
+			this._latencyHint = arguments[0]?.latencyHint || "";
 		} else {
 			this._context = createAudioContext({
 				latencyHint: options.latencyHint,
 			});
+			this._latencyHint = options.latencyHint;
 		}
 
 		this._ticker = new Ticker(
 			this.emit.bind(this, "tick"),
 			options.clockSource,
-			options.updateInterval
+			options.updateInterval,
+			this._context.sampleRate
 		);
 		this.on("tick", this._timeoutLoop.bind(this));
 
@@ -133,9 +130,9 @@ export class Context extends BaseContext {
 		this._context.onstatechange = () => {
 			this.emit("statechange", this.state);
 		};
-
-		this._setLatencyHint(options.latencyHint);
-		this.lookAhead = options.lookAhead;
+		
+		// if no custom updateInterval provided, updateInterval will be derived by lookAhead setter
+		this[arguments[0]?.hasOwnProperty("updateInterval") ? "_lookAhead" : "lookAhead"] = options.lookAhead;
 	}
 
 	static getDefaults(): ContextOptions {
@@ -391,8 +388,9 @@ export class Context extends BaseContext {
 	/**
 	 * How often the interval callback is invoked.
 	 * This number corresponds to how responsive the scheduling
-	 * can be. context.updateInterval + context.lookAhead gives you the
-	 * total latency between scheduling an event and hearing it.
+	 * can be. Setting to 0 will result in the lowest practial interval
+	 * based on context properties. context.updateInterval + context.lookAhead
+	 * gives you the total latency between scheduling an event and hearing it.
 	 */
 	get updateInterval(): Seconds {
 		return this._ticker.updateInterval;
@@ -412,6 +410,22 @@ export class Context extends BaseContext {
 		this._ticker.type = type;
 	}
 
+	/**
+	 * The amount of time into the future events are scheduled. Giving Web Audio
+	 * a short amount of time into the future to schedule events can reduce clicks and
+	 * improve performance. This value can be set to 0 to get the lowest latency.
+	 * Adjusting this value also affects the [[updateInterval]].
+	 */
+	get lookAhead(): Seconds {
+		return this._lookAhead;
+	}
+	set lookAhead(time: Seconds) {
+		this._lookAhead = time;
+		// if lookAhead is 0, default to .01 updateInterval
+		this.updateInterval = time ? (time / 2) : .01;
+	}	
+	private _lookAhead!: Seconds;
+
 	/**
 	 * The type of playback, which affects tradeoffs between audio
 	 * output latency and responsiveness.
@@ -431,29 +445,6 @@ export class Context extends BaseContext {
 		return this._latencyHint;
 	}
 
-	/**
-	 * Update the lookAhead and updateInterval based on the latencyHint
-	 */
-	private _setLatencyHint(hint: ContextLatencyHint | Seconds): void {
-		let lookAheadValue = 0;
-		this._latencyHint = hint;
-		if (isString(hint)) {
-			switch (hint) {
-				case "interactive":
-					lookAheadValue = 0.1;
-					break;
-				case "playback":
-					lookAheadValue = 0.5;
-					break;
-				case "balanced":
-					lookAheadValue = 0.25;
-					break;
-			}
-		}
-		this.lookAhead = lookAheadValue;
-		this.updateInterval = lookAheadValue / 2;
-	}
-
 	/**
 	 * The unwrapped AudioContext or OfflineAudioContext
 	 */
@@ -469,7 +460,7 @@ export class Context extends BaseContext {
 	 * }, 100);
 	 */
 	now(): Seconds {
-		return this._context.currentTime + this.lookAhead;
+		return this._context.currentTime + this._lookAhead;
 	}
 
 	/**

package/Tone/core/context/ToneAudioBuffer.ts

@@ -1,7 +1,6 @@
 import { getContext } from "../Global";
 import { Tone } from "../Tone";
 import { Samples, Seconds } from "../type/Units";
-import { isAudioBuffer } from "../util/AdvancedTypeCheck";
 import { optionsFromArguments } from "../util/Defaults";
 import { noOp } from "../util/Interface";
 import { isArray, isNumber, isString } from "../util/TypeCheck";
@@ -25,7 +24,6 @@ interface ToneAudioBufferOptions {
  * @category Core
  */
 export class ToneAudioBuffer extends Tone {
-
 	readonly name: string = "ToneAudioBuffer";
 
 	/**
@@ -54,23 +52,26 @@ export class ToneAudioBuffer extends Tone {
 	constructor(
 		url?: string | ToneAudioBuffer | AudioBuffer,
 		onload?: (buffer: ToneAudioBuffer) => void,
-		onerror?: (error: Error) => void,
+		onerror?: (error: Error) => void
 	);
 	constructor(options?: Partial<ToneAudioBufferOptions>);
 	constructor() {
-
 		super();
 
-		const options = optionsFromArguments(ToneAudioBuffer.getDefaults(), arguments, ["url", "onload", "onerror"]);
+		const options = optionsFromArguments(
+			ToneAudioBuffer.getDefaults(),
+			arguments,
+			["url", "onload", "onerror"]
+		);
 
 		this.reverse = options.reverse;
 		this.onload = options.onload;
 
-		if (options.url && isAudioBuffer(options.url) || options.url instanceof ToneAudioBuffer) {
-			this.set(options.url);
-		} else if (isString(options.url)) {
+		if (isString(options.url)) {
 			// initiate the download
 			this.load(options.url).catch(options.onerror);
+		} else if (options.url) {
+			this.set(options.url);
 		}
 	}
 
@@ -132,11 +133,13 @@ export class ToneAudioBuffer extends Tone {
 	 * @returns A Promise which resolves with this ToneAudioBuffer
 	 */
 	async load(url: string): Promise<this> {
-		const doneLoading: Promise<void> = ToneAudioBuffer.load(url).then(audioBuffer => {
-			this.set(audioBuffer);
-			// invoke the onload method
-			this.onload(this);
-		});
+		const doneLoading: Promise<void> = ToneAudioBuffer.load(url).then(
+			(audioBuffer) => {
+				this.set(audioBuffer);
+				// invoke the onload method
+				this.onload(this);
+			}
+		);
 		ToneAudioBuffer.downloads.push(doneLoading);
 		try {
 			await doneLoading;
@@ -165,11 +168,15 @@ export class ToneAudioBuffer extends Tone {
 	fromArray(array: Float32Array | Float32Array[]): this {
 		const isMultidimensional = isArray(array) && array[0].length > 0;
 		const channels = isMultidimensional ? array.length : 1;
-		const len = isMultidimensional ? (array[0] as Float32Array).length : array.length;
+		const len = isMultidimensional
+			? (array[0] as Float32Array).length
+			: array.length;
 		const context = getContext();
 		const buffer = context.createBuffer(channels, len, context.sampleRate);
-		const multiChannelArray: Float32Array[] = !isMultidimensional && channels === 1 ?
-			[array as Float32Array] : array as Float32Array[];
+		const multiChannelArray: Float32Array[] =
+			!isMultidimensional && channels === 1
+				? [array as Float32Array]
+				: (array as Float32Array[]);
 
 		for (let c = 0; c < channels; c++) {
 			buffer.copyToChannel(multiChannelArray[c], c);
@@ -195,7 +202,7 @@ export class ToneAudioBuffer extends Tone {
 				}
 			}
 			// divide by the number of channels
-			outputArray = outputArray.map(sample => sample / numChannels);
+			outputArray = outputArray.map((sample) => sample / numChannels);
 			this.fromArray(outputArray);
 		}
 		return this;
@@ -243,11 +250,21 @@ export class ToneAudioBuffer extends Tone {
 		assert(this.loaded, "Buffer is not loaded");
 		const startSamples = Math.floor(start * this.sampleRate);
 		const endSamples = Math.floor(end * this.sampleRate);
-		assert(startSamples < endSamples, "The start time must be less than the end time");
+		assert(
+			startSamples < endSamples,
+			"The start time must be less than the end time"
+		);
 		const length = endSamples - startSamples;
-		const retBuffer = getContext().createBuffer(this.numberOfChannels, length, this.sampleRate);
+		const retBuffer = getContext().createBuffer(
+			this.numberOfChannels,
+			length,
+			this.sampleRate
+		);
 		for (let channel = 0; channel < this.numberOfChannels; channel++) {
-			retBuffer.copyToChannel(this.getChannelData(channel).subarray(startSamples, endSamples), channel);
+			retBuffer.copyToChannel(
+				this.getChannelData(channel).subarray(startSamples, endSamples),
+				channel
+			);
 		}
 		return new ToneAudioBuffer(retBuffer);
 	}
@@ -333,7 +350,7 @@ export class ToneAudioBuffer extends Tone {
 	 * @return A ToneAudioBuffer created from the array
 	 */
 	static fromArray(array: Float32Array | Float32Array[]): ToneAudioBuffer {
-		return (new ToneAudioBuffer()).fromArray(array);
+		return new ToneAudioBuffer().fromArray(array);
 	}
 
 	/**
@@ -355,7 +372,6 @@ export class ToneAudioBuffer extends Tone {
 	 * Loads a url using fetch and returns the AudioBuffer.
 	 */
 	static async load(url: string): Promise<AudioBuffer> {
-
 		// test if the url contains multiple extensions
 		const matches = url.match(/\[([^\]\[]+\|.+)\]$/);
 		if (matches) {
@@ -371,12 +387,19 @@ export class ToneAudioBuffer extends Tone {
 		}
 
 		// make sure there is a slash between the baseUrl and the url
-		const baseUrl = ToneAudioBuffer.baseUrl === "" || ToneAudioBuffer.baseUrl.endsWith("/") ? ToneAudioBuffer.baseUrl : ToneAudioBuffer.baseUrl + "/";
-		
+		const baseUrl =
+			ToneAudioBuffer.baseUrl === "" ||
+			ToneAudioBuffer.baseUrl.endsWith("/")
+				? ToneAudioBuffer.baseUrl
+				: ToneAudioBuffer.baseUrl + "/";
+
 		// encode special characters in file path
 		const location = document.createElement("a");
-		location.href = (baseUrl + url);
-		location.pathname = (location.pathname + location.hash).split("/").map(encodeURIComponent).join("/");
+		location.href = baseUrl + url;
+		location.pathname = (location.pathname + location.hash)
+			.split("/")
+			.map(encodeURIComponent)
+			.join("/");
 
 		const response = await fetch(location.href);
 		if (!response.ok) {
@@ -401,7 +424,9 @@ export class ToneAudioBuffer extends Tone {
 	static supportsType(url: string): boolean {
 		const extensions = url.split(".");
 		const extension = extensions[extensions.length - 1];
-		const response = document.createElement("audio").canPlayType("audio/" + extension);
+		const response = document
+			.createElement("audio")
+			.canPlayType("audio/" + extension);
 		return response !== "";
 	}
 

package/Tone/event/Pattern.test.ts

@@ -89,19 +89,21 @@ describe("Pattern", () => {
 		it("is invoked after it's started", () => {
 			let invoked = false;
 			return Offline(({ transport }) => {
+				const values = ["a", "b", "c"];
 				let index = 0;
 				const pattern = new Pattern((() => {
 					invoked = true;
-					expect(pattern.value).to.equal(index);
+					expect(pattern.value).to.equal(values[index]);
+					expect(pattern.index).to.equal(index);
 					index++;
-				}), [0, 1, 2]).start(0);
+				}), values).start(0);
 				transport.start();
 			}, 0.2).then(() => {
 				expect(invoked).to.be.true;
 			});
 		});
 
-		it("passes in the scheduled time and pattern index to the callback", () => {
+		it("passes in the scheduled time and pattern note to the callback", () => {
 			let invoked = false;
 			return Offline(({ transport }) => {
 				const startTime = 0.05;
@@ -109,6 +111,8 @@ describe("Pattern", () => {
 					expect(time).to.be.a("number");
 					expect(time - startTime).to.be.closeTo(0.3, 0.01);
 					expect(note).to.be.equal("a");
+					expect(pattern.value).to.equal("a");
+					expect(pattern.index).to.be.equal(0);
 					invoked = true;
 				}), ["a"], "up");
 				transport.start(startTime);
@@ -121,16 +125,38 @@ describe("Pattern", () => {
 		it("passes in the next note of the pattern", () => {
 			let counter = 0;
 			return Offline(({ transport }) => {
+				const values = ["a", "b", "c"];
 				const pattern = new Pattern(((time, note) => {
-					expect(note).to.equal(counter % 3);
+					expect(note).to.equal(values[counter % 3]);
+					expect(pattern.value).to.equal(values[counter % 3]);
+					expect(pattern.index).to.be.equal(counter % 3);
 					counter++;
-				}), [0, 1, 2], "up").start(0);
+				}), values, "up").start(0);
 				pattern.interval = "16n";
 				transport.start(0);
 			}, 0.7).then(() => {
 				expect(counter).to.equal(6);
 			});
 		});
+
+		it("can modify the pattern type and values", () => {
+			let counter = 0;
+			return Offline(({ transport }) => {
+				const values = ["a", "b", "c"];
+				const pattern = new Pattern(((time, note) => {
+					expect(note).to.equal(values[counter % 3]);
+					expect(pattern.value).to.equal(values[counter % 3]);
+					expect(pattern.index).to.be.equal(counter % 3);
+					counter++;
+				}), ["a"], "down").start(0);
+				pattern.interval = "16n";
+				pattern.pattern = "up";
+				pattern.values = values;
+				transport.start(0);
+			}, 0.7).then(() => {
+				expect(counter).to.equal(6);
+			});
+		});
 	});
 
 });

package/Tone/event/Pattern.ts

@@ -27,12 +27,17 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	/**
 	 * The pattern generator function
 	 */
-	private _pattern: Iterator<ValueType>;
+	private _pattern: Iterator<number>;
+
+	/**
+	 * The current index
+	 */
+	 private _index?: number;
 
 	/**
 	 * The current value
 	 */
-	private _value?: ValueType;
+	 private _value?: ValueType;
 
 	/**
 	 * Hold the pattern type
@@ -67,7 +72,7 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 
 		this.callback = options.callback;
 		this._values = options.values;
-		this._pattern = PatternGenerator(options.values, options.pattern);
+		this._pattern = PatternGenerator(options.values.length, options.pattern);
 		this._type = options.pattern;
 	}
 
@@ -83,8 +88,9 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	 * Internal function called when the notes should be called
 	 */
 	protected _tick(time: Seconds): void {
-		const value = this._pattern.next() as IteratorResult<ValueType>;
-		this._value = value.value;
+		const index = this._pattern.next() as IteratorResult<ValueType>;
+		this._index = index.value;
+		this._value = this._values[index.value];
 		this.callback(time, this._value);
 	}
 
@@ -107,6 +113,13 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 		return this._value;
 	}
 
+	/**
+	 * The current index of the pattern.
+	 */
+	 get index(): number | undefined {
+		return this._index;
+	}
+
 	/**
 	 * The pattern type. See Tone.CtrlPattern for the full list of patterns.
 	 */
@@ -115,7 +128,7 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	}
 	set pattern(pattern) {
 		this._type = pattern;
-		this._pattern = PatternGenerator(this._values, this._type);
+		this._pattern = PatternGenerator(this._values.length, this._type);
 	}
 }
 

package/Tone/event/PatternGenerator.test.ts

@@ -13,22 +13,14 @@ describe("PatternGenerator", () => {
 
 	context("API", () => {
 
-		it("can be constructed with an array and type", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "down");
+		it("can be constructed with an number and type", () => {
+			const pattern = PatternGenerator(4, "down");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([3, 2, 1, 0, 3, 2, 1, 0, 3, 2]);
 		});
 
-		it("can be resized smaller when the index is after the previous length", () => {
-			const values = [0, 1, 2, 3, 4];
-			const pattern = PatternGenerator(values);
-			expect(pattern.next().value).to.equal(0);
-			values.shift();
-			expect(pattern.next().value).to.equal(2);
-		});
-
-		it("throws an error with an empty array", () => {
+		it("throws an error with a number less than 1", () => {
 			expect(() => {
-				const pattern = PatternGenerator([]);
+				const pattern = PatternGenerator(0);
 				pattern.next();
 			}).to.throw(Error);
 		});
@@ -37,54 +29,54 @@ describe("PatternGenerator", () => {
 	context("Patterns", () => {
 
 		it("does the up pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "up");
+			const pattern = PatternGenerator(4, "up");
 			expect(getArrayValues(pattern, 6)).to.deep.equal([0, 1, 2, 3, 0, 1]);
 		});
 
 		it("does the down pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "down");
+			const pattern = PatternGenerator(4, "down");
 			expect(getArrayValues(pattern, 6)).to.deep.equal([3, 2, 1, 0, 3, 2]);
 		});
 
 		it("does the upDown pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "upDown");
+			const pattern = PatternGenerator(4, "upDown");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([0, 1, 2, 3, 2, 1, 0, 1, 2, 3]);
 		});
 
 		it("does the downUp pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3], "downUp");
+			const pattern = PatternGenerator(4, "downUp");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([3, 2, 1, 0, 1, 2, 3, 2, 1, 0]);
 		});
 
 		it("does the alternateUp pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3, 4], "alternateUp");
+			const pattern = PatternGenerator(5, "alternateUp");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([0, 2, 1, 3, 2, 4, 3, 0, 2, 1]);
 		});
 
 		it("does the alternateDown pattern", () => {
-			const pattern = PatternGenerator([0, 1, 2, 3, 4], "alternateDown");
+			const pattern = PatternGenerator(5, "alternateDown");
 			expect(getArrayValues(pattern, 10)).to.deep.equal([4, 2, 3, 1, 2, 0, 1, 4, 2, 3]);
 		});
 
 		it("outputs random elements from the values", () => {
-			const values = [0, 1, 2, 3, 4];
-			const pattern = PatternGenerator(values, "random");
+			const numValues = 5;
+			const pattern = PatternGenerator(numValues, "random");
 			for (let i = 0; i < 10; i++) {
-				expect(values.indexOf(pattern.next().value)).to.not.equal(-1);
+				expect(pattern.next().value).to.be.at.least(0).and.at.most(numValues - 1);
 			}
 		});
 
 		it("does randomOnce pattern", () => {
-			const pattern = PatternGenerator([4, 5, 6, 7, 8], "randomOnce");
-			expect(getArrayValues(pattern, 10).sort()).to.deep.equal([4, 4, 5, 5, 6, 6, 7, 7, 8, 8]);
+			const pattern = PatternGenerator(5, "randomOnce");
+			expect(getArrayValues(pattern, 10).sort()).to.deep.equal([0, 0, 1, 1, 2, 2, 3, 3, 4, 4]);
 		});
                 
 		it("randomly walks up or down 1 step without repeating", () => {
 			const values = [0, 1, 2, 3, 4];
-			const pattern = PatternGenerator(values, "randomWalk");
-			let currentIndex = values.indexOf(pattern.next().value);
+			const pattern = PatternGenerator(5, "randomWalk");
+			let currentIndex = pattern.next().value;
 			for (let i = 0; i < 10; i++) {
-				const nextIndex = values.indexOf(pattern.next().value);
+				const nextIndex = pattern.next().value;
 				expect(currentIndex).to.not.equal(nextIndex);
 				// change always equals 1
 				expect(Math.abs(currentIndex - nextIndex)).to.equal(1);