tone 14.8.27

package/build/esm/core/util/Math.js

@@ -0,0 +1,36 @@
+/**
+ * The threshold for correctness for operators. Less than one sample even
+ * at very high sampling rates (e.g. `1e-6 < 1 / 192000`).
+ */
+const EPSILON = 1e-6;
+/**
+ * Test if A is greater than B
+ */
+export function GT(a, b) {
+    return a > b + EPSILON;
+}
+/**
+ * Test if A is greater than or equal to B
+ */
+export function GTE(a, b) {
+    return GT(a, b) || EQ(a, b);
+}
+/**
+ * Test if A is less than B
+ */
+export function LT(a, b) {
+    return a + EPSILON < b;
+}
+/**
+ * Test if A is less than B
+ */
+export function EQ(a, b) {
+    return Math.abs(a - b) < EPSILON;
+}
+/**
+ * Clamp the value within the given range
+ */
+export function clamp(value, min, max) {
+    return Math.max(Math.min(value, max), min);
+}
+//# sourceMappingURL=Math.js.map

package/build/esm/core/util/Math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Math.js","sourceRoot":"","sources":["../../../../Tone/core/util/Math.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,OAAO,GAAG,IAAI,CAAC;AAErB;;GAEG;AACH,MAAM,UAAU,EAAE,CAAC,CAAS,EAAE,CAAS;IACtC,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;AACxB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS,EAAE,CAAS;IACvC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,EAAE,CAAC,CAAS,EAAE,CAAS;IACtC,OAAO,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC;AACxB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,EAAE,CAAC,CAAS,EAAE,CAAS;IACtC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC;AAClC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,KAAK,CAAC,KAAa,EAAE,GAAW,EAAE,GAAW;IAC5D,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AAC5C,CAAC"}

package/build/esm/core/util/StateTimeline.d.ts

@@ -0,0 +1,47 @@
+import { Seconds } from "../type/Units";
+import { Timeline, TimelineEvent } from "./Timeline";
+export declare type BasicPlaybackState = "started" | "stopped";
+export declare type PlaybackState = BasicPlaybackState | "paused";
+export interface StateTimelineEvent extends TimelineEvent {
+    state: PlaybackState;
+}
+/**
+ * A Timeline State. Provides the methods: `setStateAtTime("state", time)` and `getValueAtTime(time)`
+ * @param initial The initial state of the StateTimeline.  Defaults to `undefined`
+ */
+export declare class StateTimeline<AdditionalOptions extends {} = {}> extends Timeline<StateTimelineEvent & AdditionalOptions> {
+    readonly name: string;
+    /**
+     * The initial state
+     */
+    private _initial;
+    constructor(initial?: PlaybackState);
+    /**
+     * Returns the scheduled state scheduled before or at
+     * the given time.
+     * @param  time  The time to query.
+     * @return  The name of the state input in setStateAtTime.
+     */
+    getValueAtTime(time: Seconds): PlaybackState;
+    /**
+     * Add a state to the timeline.
+     * @param  state The name of the state to set.
+     * @param  time  The time to query.
+     * @param options Any additional options that are needed in the timeline.
+     */
+    setStateAtTime(state: PlaybackState, time: Seconds, options?: AdditionalOptions): this;
+    /**
+     * Return the event before the time with the given state
+     * @param  state The state to look for
+     * @param  time  When to check before
+     * @return  The event with the given state before the time
+     */
+    getLastState(state: PlaybackState, time: number): StateTimelineEvent & AdditionalOptions | undefined;
+    /**
+     * Return the event after the time with the given state
+     * @param  state The state to look for
+     * @param  time  When to check from
+     * @return  The event with the given state after the time
+     */
+    getNextState(state: PlaybackState, time: number): StateTimelineEvent & AdditionalOptions | undefined;
+}

package/build/esm/core/util/StateTimeline.js

@@ -0,0 +1,78 @@
+import { Timeline } from "./Timeline";
+import { assertRange } from "./Debug";
+/**
+ * A Timeline State. Provides the methods: `setStateAtTime("state", time)` and `getValueAtTime(time)`
+ * @param initial The initial state of the StateTimeline.  Defaults to `undefined`
+ */
+export class StateTimeline extends Timeline {
+    constructor(initial = "stopped") {
+        super();
+        this.name = "StateTimeline";
+        this._initial = initial;
+        this.setStateAtTime(this._initial, 0);
+    }
+    /**
+     * Returns the scheduled state scheduled before or at
+     * the given time.
+     * @param  time  The time to query.
+     * @return  The name of the state input in setStateAtTime.
+     */
+    getValueAtTime(time) {
+        const event = this.get(time);
+        if (event !== null) {
+            return event.state;
+        }
+        else {
+            return this._initial;
+        }
+    }
+    /**
+     * Add a state to the timeline.
+     * @param  state The name of the state to set.
+     * @param  time  The time to query.
+     * @param options Any additional options that are needed in the timeline.
+     */
+    setStateAtTime(state, time, options) {
+        assertRange(time, 0);
+        this.add(Object.assign({}, options, {
+            state,
+            time,
+        }));
+        return this;
+    }
+    /**
+     * Return the event before the time with the given state
+     * @param  state The state to look for
+     * @param  time  When to check before
+     * @return  The event with the given state before the time
+     */
+    getLastState(state, time) {
+        // time = this.toSeconds(time);
+        const index = this._search(time);
+        for (let i = index; i >= 0; i--) {
+            const event = this._timeline[i];
+            if (event.state === state) {
+                return event;
+            }
+        }
+    }
+    /**
+     * Return the event after the time with the given state
+     * @param  state The state to look for
+     * @param  time  When to check from
+     * @return  The event with the given state after the time
+     */
+    getNextState(state, time) {
+        // time = this.toSeconds(time);
+        const index = this._search(time);
+        if (index !== -1) {
+            for (let i = index; i < this._timeline.length; i++) {
+                const event = this._timeline[i];
+                if (event.state === state) {
+                    return event;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=StateTimeline.js.map

package/build/esm/core/util/StateTimeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTimeline.js","sourceRoot":"","sources":["../../../../Tone/core/util/StateTimeline.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAiB,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAStC;;;GAGG;AACH,MAAM,OAAO,aAAiD,SAAQ,QAAgD;IASrH,YAAY,UAAyB,SAAS;QAC7C,KAAK,EAAE,CAAC;QARA,SAAI,GAAW,eAAe,CAAC;QASvC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,IAAa;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,KAAK,KAAK,IAAI,EAAE;YACnB,OAAO,KAAK,CAAC,KAAK,CAAC;SACnB;aAAM;YACN,OAAO,IAAI,CAAC,QAAQ,CAAC;SACrB;IACF,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,KAAoB,EAAE,IAAa,EAAE,OAA2B;QAC9E,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QACrB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE;YACnC,KAAK;YACL,IAAI;SACJ,CAAC,CAAC,CAAC;QACJ,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,KAAoB,EAAE,IAAY;QAC9C,+BAA+B;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjC,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,EAAE;gBAC1B,OAAO,KAAK,CAAC;aACb;SACD;IACF,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,KAAoB,EAAE,IAAY;QAC9C,+BAA+B;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YACjB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACnD,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gBAChC,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,EAAE;oBAC1B,OAAO,KAAK,CAAC;iBACb;aACD;SACD;IACF,CAAC;CACD"}

package/build/esm/core/util/Timeline.d.ts

@@ -0,0 +1,156 @@
+import { Tone } from "../Tone";
+import { Seconds } from "../type/Units";
+declare type TimelineSearchParam = "ticks" | "time";
+/**
+ * The options object for Timeline
+ */
+interface TimelineOptions {
+    memory: number;
+    increasing: boolean;
+}
+/**
+ * An event must have a time number
+ */
+export interface TimelineEvent {
+    time: number;
+}
+/**
+ * A Timeline class for scheduling and maintaining state
+ * along a timeline. All events must have a "time" property.
+ * Internally, events are stored in time order for fast
+ * retrieval.
+ */
+export declare class Timeline<GenericEvent extends TimelineEvent> extends Tone {
+    readonly name: string;
+    /**
+     * The memory of the timeline, i.e.
+     * how many events in the past it will retain
+     */
+    memory: number;
+    /**
+     * The array of scheduled timeline events
+     */
+    protected _timeline: GenericEvent[];
+    /**
+     * If the time value must always be greater than or equal to the last
+     * element on the list.
+     */
+    increasing: boolean;
+    /**
+     * @param memory The number of previous events that are retained.
+     */
+    constructor(memory?: number);
+    constructor(options?: Partial<TimelineOptions>);
+    static getDefaults(): TimelineOptions;
+    /**
+     * The number of items in the timeline.
+     */
+    get length(): number;
+    /**
+     * Insert an event object onto the timeline. Events must have a "time" attribute.
+     * @param event  The event object to insert into the timeline.
+     */
+    add(event: GenericEvent): this;
+    /**
+     * Remove an event from the timeline.
+     * @param  {Object}  event  The event object to remove from the list.
+     * @returns {Timeline} this
+     */
+    remove(event: GenericEvent): this;
+    /**
+     * Get the nearest event whose time is less than or equal to the given time.
+     * @param  time  The time to query.
+     */
+    get(time: number, param?: TimelineSearchParam): GenericEvent | null;
+    /**
+     * Return the first event in the timeline without removing it
+     * @returns {Object} The first event object
+     */
+    peek(): GenericEvent | undefined;
+    /**
+     * Return the first event in the timeline and remove it
+     */
+    shift(): GenericEvent | undefined;
+    /**
+     * Get the event which is scheduled after the given time.
+     * @param  time  The time to query.
+     */
+    getAfter(time: number, param?: TimelineSearchParam): GenericEvent | null;
+    /**
+     * Get the event before the event at the given time.
+     * @param  time  The time to query.
+     */
+    getBefore(time: number): GenericEvent | null;
+    /**
+     * Cancel events at and after the given time
+     * @param  after  The time to query.
+     */
+    cancel(after: number): this;
+    /**
+     * Cancel events before or equal to the given time.
+     * @param  time  The time to cancel before.
+     */
+    cancelBefore(time: number): this;
+    /**
+     * Returns the previous event if there is one. null otherwise
+     * @param  event The event to find the previous one of
+     * @return The event right before the given event
+     */
+    previousEvent(event: GenericEvent): GenericEvent | null;
+    /**
+     * Does a binary search on the timeline array and returns the
+     * nearest event index whose time is after or equal to the given time.
+     * If a time is searched before the first index in the timeline, -1 is returned.
+     * If the time is after the end, the index of the last item is returned.
+     */
+    protected _search(time: number, param?: TimelineSearchParam): number;
+    /**
+     * Internal iterator. Applies extra safety checks for
+     * removing items from the array.
+     */
+    private _iterate;
+    /**
+     * Iterate over everything in the array
+     * @param  callback The callback to invoke with every item
+     */
+    forEach(callback: (event: GenericEvent) => void): this;
+    /**
+     * Iterate over everything in the array at or before the given time.
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachBefore(time: Seconds, callback: (event: GenericEvent) => void): this;
+    /**
+     * Iterate over everything in the array after the given time.
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachAfter(time: Seconds, callback: (event: GenericEvent) => void): this;
+    /**
+     * Iterate over everything in the array between the startTime and endTime.
+     * The timerange is inclusive of the startTime, but exclusive of the endTime.
+     * range = [startTime, endTime).
+     * @param  startTime The time to check if items are before
+     * @param  endTime The end of the test interval.
+     * @param  callback The callback to invoke with every item
+     */
+    forEachBetween(startTime: number, endTime: number, callback: (event: GenericEvent) => void): this;
+    /**
+     * Iterate over everything in the array at or after the given time. Similar to
+     * forEachAfter, but includes the item(s) at the given time.
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachFrom(time: number, callback: (event: GenericEvent) => void): this;
+    /**
+     * Iterate over everything in the array at the given time
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachAtTime(time: number, callback: (event: GenericEvent) => void): this;
+    /**
+     * Clean up.
+     */
+    dispose(): this;
+}
+export {};

package/build/esm/core/util/Timeline.js

@@ -0,0 +1,351 @@
+import { Tone } from "../Tone";
+import { optionsFromArguments } from "./Defaults";
+import { assert } from "./Debug";
+import { EQ, GT, GTE, LT } from "./Math";
+/**
+ * A Timeline class for scheduling and maintaining state
+ * along a timeline. All events must have a "time" property.
+ * Internally, events are stored in time order for fast
+ * retrieval.
+ */
+export class Timeline extends Tone {
+    constructor() {
+        super();
+        this.name = "Timeline";
+        /**
+         * The array of scheduled timeline events
+         */
+        this._timeline = [];
+        const options = optionsFromArguments(Timeline.getDefaults(), arguments, ["memory"]);
+        this.memory = options.memory;
+        this.increasing = options.increasing;
+    }
+    static getDefaults() {
+        return {
+            memory: Infinity,
+            increasing: false,
+        };
+    }
+    /**
+     * The number of items in the timeline.
+     */
+    get length() {
+        return this._timeline.length;
+    }
+    /**
+     * Insert an event object onto the timeline. Events must have a "time" attribute.
+     * @param event  The event object to insert into the timeline.
+     */
+    add(event) {
+        // the event needs to have a time attribute
+        assert(Reflect.has(event, "time"), "Timeline: events must have a time attribute");
+        event.time = event.time.valueOf();
+        if (this.increasing && this.length) {
+            const lastValue = this._timeline[this.length - 1];
+            assert(GTE(event.time, lastValue.time), "The time must be greater than or equal to the last scheduled time");
+            this._timeline.push(event);
+        }
+        else {
+            const index = this._search(event.time);
+            this._timeline.splice(index + 1, 0, event);
+        }
+        // if the length is more than the memory, remove the previous ones
+        if (this.length > this.memory) {
+            const diff = this.length - this.memory;
+            this._timeline.splice(0, diff);
+        }
+        return this;
+    }
+    /**
+     * Remove an event from the timeline.
+     * @param  {Object}  event  The event object to remove from the list.
+     * @returns {Timeline} this
+     */
+    remove(event) {
+        const index = this._timeline.indexOf(event);
+        if (index !== -1) {
+            this._timeline.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * Get the nearest event whose time is less than or equal to the given time.
+     * @param  time  The time to query.
+     */
+    get(time, param = "time") {
+        const index = this._search(time, param);
+        if (index !== -1) {
+            return this._timeline[index];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Return the first event in the timeline without removing it
+     * @returns {Object} The first event object
+     */
+    peek() {
+        return this._timeline[0];
+    }
+    /**
+     * Return the first event in the timeline and remove it
+     */
+    shift() {
+        return this._timeline.shift();
+    }
+    /**
+     * Get the event which is scheduled after the given time.
+     * @param  time  The time to query.
+     */
+    getAfter(time, param = "time") {
+        const index = this._search(time, param);
+        if (index + 1 < this._timeline.length) {
+            return this._timeline[index + 1];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Get the event before the event at the given time.
+     * @param  time  The time to query.
+     */
+    getBefore(time) {
+        const len = this._timeline.length;
+        // if it's after the last item, return the last item
+        if (len > 0 && this._timeline[len - 1].time < time) {
+            return this._timeline[len - 1];
+        }
+        const index = this._search(time);
+        if (index - 1 >= 0) {
+            return this._timeline[index - 1];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Cancel events at and after the given time
+     * @param  after  The time to query.
+     */
+    cancel(after) {
+        if (this._timeline.length > 1) {
+            let index = this._search(after);
+            if (index >= 0) {
+                if (EQ(this._timeline[index].time, after)) {
+                    // get the first item with that time
+                    for (let i = index; i >= 0; i--) {
+                        if (EQ(this._timeline[i].time, after)) {
+                            index = i;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    this._timeline = this._timeline.slice(0, index);
+                }
+                else {
+                    this._timeline = this._timeline.slice(0, index + 1);
+                }
+            }
+            else {
+                this._timeline = [];
+            }
+        }
+        else if (this._timeline.length === 1) {
+            // the first item's time
+            if (GTE(this._timeline[0].time, after)) {
+                this._timeline = [];
+            }
+        }
+        return this;
+    }
+    /**
+     * Cancel events before or equal to the given time.
+     * @param  time  The time to cancel before.
+     */
+    cancelBefore(time) {
+        const index = this._search(time);
+        if (index >= 0) {
+            this._timeline = this._timeline.slice(index + 1);
+        }
+        return this;
+    }
+    /**
+     * Returns the previous event if there is one. null otherwise
+     * @param  event The event to find the previous one of
+     * @return The event right before the given event
+     */
+    previousEvent(event) {
+        const index = this._timeline.indexOf(event);
+        if (index > 0) {
+            return this._timeline[index - 1];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Does a binary search on the timeline array and returns the
+     * nearest event index whose time is after or equal to the given time.
+     * If a time is searched before the first index in the timeline, -1 is returned.
+     * If the time is after the end, the index of the last item is returned.
+     */
+    _search(time, param = "time") {
+        if (this._timeline.length === 0) {
+            return -1;
+        }
+        let beginning = 0;
+        const len = this._timeline.length;
+        let end = len;
+        if (len > 0 && this._timeline[len - 1][param] <= time) {
+            return len - 1;
+        }
+        while (beginning < end) {
+            // calculate the midpoint for roughly equal partition
+            let midPoint = Math.floor(beginning + (end - beginning) / 2);
+            const event = this._timeline[midPoint];
+            const nextEvent = this._timeline[midPoint + 1];
+            if (EQ(event[param], time)) {
+                // choose the last one that has the same time
+                for (let i = midPoint; i < this._timeline.length; i++) {
+                    const testEvent = this._timeline[i];
+                    if (EQ(testEvent[param], time)) {
+                        midPoint = i;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                return midPoint;
+            }
+            else if (LT(event[param], time) && GT(nextEvent[param], time)) {
+                return midPoint;
+            }
+            else if (GT(event[param], time)) {
+                // search lower
+                end = midPoint;
+            }
+            else {
+                // search upper
+                beginning = midPoint + 1;
+            }
+        }
+        return -1;
+    }
+    /**
+     * Internal iterator. Applies extra safety checks for
+     * removing items from the array.
+     */
+    _iterate(callback, lowerBound = 0, upperBound = this._timeline.length - 1) {
+        this._timeline.slice(lowerBound, upperBound + 1).forEach(callback);
+    }
+    /**
+     * Iterate over everything in the array
+     * @param  callback The callback to invoke with every item
+     */
+    forEach(callback) {
+        this._iterate(callback);
+        return this;
+    }
+    /**
+     * Iterate over everything in the array at or before the given time.
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachBefore(time, callback) {
+        // iterate over the items in reverse so that removing an item doesn't break things
+        const upperBound = this._search(time);
+        if (upperBound !== -1) {
+            this._iterate(callback, 0, upperBound);
+        }
+        return this;
+    }
+    /**
+     * Iterate over everything in the array after the given time.
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachAfter(time, callback) {
+        // iterate over the items in reverse so that removing an item doesn't break things
+        const lowerBound = this._search(time);
+        this._iterate(callback, lowerBound + 1);
+        return this;
+    }
+    /**
+     * Iterate over everything in the array between the startTime and endTime.
+     * The timerange is inclusive of the startTime, but exclusive of the endTime.
+     * range = [startTime, endTime).
+     * @param  startTime The time to check if items are before
+     * @param  endTime The end of the test interval.
+     * @param  callback The callback to invoke with every item
+     */
+    forEachBetween(startTime, endTime, callback) {
+        let lowerBound = this._search(startTime);
+        let upperBound = this._search(endTime);
+        if (lowerBound !== -1 && upperBound !== -1) {
+            if (this._timeline[lowerBound].time !== startTime) {
+                lowerBound += 1;
+            }
+            // exclusive of the end time
+            if (this._timeline[upperBound].time === endTime) {
+                upperBound -= 1;
+            }
+            this._iterate(callback, lowerBound, upperBound);
+        }
+        else if (lowerBound === -1) {
+            this._iterate(callback, 0, upperBound);
+        }
+        return this;
+    }
+    /**
+     * Iterate over everything in the array at or after the given time. Similar to
+     * forEachAfter, but includes the item(s) at the given time.
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachFrom(time, callback) {
+        // iterate over the items in reverse so that removing an item doesn't break things
+        let lowerBound = this._search(time);
+        // work backwards until the event time is less than time
+        while (lowerBound >= 0 && this._timeline[lowerBound].time >= time) {
+            lowerBound--;
+        }
+        this._iterate(callback, lowerBound + 1);
+        return this;
+    }
+    /**
+     * Iterate over everything in the array at the given time
+     * @param  time The time to check if items are before
+     * @param  callback The callback to invoke with every item
+     */
+    forEachAtTime(time, callback) {
+        // iterate over the items in reverse so that removing an item doesn't break things
+        const upperBound = this._search(time);
+        if (upperBound !== -1 && EQ(this._timeline[upperBound].time, time)) {
+            let lowerBound = upperBound;
+            for (let i = upperBound; i >= 0; i--) {
+                if (EQ(this._timeline[i].time, time)) {
+                    lowerBound = i;
+                }
+                else {
+                    break;
+                }
+            }
+            this._iterate(event => {
+                callback(event);
+            }, lowerBound, upperBound);
+        }
+        return this;
+    }
+    /**
+     * Clean up.
+     */
+    dispose() {
+        super.dispose();
+        this._timeline = [];
+        return this;
+    }
+}
+//# sourceMappingURL=Timeline.js.map