requirebin sketch

index.js

const most = require('most');


const stream = most.just(Array(170000));

const dest = [];

stream.forEach(bigArray =>
  dest.push.apply(dest, bigArray)
);

console.log(dest);

minified.js

setTimeout(function(){
;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {
    var canSetImmediate = typeof window !== 'undefined'
    && window.setImmediate;
    var canMutationObserver = typeof window !== 'undefined'
    && window.MutationObserver;
    var canPost = typeof window !== 'undefined'
    && window.postMessage && window.addEventListener
    ;

    if (canSetImmediate) {
        return function (f) { return window.setImmediate(f) };
    }

    var queue = [];

    if (canMutationObserver) {
        var hiddenDiv = document.createElement("div");
        var observer = new MutationObserver(function () {
            var queueList = queue.slice();
            queue.length = 0;
            queueList.forEach(function (fn) {
                fn();
            });
        });

        observer.observe(hiddenDiv, { attributes: true });

        return function nextTick(fn) {
            if (!queue.length) {
                hiddenDiv.setAttribute('yes', 'no');
            }
            queue.push(fn);
        };
    }

    if (canPost) {
        window.addEventListener('message', function (ev) {
            var source = ev.source;
            if ((source === window || source === null) && ev.data === 'process-tick') {
                ev.stopPropagation();
                if (queue.length > 0) {
                    var fn = queue.shift();
                    fn();
                }
            }
        }, true);

        return function nextTick(fn) {
            queue.push(fn);
            window.postMessage('process-tick', '*');
        };
    }

    return function nextTick(fn) {
        setTimeout(fn, 0);
    };
})();

process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;

process.binding = function (name) {
    throw new Error('process.binding is not supported');
};

// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};

},{}],2:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = LinkedList;

/**
 * Doubly linked list
 * @constructor
 */
function LinkedList() {
	this.head = null;
	this.length = 0;
}

/**
 * Add a node to the end of the list
 * @param {{prev:Object|null, next:Object|null, dispose:function}} x node to add
 */
LinkedList.prototype.add = function(x) {
	if(this.head !== null) {
		this.head.prev = x;
		x.next = this.head;
	}
	this.head = x;
	++this.length;
};

/**
 * Remove the provided node from the list
 * @param {{prev:Object|null, next:Object|null, dispose:function}} x node to remove
 */
LinkedList.prototype.remove = function(x) {
	--this.length;
	if(x === this.head) {
		this.head = this.head.next;
	}
	if(x.next !== null) {
		x.next.prev = x.prev;
		x.next = null;
	}
	if(x.prev !== null) {
		x.prev.next = x.next;
		x.prev = null;
	}
};

/**
 * @returns {boolean} true iff there are no nodes in the list
 */
LinkedList.prototype.isEmpty = function() {
	return this.length === 0;
};

/**
 * Dispose all nodes
 * @returns {Promise} promise that fulfills when all nodes have been disposed,
 *  or rejects if an error occurs while disposing
 */
LinkedList.prototype.dispose = function() {
	if(this.isEmpty()) {
		return Promise.resolve();
	}

	var promises = [];
	var x = this.head;
	this.head = null;
	this.length = 0;

	while(x !== null) {
		promises.push(x.dispose());
		x = x.next;
	}

	return Promise.all(promises);
};

},{}],3:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

exports.isPromise = isPromise;

function isPromise(p) {
	return p !== null && typeof p === 'object' && typeof p.then === 'function';
}

},{}],4:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

// Based on https://github.com/petkaantonov/deque

module.exports = Queue;

function Queue(capPow2) {
	this._capacity = capPow2||32;
	this._length = 0;
	this._head = 0;
}

Queue.prototype.push = function (x) {
	var len = this._length;
	this._checkCapacity(len + 1);

	var i = (this._head + len) & (this._capacity - 1);
	this[i] = x;
	this._length = len + 1;
};

Queue.prototype.shift = function () {
	var head = this._head;
	var x = this[head];

	this[head] = void 0;
	this._head = (head + 1) & (this._capacity - 1);
	this._length--;
	return x;
};

Queue.prototype.isEmpty = function() {
	return this._length === 0;
};

Queue.prototype.length = function () {
	return this._length;
};

Queue.prototype._checkCapacity = function (size) {
	if (this._capacity < size) {
		this._ensureCapacity(this._capacity << 1);
	}
};

Queue.prototype._ensureCapacity = function (capacity) {
	var oldCapacity = this._capacity;
	this._capacity = capacity;

	var last = this._head + this._length;

	if (last > oldCapacity) {
		copy(this, 0, this, oldCapacity, last & (oldCapacity - 1));
	}
};

function copy(src, srcIndex, dst, dstIndex, len) {
	for (var j = 0; j < len; ++j) {
		dst[j + dstIndex] = src[j + srcIndex];
		src[j + srcIndex] = void 0;
	}
}


},{}],5:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = Stream;

function Stream(source) {
	this.source = source;
}

},{}],6:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Pipe = require('../sink/Pipe');
var runSource = require('../runSource');
var dispose = require('../disposable/dispose');
var PropagateTask = require('../scheduler/PropagateTask');

exports.scan = scan;
exports.reduce = reduce;

/**
 * Create a stream containing successive reduce results of applying f to
 * the previous reduce result and the current stream item.
 * @param {function(result:*, x:*):*} f reducer function
 * @param {*} initial initial value
 * @param {Stream} stream stream to scan
 * @returns {Stream} new stream containing successive reduce results
 */
function scan(f, initial, stream) {
	return new Stream(new Scan(f, initial, stream.source));
}

function Scan(f, z, source) {
	this.source = source;
	this.f = f;
	this.value = z;
}

Scan.prototype.run = function(sink, scheduler) {
	var d1 = scheduler.asap(PropagateTask.event(this.value, sink));
	var d2 = this.source.run(new ScanSink(this.f, this.value, sink), scheduler);
	return dispose.all([d1, d2]);
};

function ScanSink(f, z, sink) {
	this.f = f;
	this.value = z;
	this.sink = sink;
}

ScanSink.prototype.event = function(t, x) {
	var f = this.f;
	this.value = f(this.value, x);
	this.sink.event(t, this.value);
};

ScanSink.prototype.error = Pipe.prototype.error;
ScanSink.prototype.end = Pipe.prototype.end;

/**
 * Reduce a stream to produce a single result.  Note that reducing an infinite
 * stream will return a Promise that never fulfills, but that may reject if an error
 * occurs.
 * @param {function(result:*, x:*):*} f reducer function
 * @param {*} initial initial value
 * @param {Stream} stream to reduce
 * @returns {Promise} promise for the file result of the reduce
 */
function reduce(f, initial, stream) {
	return runSource.withDefaultScheduler(noop, new Reduce(f, initial, stream.source));
}

function Reduce(f, z, source) {
	this.source = source;
	this.f = f;
	this.value = z;
}

Reduce.prototype.run = function(sink, scheduler) {
	return this.source.run(new ReduceSink(this.f, this.value, sink), scheduler);
};

function ReduceSink(f, z, sink) {
	this.f = f;
	this.value = z;
	this.sink = sink;
}

ReduceSink.prototype.event = function(t, x) {
	var f = this.f;
	this.value = f(this.value, x);
	this.sink.event(t, this.value);
};

ReduceSink.prototype.error = Pipe.prototype.error;

ReduceSink.prototype.end = function(t) {
	this.sink.end(t, this.value);
};

function noop() {}

},{"../Stream":5,"../disposable/dispose":34,"../runSource":44,"../scheduler/PropagateTask":45,"../sink/Pipe":53}],7:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var combine = require('./combine').combine;
var apply = require('@most/prelude').apply;

exports.ap  = ap;

/**
 * Assume fs is a stream containing functions, and apply the latest function
 * in fs to the latest value in xs.
 * fs:         --f---------g--------h------>
 * xs:         -a-------b-------c-------d-->
 * ap(fs, xs): --fa-----fb-gb---gc--hc--hd->
 * @param {Stream} fs stream of functions to apply to the latest x
 * @param {Stream} xs stream of values to which to apply all the latest f
 * @returns {Stream} stream containing all the applications of fs to xs
 */
function ap(fs, xs) {
	return combine(apply, fs, xs);
}

},{"./combine":9,"@most/prelude":69}],8:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var streamOf = require('../source/core').of;
var continueWith = require('./continueWith').continueWith;

exports.concat = concat;
exports.cycle = cycle;
exports.cons = cons;

/**
 * @param {*} x value to prepend
 * @param {Stream} stream
 * @returns {Stream} new stream with x prepended
 */
function cons(x, stream) {
	return concat(streamOf(x), stream);
}

/**
 * @param {Stream} left
 * @param {Stream} right
 * @returns {Stream} new stream containing all events in left followed by all
 *  events in right.  This *timeshifts* right to the end of left.
 */
function concat(left, right) {
	return continueWith(function() {
		return right;
	}, left);
}

/**
 * @deprecated
 * Tie stream into a circle, creating an infinite stream
 * @param {Stream} stream
 * @returns {Stream} new infinite stream
 */
function cycle(stream) {
	return continueWith(function cycleNext() {
		return cycle(stream);
	}, stream);
}

},{"../source/core":57,"./continueWith":11}],9:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var transform = require('./transform');
var core = require('../source/core');
var Pipe = require('../sink/Pipe');
var IndexSink = require('../sink/IndexSink');
var dispose = require('../disposable/dispose');
var base = require('@most/prelude');
var invoke = require('../invoke');

var map = base.map;
var tail = base.tail;

exports.combineArray = combineArray;
exports.combine = combine;

/**
 * Combine latest events from all input streams
 * @param {function(...events):*} f function to combine most recent events
 * @returns {Stream} stream containing the result of applying f to the most recent
 *  event of each input stream, whenever a new event arrives on any stream.
 */
function combine(f /*, ...streams */) {
	return combineArray(f, tail(arguments));
}

/**
 * Combine latest events from all input streams
 * @param {function(...events):*} f function to combine most recent events
 * @param {[Stream]} streams most recent events
 * @returns {Stream} stream containing the result of applying f to the most recent
 *  event of each input stream, whenever a new event arrives on any stream.
 */
function combineArray(f, streams) {
	var l = streams.length;
	return l === 0 ? core.empty()
		 : l === 1 ? transform.map(f, streams[0])
		 : new Stream(combineSources(f, streams));
}

function combineSources(f, streams) {
	return new Combine(f, map(getSource, streams))
}

function getSource(stream) {
	return stream.source;
}

function Combine(f, sources) {
	this.f = f;
	this.sources = sources;
}

Combine.prototype.run = function(sink, scheduler) {
	var l = this.sources.length;
	var disposables = new Array(l);
	var sinks = new Array(l);

	var mergeSink = new CombineSink(disposables, sinks, sink, this.f);

	for(var indexSink, i=0; i<l; ++i) {
		indexSink = sinks[i] = new IndexSink(i, mergeSink);
		disposables[i] = this.sources[i].run(indexSink, scheduler);
	}

	return dispose.all(disposables);
};

function CombineSink(disposables, sinks, sink, f) {
	this.sink = sink;
	this.disposables = disposables;
	this.sinks = sinks;
	this.f = f;

	var l = sinks.length;
	this.awaiting = l;
	this.values = new Array(l);
	this.hasValue = new Array(l);
	for(var i = 0; i < l; ++i) {
		this.hasValue[i] = false;
	}

	this.activeCount = sinks.length;
}

CombineSink.prototype.error = Pipe.prototype.error;

CombineSink.prototype.event = function(t, indexedValue) {
	var i = indexedValue.index;
	var awaiting = this._updateReady(i);

	this.values[i] = indexedValue.value;
	if(awaiting === 0) {
		this.sink.event(t, invoke(this.f, this.values));
	}
};

CombineSink.prototype._updateReady = function(index) {
	if(this.awaiting > 0) {
		if(!this.hasValue[index]) {
			this.hasValue[index] = true
			this.awaiting -= 1
		}
	}
	return this.awaiting;
}

CombineSink.prototype.end = function(t, indexedValue) {
	dispose.tryDispose(t, this.disposables[indexedValue.index], this.sink);
	if(--this.activeCount === 0) {
		this.sink.end(t, indexedValue.value);
	}
};

},{"../Stream":5,"../disposable/dispose":34,"../invoke":39,"../sink/IndexSink":51,"../sink/Pipe":53,"../source/core":57,"./transform":29,"@most/prelude":69}],10:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var mergeMapConcurrently = require('./mergeConcurrently').mergeMapConcurrently;

exports.concatMap = concatMap;

/**
 * Map each value in stream to a new stream, and concatenate them all
 * stream:              -a---b---cX
 * f(a):                 1-1-1-1X
 * f(b):                        -2-2-2-2X
 * f(c):                                -3-3-3-3X
 * stream.concatMap(f): -1-1-1-1-2-2-2-2-3-3-3-3X
 * @param {function(x:*):Stream} f function to map each value to a stream
 * @param {Stream} stream
 * @returns {Stream} new stream containing all events from each stream returned by f
 */
function concatMap(f, stream) {
	return mergeMapConcurrently(f, 1, stream);
}

},{"./mergeConcurrently":19}],11:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Sink = require('../sink/Pipe');
var dispose = require('../disposable/dispose');
var isPromise = require('../Promise').isPromise;

exports.continueWith = continueWith;

function continueWith(f, stream) {
	return new Stream(new ContinueWith(f, stream.source));
}

function ContinueWith(f, source) {
	this.f = f;
	this.source = source;
}

ContinueWith.prototype.run = function(sink, scheduler) {
	return new ContinueWithSink(this.f, this.source, sink, scheduler);
};

function ContinueWithSink(f, source, sink, scheduler) {
	this.f = f;
	this.sink = sink;
	this.scheduler = scheduler;
	this.active = true;
	this.disposable = dispose.once(source.run(this, scheduler));
}

ContinueWithSink.prototype.error = Sink.prototype.error;

ContinueWithSink.prototype.event = function(t, x) {
	if(!this.active) {
		return;
	}
	this.sink.event(t, x);
};

ContinueWithSink.prototype.end = function(t, x) {
	if(!this.active) {
		return;
	}

	dispose.tryDispose(t, this.disposable, this.sink);
	this._startNext(t, x, this.sink);
};

ContinueWithSink.prototype._startNext = function(t, x, sink) {
	try {
		this.disposable = this._continue(this.f, x, sink);
	} catch(e) {
		sink.error(t, e);
	}
};

ContinueWithSink.prototype._continue = function(f, x, sink) {
	return f(x).source.run(sink, this.scheduler);
};

ContinueWithSink.prototype.dispose = function() {
	this.active = false;
	return this.disposable.dispose();
};

},{"../Promise":3,"../Stream":5,"../disposable/dispose":34,"../sink/Pipe":53}],12:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Sink = require('../sink/Pipe');
var dispose = require('../disposable/dispose');
var PropagateTask = require('../scheduler/PropagateTask');

exports.delay = delay;

/**
 * @param {Number} delayTime milliseconds to delay each item
 * @param {Stream} stream
 * @returns {Stream} new stream containing the same items, but delayed by ms
 */
function delay(delayTime, stream) {
	return delayTime <= 0 ? stream
		 : new Stream(new Delay(delayTime, stream.source));
}

function Delay(dt, source) {
	this.dt = dt;
	this.source = source;
}

Delay.prototype.run = function(sink, scheduler) {
	var delaySink = new DelaySink(this.dt, sink, scheduler);
	return dispose.all([delaySink, this.source.run(delaySink, scheduler)]);
};

function DelaySink(dt, sink, scheduler) {
	this.dt = dt;
	this.sink = sink;
	this.scheduler = scheduler;
}

DelaySink.prototype.dispose = function() {
	var self = this;
	this.scheduler.cancelAll(function(task) {
		return task.sink === self.sink;
	});
};

DelaySink.prototype.event = function(t, x) {
	this.scheduler.delay(this.dt, PropagateTask.event(x, this.sink));
};

DelaySink.prototype.end = function(t, x) {
	this.scheduler.delay(this.dt, PropagateTask.end(x, this.sink));
};

DelaySink.prototype.error = Sink.prototype.error;

},{"../Stream":5,"../disposable/dispose":34,"../scheduler/PropagateTask":45,"../sink/Pipe":53}],13:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var SafeSink = require('../sink/SafeSink');
var Pipe = require('../sink/Pipe');
var dispose = require('../disposable/dispose');
var tryEvent = require('../source/tryEvent');
var isPromise = require('../Promise').isPromise;
var PropagateTask = require('../scheduler/PropagateTask');

exports.flatMapError = recoverWith;
exports.recoverWith  = recoverWith;
exports.throwError   = throwError;

/**
 * If stream encounters an error, recover and continue with items from stream
 * returned by f.
 * @param {function(error:*):Stream} f function which returns a new stream
 * @param {Stream} stream
 * @returns {Stream} new stream which will recover from an error by calling f
 */
function recoverWith(f, stream) {
	return new Stream(new RecoverWith(f, stream.source));
}

/**
 * Create a stream containing only an error
 * @param {*} e error value, preferably an Error or Error subtype
 * @returns {Stream} new stream containing only an error
 */
function throwError(e) {
	return new Stream(new ErrorSource(e));
}

function ErrorSource(e) {
	this.value = e;
}

ErrorSource.prototype.run = function(sink, scheduler) {
	return scheduler.asap(new PropagateTask(runError, this.value, sink));
};

function runError(t, e, sink) {
	sink.error(t, e);
}

function RecoverWith(f, source) {
	this.f = f;
	this.source = source;
}

RecoverWith.prototype.run = function(sink, scheduler) {
	return new RecoverWithSink(this.f, this.source, sink, scheduler);
};

function RecoverWithSink(f, source, sink, scheduler) {
	this.f = f;
	this.sink = new SafeSink(sink);
	this.scheduler = scheduler;
	this.disposable = source.run(this, scheduler);
}

RecoverWithSink.prototype.event = function(t, x) {
		tryEvent.tryEvent(t, x, this.sink);
}

RecoverWithSink.prototype.end = function(t, x) {
		tryEvent.tryEnd(t, x, this.sink);
}

RecoverWithSink.prototype.error = function(t, e) {
	var nextSink = this.sink.disable();

	dispose.tryDispose(t, this.disposable, this.sink);
	this._startNext(t, e, nextSink);
};

RecoverWithSink.prototype._startNext = function(t, x, sink) {
	try {
		this.disposable = this._continue(this.f, x, sink);
	} catch(e) {
		sink.error(t, e);
	}
};

RecoverWithSink.prototype._continue = function(f, x, sink) {
	var stream = f(x);
	return stream.source.run(sink, this.scheduler);
};

RecoverWithSink.prototype.dispose = function() {
	return this.disposable.dispose();
};

},{"../Promise":3,"../Stream":5,"../disposable/dispose":34,"../scheduler/PropagateTask":45,"../sink/Pipe":53,"../sink/SafeSink":54,"../source/tryEvent":66}],14:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Sink = require('../sink/Pipe');
var Filter = require('../fusion/Filter');

exports.filter = filter;
exports.skipRepeats = skipRepeats;
exports.skipRepeatsWith = skipRepeatsWith;

/**
 * Retain only items matching a predicate
 * @param {function(x:*):boolean} p filtering predicate called for each item
 * @param {Stream} stream stream to filter
 * @returns {Stream} stream containing only items for which predicate returns truthy
 */
function filter(p, stream) {
	return new Stream(Filter.create(p, stream.source));
}

/**
 * Skip repeated events, using === to detect duplicates
 * @param {Stream} stream stream from which to omit repeated events
 * @returns {Stream} stream without repeated events
 */
function skipRepeats(stream) {
	return skipRepeatsWith(same, stream);
}

/**
 * Skip repeated events using the provided equals function to detect duplicates
 * @param {function(a:*, b:*):boolean} equals optional function to compare items
 * @param {Stream} stream stream from which to omit repeated events
 * @returns {Stream} stream without repeated events
 */
function skipRepeatsWith(equals, stream) {
	return new Stream(new SkipRepeats(equals, stream.source));
}

function SkipRepeats(equals, source) {
	this.equals = equals;
	this.source = source;
}

SkipRepeats.prototype.run = function(sink, scheduler) {
	return this.source.run(new SkipRepeatsSink(this.equals, sink), scheduler);
};

function SkipRepeatsSink(equals, sink) {
	this.equals = equals;
	this.sink = sink;
	this.value = void 0;
	this.init = true;
}

SkipRepeatsSink.prototype.end   = Sink.prototype.end;
SkipRepeatsSink.prototype.error = Sink.prototype.error;

SkipRepeatsSink.prototype.event = function(t, x) {
	if(this.init) {
		this.init = false;
		this.value = x;
		this.sink.event(t, x);
	} else if(!this.equals(this.value, x)) {
		this.value = x;
		this.sink.event(t, x);
	}
};

function same(a, b) {
	return a === b;
}

},{"../Stream":5,"../fusion/Filter":36,"../sink/Pipe":53}],15:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var mergeConcurrently = require('./mergeConcurrently').mergeConcurrently;
var mergeMapConcurrently = require('./mergeConcurrently').mergeMapConcurrently;

exports.flatMap = flatMap;
exports.join = join;

/**
 * Map each value in the stream to a new stream, and merge it into the
 * returned outer stream. Event arrival times are preserved.
 * @param {function(x:*):Stream} f chaining function, must return a Stream
 * @param {Stream} stream
 * @returns {Stream} new stream containing all events from each stream returned by f
 */
function flatMap(f, stream) {
	return mergeMapConcurrently(f, Infinity, stream);
}

/**
 * Monadic join. Flatten a Stream<Stream<X>> to Stream<X> by merging inner
 * streams to the outer. Event arrival times are preserved.
 * @param {Stream<Stream<X>>} stream stream of streams
 * @returns {Stream<X>} new stream containing all events of all inner streams
 */
function join(stream) {
	return mergeConcurrently(Infinity, stream);
}

},{"./mergeConcurrently":19}],16:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Sink = require('../sink/Pipe');
var dispose = require('../disposable/dispose');
var PropagateTask = require('../scheduler/PropagateTask');
var Map = require('../fusion/Map');

exports.throttle = throttle;
exports.debounce = debounce;

/**
 * Limit the rate of events by suppressing events that occur too often
 * @param {Number} period time to suppress events
 * @param {Stream} stream
 * @returns {Stream}
 */
function throttle(period, stream) {
	return new Stream(throttleSource(period, stream.source));
}

function throttleSource(period, source) {
	return source instanceof Map ? commuteMapThrottle(period, source)
		: source instanceof Throttle ? fuseThrottle(period, source)
		: new Throttle(period, source)
}

function commuteMapThrottle(period, source) {
	return Map.create(source.f, throttleSource(period, source.source))
}

function fuseThrottle(period, source) {
	return new Throttle(Math.max(period, source.period), source.source)
}

function Throttle(period, source) {
	this.period = period;
	this.source = source;
}

Throttle.prototype.run = function(sink, scheduler) {
	return this.source.run(new ThrottleSink(this.period, sink), scheduler);
};

function ThrottleSink(period, sink) {
	this.time = 0;
	this.period = period;
	this.sink = sink;
}

ThrottleSink.prototype.event = function(t, x) {
	if(t >= this.time) {
		this.time = t + this.period;
		this.sink.event(t, x);
	}
};

ThrottleSink.prototype.end   = Sink.prototype.end;

ThrottleSink.prototype.error = Sink.prototype.error;

/**
 * Wait for a burst of events to subside and emit only the last event in the burst
 * @param {Number} period events occuring more frequently than this
 *  will be suppressed
 * @param {Stream} stream stream to debounce
 * @returns {Stream} new debounced stream
 */
function debounce(period, stream) {
	return new Stream(new Debounce(period, stream.source));
}

function Debounce(dt, source) {
	this.dt = dt;
	this.source = source;
}

Debounce.prototype.run = function(sink, scheduler) {
	return new DebounceSink(this.dt, this.source, sink, scheduler);
};

function DebounceSink(dt, source, sink, scheduler) {
	this.dt = dt;
	this.sink = sink;
	this.scheduler = scheduler;
	this.value = void 0;
	this.timer = null;

	var sourceDisposable = source.run(this, scheduler);
	this.disposable = dispose.all([this, sourceDisposable]);
}

DebounceSink.prototype.event = function(t, x) {
	this._clearTimer();
	this.value = x;
	this.timer = this.scheduler.delay(this.dt, PropagateTask.event(x, this.sink));
};

DebounceSink.prototype.end = function(t, x) {
	if(this._clearTimer()) {
		this.sink.event(t, this.value);
		this.value = void 0;
	}
	this.sink.end(t, x);
};

DebounceSink.prototype.error = function(t, x) {
	this._clearTimer();
	this.sink.error(t, x);
};

DebounceSink.prototype.dispose = function() {
	this._clearTimer();
};

DebounceSink.prototype._clearTimer = function() {
	if(this.timer === null) {
		return false;
	}
	this.timer.dispose();
	this.timer = null;
	return true;
};

},{"../Stream":5,"../disposable/dispose":34,"../fusion/Map":38,"../scheduler/PropagateTask":45,"../sink/Pipe":53}],17:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Pipe = require('../sink/Pipe');

exports.loop = loop;

/**
 * Generalized feedback loop. Call a stepper function for each event. The stepper
 * will be called with 2 params: the current seed and the an event value.  It must
 * return a new { seed, value } pair. The `seed` will be fed back into the next
 * invocation of stepper, and the `value` will be propagated as the event value.
 * @param {function(seed:*, value:*):{seed:*, value:*}} stepper loop step function
 * @param {*} seed initial seed value passed to first stepper call
 * @param {Stream} stream event stream
 * @returns {Stream} new stream whose values are the `value` field of the objects
 * returned by the stepper
 */
function loop(stepper, seed, stream) {
	return new Stream(new Loop(stepper, seed, stream.source));
}

function Loop(stepper, seed, source) {
	this.step = stepper;
	this.seed = seed;
	this.source = source;
}

Loop.prototype.run = function(sink, scheduler) {
	return this.source.run(new LoopSink(this.step, this.seed, sink), scheduler);
};

function LoopSink(stepper, seed, sink) {
	this.step = stepper;
	this.seed = seed;
	this.sink = sink;
}

LoopSink.prototype.error = Pipe.prototype.error;

LoopSink.prototype.event = function(t, x) {
	var result = this.step(this.seed, x);
	this.seed = result.seed;
	this.sink.event(t, result.value);
};

LoopSink.prototype.end = function(t) {
	this.sink.end(t, this.seed);
};

},{"../Stream":5,"../sink/Pipe":53}],18:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Pipe = require('../sink/Pipe');
var IndexSink = require('../sink/IndexSink');
var empty = require('../source/core').empty;
var dispose = require('../disposable/dispose');
var base = require('@most/prelude');

var copy = base.copy;
var reduce = base.reduce;

exports.merge = merge;
exports.mergeArray = mergeArray;

/**
 * @returns {Stream} stream containing events from all streams in the argument
 * list in time order.  If two events are simultaneous they will be merged in
 * arbitrary order.
 */
function merge(/*...streams*/) {
	return mergeArray(copy(arguments));
}

/**
 * @param {Array} streams array of stream to merge
 * @returns {Stream} stream containing events from all input observables
 * in time order.  If two events are simultaneous they will be merged in
 * arbitrary order.
 */
function mergeArray(streams) {
    var l = streams.length;
    return l === 0 ? empty()
		 : l === 1 ? streams[0]
		 : new Stream(mergeSources(streams));
}

/**
 * This implements fusion/flattening for merge.  It will
 * fuse adjacent merge operations.  For example:
 * - a.merge(b).merge(c) effectively becomes merge(a, b, c)
 * - merge(a, merge(b, c)) effectively becomes merge(a, b, c)
 * It does this by concatenating the sources arrays of
 * any nested Merge sources, in effect "flattening" nested
 * merge operations into a single merge.
 */
function mergeSources(streams) {
	return new Merge(reduce(appendSources, [], streams))
}

function appendSources(sources, stream) {
	var source = stream.source;
	return source instanceof Merge
		? sources.concat(source.sources)
		: sources.concat(source)
}

function Merge(sources) {
	this.sources = sources;
}

Merge.prototype.run = function(sink, scheduler) {
	var l = this.sources.length;
	var disposables = new Array(l);
	var sinks = new Array(l);

	var mergeSink = new MergeSink(disposables, sinks, sink);

	for(var indexSink, i=0; i<l; ++i) {
		indexSink = sinks[i] = new IndexSink(i, mergeSink);
		disposables[i] = this.sources[i].run(indexSink, scheduler);
	}

	return dispose.all(disposables);
};

function MergeSink(disposables, sinks, sink) {
	this.sink = sink;
	this.disposables = disposables;
	this.activeCount = sinks.length;
}

MergeSink.prototype.error = Pipe.prototype.error;

MergeSink.prototype.event = function(t, indexValue) {
	this.sink.event(t, indexValue.value);
};

MergeSink.prototype.end = function(t, indexedValue) {
	dispose.tryDispose(t, this.disposables[indexedValue.index], this.sink);
	if(--this.activeCount === 0) {
		this.sink.end(t, indexedValue.value);
	}
};

},{"../Stream":5,"../disposable/dispose":34,"../sink/IndexSink":51,"../sink/Pipe":53,"../source/core":57,"@most/prelude":69}],19:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var dispose = require('../disposable/dispose');
var LinkedList = require('../LinkedList');
var identity = require('@most/prelude').id;

exports.mergeConcurrently = mergeConcurrently;
exports.mergeMapConcurrently = mergeMapConcurrently;

function mergeConcurrently(concurrency, stream) {
	return mergeMapConcurrently(identity, concurrency, stream);
}

function mergeMapConcurrently(f, concurrency, stream) {
	return new Stream(new MergeConcurrently(f, concurrency, stream.source));
}

function MergeConcurrently(f, concurrency, source) {
	this.f = f;
	this.concurrency = concurrency;
	this.source = source;
}

MergeConcurrently.prototype.run = function(sink, scheduler) {
	return new Outer(this.f, this.concurrency, this.source, sink, scheduler);
};

function Outer(f, concurrency, source, sink, scheduler) {
	this.f = f;
	this.concurrency = concurrency;
	this.sink = sink;
	this.scheduler = scheduler;
	this.pending = [];
	this.current = new LinkedList();
	this.disposable = dispose.once(source.run(this, scheduler));
	this.active = true;
}

Outer.prototype.event = function(t, x) {
	this._addInner(t, x);
};

Outer.prototype._addInner = function(t, x) {
	if(this.current.length < this.concurrency) {
		this._startInner(t, x);
	} else {
		this.pending.push(x);
	}
};

Outer.prototype._startInner = function(t, x) {
	try {
		this._initInner(t, x);
	} catch(e) {
		this.error(t, e);
	}
};

Outer.prototype._initInner = function(t, x) {
	var innerSink = new Inner(t, this, this.sink);
	innerSink.disposable = mapAndRun(this.f, x, innerSink, this.scheduler);
	this.current.add(innerSink);
}

function mapAndRun(f, x, sink, scheduler) {
	return f(x).source.run(sink, scheduler);
}

Outer.prototype.end = function(t, x) {
	this.active = false;
	dispose.tryDispose(t, this.disposable, this.sink);
	this._checkEnd(t, x);
};

Outer.prototype.error = function(t, e) {
	this.active = false;
	this.sink.error(t, e);
};

Outer.prototype.dispose = function() {
	this.active = false;
	this.pending.length = 0;
	return Promise.all([this.disposable.dispose(), this.current.dispose()]);
};

Outer.prototype._endInner = function(t, x, inner) {
	this.current.remove(inner);
	dispose.tryDispose(t, inner, this);

	if(this.pending.length === 0) {
		this._checkEnd(t, x);
	} else {
		this._startInner(t, this.pending.shift());
	}
};

Outer.prototype._checkEnd = function(t, x) {
	if(!this.active && this.current.isEmpty()) {
		this.sink.end(t, x);
	}
};

function Inner(time, outer, sink) {
	this.prev = this.next = null;
	this.time = time;
	this.outer = outer;
	this.sink = sink;
	this.disposable = void 0;
}

Inner.prototype.event = function(t, x) {
	this.sink.event(Math.max(t, this.time), x);
};

Inner.prototype.end = function(t, x) {
	this.outer._endInner(Math.max(t, this.time), x, this);
};

Inner.prototype.error = function(t, e) {
	this.outer.error(Math.max(t, this.time), e);
};

Inner.prototype.dispose = function() {
	return this.disposable.dispose();
};

},{"../LinkedList":2,"../Stream":5,"../disposable/dispose":34,"@most/prelude":69}],20:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var runSource = require('../runSource');

exports.observe = observe;
exports.drain = drain;

/**
 * Observe all the event values in the stream in time order. The
 * provided function `f` will be called for each event value
 * @param {function(x:T):*} f function to call with each event value
 * @param {Stream<T>} stream stream to observe
 * @return {Promise} promise that fulfills after the stream ends without
 *  an error, or rejects if the stream ends with an error.
 */
function observe(f, stream) {
	return runSource.withDefaultScheduler(f, stream.source);
}

/**
 * "Run" a stream by
 * @param stream
 * @return {*}
 */
function drain(stream) {
	return runSource.withDefaultScheduler(noop, stream.source);
}

function noop() {}

},{"../runSource":44}],21:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var fatal = require('../fatalError');
var just = require('../source/core').of;

exports.fromPromise = fromPromise;
exports.awaitPromises = awaitPromises;

/**
 * Create a stream containing only the promise's fulfillment
 * value at the time it fulfills.
 * @param {Promise<T>} p promise
 * @return {Stream<T>} stream containing promise's fulfillment value.
 *  If the promise rejects, the stream will error
 */
function fromPromise(p) {
	return awaitPromises(just(p));
}

/**
 * Turn a Stream<Promise<T>> into Stream<T> by awaiting each promise.
 * Event order is preserved.
 * @param {Stream<Promise<T>>} stream
 * @return {Stream<T>} stream of fulfillment values.  The stream will
 * error if any promise rejects.
 */
function awaitPromises(stream) {
	return new Stream(new Await(stream.source));
}

function Await(source) {
	this.source = source;
}

Await.prototype.run = function(sink, scheduler) {
	return this.source.run(new AwaitSink(sink, scheduler), scheduler);
};

function AwaitSink(sink, scheduler) {
	this.sink = sink;
	this.scheduler = scheduler;
	this.queue = Promise.resolve();
	var self = this;

	// Pre-create closures, to avoid creating them per event
	this._eventBound = function(x) {
		self.sink.event(self.scheduler.now(), x);
	};

	this._endBound = function(x) {
		self.sink.end(self.scheduler.now(), x);
	};

	this._errorBound = function(e) {
		self.sink.error(self.scheduler.now(), e);
	};
}

AwaitSink.prototype.event = function(t, promise) {
	var self = this;
	this.queue = this.queue.then(function() {
		return self._event(promise);
	}).catch(this._errorBound);
};

AwaitSink.prototype.end = function(t, x) {
	var self = this;
	this.queue = this.queue.then(function() {
		return self._end(x);
	}).catch(this._errorBound);
};

AwaitSink.prototype.error = function(t, e) {
	var self = this;
	// Don't resolve error values, propagate directly
	this.queue = this.queue.then(function() {
		return self._errorBound(e);
	}).catch(fatal);
};

AwaitSink.prototype._event = function(promise) {
	return promise.then(this._eventBound);
};

AwaitSink.prototype._end = function(x) {
	return Promise.resolve(x).then(this._endBound);
};

},{"../Stream":5,"../fatalError":35,"../source/core":57}],22:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Pipe = require('../sink/Pipe');
var dispose = require('../disposable/dispose');
var base = require('@most/prelude');
var invoke = require('../invoke');

exports.sample = sample;
exports.sampleWith = sampleWith;
exports.sampleArray = sampleArray;

/**
 * When an event arrives on sampler, emit the result of calling f with the latest
 * values of all streams being sampled
 * @param {function(...values):*} f function to apply to each set of sampled values
 * @param {Stream} sampler streams will be sampled whenever an event arrives
 *  on sampler
 * @returns {Stream} stream of sampled and transformed values
 */
function sample(f, sampler /*, ...streams */) {
	return sampleArray(f, sampler, base.drop(2, arguments));
}

/**
 * When an event arrives on sampler, emit the latest event value from stream.
 * @param {Stream} sampler stream of events at whose arrival time
 *  stream's latest value will be propagated
 * @param {Stream} stream stream of values
 * @returns {Stream} sampled stream of values
 */
function sampleWith(sampler, stream) {
	return new Stream(new Sampler(base.id, sampler.source, [stream.source]));
}

function sampleArray(f, sampler, streams) {
	return new Stream(new Sampler(f, sampler.source, base.map(getSource, streams)));
}

function getSource(stream) {
	return stream.source;
}

function Sampler(f, sampler, sources) {
	this.f = f;
	this.sampler = sampler;
	this.sources = sources;
}

Sampler.prototype.run = function(sink, scheduler) {
	var l = this.sources.length;
	var disposables = new Array(l+1);
	var sinks = new Array(l);

	var sampleSink = new SampleSink(this.f, sinks, sink);

	for(var hold, i=0; i<l; ++i) {
		hold = sinks[i] = new Hold(sampleSink);
		disposables[i] = this.sources[i].run(hold, scheduler);
	}

	disposables[i] = this.sampler.run(sampleSink, scheduler);

	return dispose.all(disposables);
};

function Hold(sink) {
	this.sink = sink;
	this.hasValue = false;
}

Hold.prototype.event = function(t, x) {
	this.value = x;
	this.hasValue = true;
	this.sink._notify(this);
};

Hold.prototype.end = function () {};
Hold.prototype.error = Pipe.prototype.error;

function SampleSink(f, sinks, sink) {
	this.f = f;
	this.sinks = sinks;
	this.sink = sink;
	this.active = false;
}

SampleSink.prototype._notify = function() {
	if(!this.active) {
		this.active = this.sinks.every(hasValue);
	}
};

SampleSink.prototype.event = function(t) {
	if(this.active) {
		this.sink.event(t, invoke(this.f, base.map(getValue, this.sinks)));
	}
};

SampleSink.prototype.end = Pipe.prototype.end;
SampleSink.prototype.error = Pipe.prototype.error;

function hasValue(hold) {
	return hold.hasValue;
}

function getValue(hold) {
	return hold.value;
}

},{"../Stream":5,"../disposable/dispose":34,"../invoke":39,"../sink/Pipe":53,"@most/prelude":69}],23:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Sink = require('../sink/Pipe');
var core = require('../source/core');
var dispose = require('../disposable/dispose');
var Map = require('../fusion/Map');

exports.take = take;
exports.skip = skip;
exports.slice = slice;
exports.takeWhile = takeWhile;
exports.skipWhile = skipWhile;

/**
 * @param {number} n
 * @param {Stream} stream
 * @returns {Stream} new stream containing only up to the first n items from stream
 */
function take(n, stream) {
	return slice(0, n, stream);
}

/**
 * @param {number} n
 * @param {Stream} stream
 * @returns {Stream} new stream with the first n items removed
 */
function skip(n, stream) {
	return slice(n, Infinity, stream);
}

/**
 * Slice a stream by index. Negative start/end indexes are not supported
 * @param {number} start
 * @param {number} end
 * @param {Stream} stream
 * @returns {Stream} stream containing items where start <= index < end
 */
function slice(start, end, stream) {
	return end <= start ? core.empty()
		: new Stream(sliceSource(start, end, stream.source));
}

function sliceSource(start, end, source) {
	return source instanceof Map ? commuteMapSlice(start, end, source)
		: source instanceof Slice ? fuseSlice(start, end, source)
		: new Slice(start, end, source);
}

function commuteMapSlice(start, end, source) {
	return Map.create(source.f, sliceSource(start, end, source.source))
}

function fuseSlice(start, end, source) {
	start += source.min;
	end = Math.min(end + source.min, source.max);
	return new Slice(start, end, source.source);
}

function Slice(min, max, source) {
	this.source = source;
	this.min = min;
	this.max = max;
}

Slice.prototype.run = function(sink, scheduler) {
	return new SliceSink(this.min, this.max - this.min, this.source, sink, scheduler);
};

function SliceSink(skip, take, source, sink, scheduler) {
	this.sink = sink;
	this.skip = skip;
	this.take = take;
	this.disposable = dispose.once(source.run(this, scheduler));
}

SliceSink.prototype.end   = Sink.prototype.end;
SliceSink.prototype.error = Sink.prototype.error;

SliceSink.prototype.event = function(t, x) {
	if(this.skip > 0) {
		this.skip -= 1;
		return;
	}

	if(this.take === 0) {
		return;
	}

	this.take -= 1;
	this.sink.event(t, x);
	if(this.take === 0) {
		this.dispose();
		this.sink.end(t, x);
	}
};

SliceSink.prototype.dispose = function() {
	return this.disposable.dispose();
};

function takeWhile(p, stream) {
	return new Stream(new TakeWhile(p, stream.source));
}

function TakeWhile(p, source) {
	this.p = p;
	this.source = source;
}

TakeWhile.prototype.run = function(sink, scheduler) {
	return new TakeWhileSink(this.p, this.source, sink, scheduler);
};

function TakeWhileSink(p, source, sink, scheduler) {
	this.p = p;
	this.sink = sink;
	this.active = true;
	this.disposable = dispose.once(source.run(this, scheduler));
}

TakeWhileSink.prototype.end   = Sink.prototype.end;
TakeWhileSink.prototype.error = Sink.prototype.error;

TakeWhileSink.prototype.event = function(t, x) {
	if(!this.active) {
		return;
	}

	var p = this.p;
	this.active = p(x);
	if(this.active) {
		this.sink.event(t, x);
	} else {
		this.dispose();
		this.sink.end(t, x);
	}
};

TakeWhileSink.prototype.dispose = function() {
	return this.disposable.dispose();
};

function skipWhile(p, stream) {
	return new Stream(new SkipWhile(p, stream.source));
}

function SkipWhile(p, source) {
	this.p = p;
	this.source = source;
}

SkipWhile.prototype.run = function(sink, scheduler) {
	return this.source.run(new SkipWhileSink(this.p, sink), scheduler);
};

function SkipWhileSink(p, sink) {
	this.p = p;
	this.sink = sink;
	this.skipping = true;
}

SkipWhileSink.prototype.end   = Sink.prototype.end;
SkipWhileSink.prototype.error = Sink.prototype.error;

SkipWhileSink.prototype.event = function(t, x) {
	if(this.skipping) {
		var p = this.p;
		this.skipping = p(x);
		if(this.skipping) {
			return;
		}
	}

	this.sink.event(t, x);
};

},{"../Stream":5,"../disposable/dispose":34,"../fusion/Map":38,"../sink/Pipe":53,"../source/core":57}],24:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var dispose = require('../disposable/dispose');

exports.switch = switchLatest;

/**
 * Given a stream of streams, return a new stream that adopts the behavior
 * of the most recent inner stream.
 * @param {Stream} stream of streams on which to switch
 * @returns {Stream} switching stream
 */
function switchLatest(stream) {
	return new Stream(new Switch(stream.source));
}

function Switch(source) {
	this.source = source;
}

Switch.prototype.run = function(sink, scheduler) {
	var switchSink = new SwitchSink(sink, scheduler);
	return dispose.all(switchSink, this.source.run(switchSink, scheduler));
};

function SwitchSink(sink, scheduler) {
	this.sink = sink;
	this.scheduler = scheduler;
	this.current = null;
	this.ended = false;
}

SwitchSink.prototype.event = function(t, stream) {
	this._disposeCurrent(t); // TODO: capture the result of this dispose
	this.current = new Segment(t, Infinity, this, this.sink);
	this.current.disposable = stream.source.run(this.current, this.scheduler);
};

SwitchSink.prototype.end = function(t, x) {
	this.ended = true;
	this._checkEnd(t, x);
};

SwitchSink.prototype.error = function(t, e) {
	this.ended = true;
	this.sink.error(t, e);
};

SwitchSink.prototype.dispose = function() {
	return this._disposeCurrent(0);
};

SwitchSink.prototype._disposeCurrent = function(t) {
	if(this.current !== null) {
		return this.current._dispose(t);
	}
};

SwitchSink.prototype._disposeInner = function(t, inner) {
	inner._dispose(t); // TODO: capture the result of this dispose
	if(inner === this.current) {
		this.current = null;
	}
};

SwitchSink.prototype._checkEnd = function(t, x) {
	if(this.ended && this.current === null) {
		this.sink.end(t, x);
	}
};

SwitchSink.prototype._endInner = function(t, x, inner) {
	this._disposeInner(t, inner);
	this._checkEnd(t, x);
};

SwitchSink.prototype._errorInner = function(t, e, inner) {
	this._disposeInner(t, inner);
	this.sink.error(t, e);
};

function Segment(min, max, outer, sink) {
	this.min = min;
	this.max = max;
	this.outer = outer;
	this.sink = sink;
	this.disposable = dispose.empty();
}

Segment.prototype.event = function(t, x) {
	if(t < this.max) {
		this.sink.event(Math.max(t, this.min), x);
	}
};

Segment.prototype.end = function(t, x) {
	this.outer._endInner(Math.max(t, this.min), x, this);
};

Segment.prototype.error = function(t, e) {
	this.outer._errorInner(Math.max(t, this.min), e, this);
};

Segment.prototype._dispose = function(t) {
	this.max = t;
	dispose.tryDispose(t, this.disposable, this.sink)
};

},{"../Stream":5,"../disposable/dispose":34}],25:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

exports.thru = function thru(f, stream) {
	return f(stream);
}

},{}],26:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Pipe = require('../sink/Pipe');
var dispose = require('../disposable/dispose');
var join = require('../combinator/flatMap').join;

exports.during    = during;
exports.takeUntil = takeUntil;
exports.skipUntil = skipUntil;

function takeUntil(signal, stream) {
	return new Stream(new Until(signal.source, stream.source));
}

function skipUntil(signal, stream) {
	return new Stream(new Since(signal.source, stream.source));
}

function during(timeWindow, stream) {
	return takeUntil(join(timeWindow), skipUntil(timeWindow, stream));
}

function Until(maxSignal, source) {
	this.maxSignal = maxSignal;
	this.source = source;
}

Until.prototype.run = function(sink, scheduler) {
	var min = new Bound(-Infinity, sink);
	var max = new UpperBound(this.maxSignal, sink, scheduler);
	var disposable = this.source.run(new TimeWindowSink(min, max, sink), scheduler);

	return dispose.all([min, max, disposable]);
};

function Since(minSignal, source) {
	this.minSignal = minSignal;
	this.source = source;
}

Since.prototype.run = function(sink, scheduler) {
	var min = new LowerBound(this.minSignal, sink, scheduler);
	var max = new Bound(Infinity, sink);
	var disposable = this.source.run(new TimeWindowSink(min, max, sink), scheduler);

	return dispose.all([min, max, disposable]);
};

function Bound(value, sink) {
	this.value = value;
	this.sink = sink;
}

Bound.prototype.error = Pipe.prototype.error;
Bound.prototype.event = noop;
Bound.prototype.end = noop;
Bound.prototype.dispose = noop;

function TimeWindowSink(min, max, sink) {
	this.min = min;
	this.max = max;
	this.sink = sink;
}

TimeWindowSink.prototype.event = function(t, x) {
	if(t >= this.min.value && t < this.max.value) {
		this.sink.event(t, x);
	}
};

TimeWindowSink.prototype.error = Pipe.prototype.error;
TimeWindowSink.prototype.end = Pipe.prototype.end;

function LowerBound(signal, sink, scheduler) {
	this.value = Infinity;
	this.sink = sink;
	this.disposable = signal.run(this, scheduler);
}

LowerBound.prototype.event = function(t /*, x */) {
	if(t < this.value) {
		this.value = t;
	}
};

LowerBound.prototype.end = noop;
LowerBound.prototype.error = Pipe.prototype.error;

LowerBound.prototype.dispose = function() {
	return this.disposable.dispose();
};

function UpperBound(signal, sink, scheduler) {
	this.value = Infinity;
	this.sink = sink;
	this.disposable = signal.run(this, scheduler);
}

UpperBound.prototype.event = function(t, x) {
	if(t < this.value) {
		this.value = t;
		this.sink.end(t, x);
	}
};

UpperBound.prototype.end = noop;
UpperBound.prototype.error = Pipe.prototype.error;

UpperBound.prototype.dispose = function() {
	return this.disposable.dispose();
};

function noop() {}

},{"../Stream":5,"../combinator/flatMap":15,"../disposable/dispose":34,"../sink/Pipe":53}],27:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Sink = require('../sink/Pipe');

exports.timestamp = timestamp;

function timestamp(stream) {
	return new Stream(new Timestamp(stream.source));
}

function Timestamp(source) {
	this.source = source;
}

Timestamp.prototype.run = function(sink, scheduler) {
	return this.source.run(new TimestampSink(sink), scheduler);
};

function TimestampSink(sink) {
	this.sink = sink;
}

TimestampSink.prototype.end   = Sink.prototype.end;
TimestampSink.prototype.error = Sink.prototype.error;

TimestampSink.prototype.event = function(t, x) {
	this.sink.event(t, { time: t, value: x });
};

},{"../Stream":5,"../sink/Pipe":53}],28:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');

exports.transduce = transduce;

/**
 * Transform a stream by passing its events through a transducer.
 * @param  {function} transducer transducer function
 * @param  {Stream} stream stream whose events will be passed through the
 *  transducer
 * @return {Stream} stream of events transformed by the transducer
 */
function transduce(transducer, stream) {
	return new Stream(new Transduce(transducer, stream.source));
}

function Transduce(transducer, source) {
	this.transducer = transducer;
	this.source = source;
}

Transduce.prototype.run = function(sink, scheduler) {
	var xf = this.transducer(new Transformer(sink));
	return this.source.run(new TransduceSink(getTxHandler(xf), sink), scheduler);
};

function TransduceSink(adapter, sink) {
	this.xf = adapter;
	this.sink = sink;
}

TransduceSink.prototype.event = function(t, x) {
	var next = this.xf.step(t, x);

	return this.xf.isReduced(next)
		? this.sink.end(t, this.xf.getResult(next))
		: next;
};

TransduceSink.prototype.end = function(t, x) {
	return this.xf.result(x);
};

TransduceSink.prototype.error = function(t, e) {
	return this.sink.error(t, e);
};

function Transformer(sink) {
	this.time = -Infinity;
	this.sink = sink;
}

Transformer.prototype['@@transducer/init'] = Transformer.prototype.init = function() {};

Transformer.prototype['@@transducer/step'] = Transformer.prototype.step = function(t, x) {
	if(!isNaN(t)) {
		this.time = Math.max(t, this.time);
	}
	return this.sink.event(this.time, x);
};

Transformer.prototype['@@transducer/result'] = Transformer.prototype.result = function(x) {
	return this.sink.end(this.time, x);
};

/**
 * Given an object supporting the new or legacy transducer protocol,
 * create an adapter for it.
 * @param {object} tx transform
 * @returns {TxAdapter|LegacyTxAdapter}
 */
function getTxHandler(tx) {
	return typeof tx['@@transducer/step'] === 'function'
		? new TxAdapter(tx)
		: new LegacyTxAdapter(tx);
}

/**
 * Adapter for new official transducer protocol
 * @param {object} tx transform
 * @constructor
 */
function TxAdapter(tx) {
	this.tx = tx;
}

TxAdapter.prototype.step = function(t, x) {
	return this.tx['@@transducer/step'](t, x);
};
TxAdapter.prototype.result = function(x) {
	return this.tx['@@transducer/result'](x);
};
TxAdapter.prototype.isReduced = function(x) {
	return x != null && x['@@transducer/reduced'];
};
TxAdapter.prototype.getResult = function(x) {
	return x['@@transducer/value'];
};

/**
 * Adapter for older transducer protocol
 * @param {object} tx transform
 * @constructor
 */
function LegacyTxAdapter(tx) {
	this.tx = tx;
}

LegacyTxAdapter.prototype.step = function(t, x) {
	return this.tx.step(t, x);
};
LegacyTxAdapter.prototype.result = function(x) {
	return this.tx.result(x);
};
LegacyTxAdapter.prototype.isReduced = function(x) {
	return x != null && x.__transducers_reduced__;
};
LegacyTxAdapter.prototype.getResult = function(x) {
	return x.value;
};

},{"../Stream":5}],29:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var Map = require('../fusion/Map');

exports.map = map;
exports.constant = constant;
exports.tap = tap;

/**
 * Transform each value in the stream by applying f to each
 * @param {function(*):*} f mapping function
 * @param {Stream} stream stream to map
 * @returns {Stream} stream containing items transformed by f
 */
function map(f, stream) {
	return new Stream(Map.create(f, stream.source));
}

/**
 * Replace each value in the stream with x
 * @param {*} x
 * @param {Stream} stream
 * @returns {Stream} stream containing items replaced with x
 */
function constant(x, stream) {
	return map(function() {
		return x;
	}, stream);
}

/**
 * Perform a side effect for each item in the stream
 * @param {function(x:*):*} f side effect to execute for each item. The
 *  return value will be discarded.
 * @param {Stream} stream stream to tap
 * @returns {Stream} new stream containing the same items as this stream
 */
function tap(f, stream) {
	return map(function(x) {
		f(x);
		return x;
	}, stream);
}

},{"../Stream":5,"../fusion/Map":38}],30:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var transform = require('./transform');
var core = require('../source/core');
var Sink = require('../sink/Pipe');
var IndexSink = require('../sink/IndexSink');
var dispose = require('../disposable/dispose');
var base = require('@most/prelude');
var invoke = require('../invoke');
var Queue = require('../Queue');

var map = base.map;
var tail = base.tail;

exports.zip = zip;
exports.zipArray = zipArray;

/**
 * Combine streams pairwise (or tuple-wise) by index by applying f to values
 * at corresponding indices.  The returned stream ends when any of the input
 * streams ends.
 * @param {function} f function to combine values
 * @returns {Stream} new stream with items at corresponding indices combined
 *  using f
 */
function zip(f /*,...streams */) {
	return zipArray(f, tail(arguments));
}

/**
 * Combine streams pairwise (or tuple-wise) by index by applying f to values
 * at corresponding indices.  The returned stream ends when any of the input
 * streams ends.
 * @param {function} f function to combine values
 * @param {[Stream]} streams streams to zip using f
 * @returns {Stream} new stream with items at corresponding indices combined
 *  using f
 */
function zipArray(f, streams) {
	return streams.length === 0 ? core.empty()
		 : streams.length === 1 ? transform.map(f, streams[0])
		 : new Stream(new Zip(f, map(getSource, streams)));
}

function getSource(stream) {
	return stream.source;
}

function Zip(f, sources) {
	this.f = f;
	this.sources = sources;
}

Zip.prototype.run = function(sink, scheduler) {
	var l = this.sources.length;
	var disposables = new Array(l);
	var sinks = new Array(l);
	var buffers = new Array(l);

	var zipSink = new ZipSink(this.f, buffers, sinks, sink);

	for(var indexSink, i=0; i<l; ++i) {
		buffers[i] = new Queue();
		indexSink = sinks[i] = new IndexSink(i, zipSink);
		disposables[i] = this.sources[i].run(indexSink, scheduler);
	}

	return dispose.all(disposables);
};

function ZipSink(f, buffers, sinks, sink) {
	this.f = f;
	this.sinks = sinks;
	this.sink = sink;
	this.buffers = buffers;
}

ZipSink.prototype.event = function(t, indexedValue) {
	var buffers = this.buffers;
	var buffer = buffers[indexedValue.index];

	buffer.push(indexedValue.value);

	if(buffer.length() === 1) {
		if(!ready(this.buffers)) {
			return;
		}

		emitZipped(this.f, t, buffers, this.sink);

		if (ended(this.buffers, this.sinks)) {
			this.sink.end(t, void 0);
		}
	}
};

ZipSink.prototype.end = function(t, indexedValue) {
	var buffer = this.buffers[indexedValue.index];
	if(buffer.isEmpty()) {
		this.sink.end(t, indexedValue.value);
	}
};

ZipSink.prototype.error = Sink.prototype.error;

function emitZipped (f, t, buffers, sink) {
	sink.event(t, invoke(f, map(head, buffers)));
}

function head(buffer) {
	return buffer.shift();
}

function ended(buffers, sinks) {
	for(var i=0, l=buffers.length; i<l; ++i) {
		if(buffers[i].isEmpty() && !sinks[i].active) {
			return true;
		}
	}
	return false;
}

function ready(buffers) {
	for(var i=0, l=buffers.length; i<l; ++i) {
		if(buffers[i].isEmpty()) {
			return false;
		}
	}
	return true;
}

},{"../Queue":4,"../Stream":5,"../disposable/dispose":34,"../invoke":39,"../sink/IndexSink":51,"../sink/Pipe":53,"../source/core":57,"./transform":29,"@most/prelude":69}],31:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = defer;

function defer(task) {
	return Promise.resolve(task).then(runTask);
}

function runTask(task) {
	try {
		return task.run();
	} catch(e) {
		return task.error(e);
	}
}

},{}],32:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = Disposable;

/**
 * Create a new Disposable which will dispose its underlying resource.
 * @param {function} dispose function
 * @param {*?} data any data to be passed to disposer function
 * @constructor
 */
function Disposable(dispose, data) {
	this._dispose = dispose;
	this._data = data;
}

Disposable.prototype.dispose = function() {
	return this._dispose(this._data);
};

},{}],33:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = SettableDisposable;

function SettableDisposable() {
	this.disposable = void 0;
	this.disposed = false;
	this._resolve = void 0;

	var self = this;
	this.result = new Promise(function(resolve) {
		self._resolve = resolve;
	});
}

SettableDisposable.prototype.setDisposable = function(disposable) {
	if(this.disposable !== void 0) {
		throw new Error('setDisposable called more than once');
	}

	this.disposable = disposable;

	if(this.disposed) {
		this._resolve(disposable.dispose());
	}
};

SettableDisposable.prototype.dispose = function() {
	if(this.disposed) {
		return this.result;
	}

	this.disposed = true;

	if(this.disposable !== void 0) {
		this.result = this.disposable.dispose();
	}

	return this.result;
};

},{}],34:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Disposable = require('./Disposable');
var SettableDisposable = require('./SettableDisposable');
var isPromise = require('../Promise').isPromise;
var base = require('@most/prelude');

var map = base.map;
var identity = base.id;

exports.tryDispose = tryDispose;
exports.create = create;
exports.once = once;
exports.empty = empty;
exports.all = all;
exports.settable = settable;
exports.promised = promised;

/**
 * Call disposable.dispose.  If it returns a promise, catch promise
 * error and forward it through the provided sink.
 * @param {number} t time
 * @param {{dispose: function}} disposable
 * @param {{error: function}} sink
 * @return {*} result of disposable.dispose
 */
function tryDispose(t, disposable, sink) {
	var result = disposeSafely(disposable);
	return isPromise(result)
		? result.catch(function (e) {
			sink.error(t, e);
		})
		: result;
}

/**
 * Create a new Disposable which will dispose its underlying resource
 * at most once.
 * @param {function} dispose function
 * @param {*?} data any data to be passed to disposer function
 * @return {Disposable}
 */
function create(dispose, data) {
	return once(new Disposable(dispose, data));
}

/**
 * Create a noop disposable. Can be used to satisfy a Disposable
 * requirement when no actual resource needs to be disposed.
 * @return {Disposable|exports|module.exports}
 */
function empty() {
	return new Disposable(identity, void 0);
}

/**
 * Create a disposable that will dispose all input disposables in parallel.
 * @param {Array<Disposable>} disposables
 * @return {Disposable}
 */
function all(disposables) {
	return create(disposeAll, disposables);
}

function disposeAll(disposables) {
	return Promise.all(map(disposeSafely, disposables));
}

function disposeSafely(disposable) {
	try {
		return disposable.dispose();
	} catch(e) {
		return Promise.reject(e);
	}
}

/**
 * Create a disposable from a promise for another disposable
 * @param {Promise<Disposable>} disposablePromise
 * @return {Disposable}
 */
function promised(disposablePromise) {
	return create(disposePromise, disposablePromise);
}

function disposePromise(disposablePromise) {
	return disposablePromise.then(disposeOne);
}

function disposeOne(disposable) {
	return disposable.dispose();
}

/**
 * Create a disposable proxy that allows its underlying disposable to
 * be set later.
 * @return {SettableDisposable}
 */
function settable() {
	return new SettableDisposable();
}

/**
 * Wrap an existing disposable (which may not already have been once()d)
 * so that it will only dispose its underlying resource at most once.
 * @param {{ dispose: function() }} disposable
 * @return {Disposable} wrapped disposable
 */
function once(disposable) {
	return new Disposable(disposeMemoized, memoized(disposable));
}

function disposeMemoized(memoized) {
	if(!memoized.disposed) {
		memoized.disposed = true;
		memoized.value = disposeSafely(memoized.disposable);
		memoized.disposable = void 0;
	}

	return memoized.value;
}

function memoized(disposable) {
	return { disposed: false, disposable: disposable, value: void 0 };
}

},{"../Promise":3,"./Disposable":32,"./SettableDisposable":33,"@most/prelude":69}],35:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = fatalError;

function fatalError (e) {
	setTimeout(function() {
		throw e;
	}, 0);
}

},{}],36:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Pipe = require('../sink/Pipe');

module.exports = Filter;

function Filter(p, source) {
	this.p = p;
	this.source = source;
}

/**
 * Create a filtered source, fusing adjacent filter.filter if possible
 * @param {function(x:*):boolean} p filtering predicate
 * @param {{run:function}} source source to filter
 * @returns {Filter} filtered source
 */
Filter.create = function createFilter(p, source) {
	if (source instanceof Filter) {
		return new Filter(and(source.p, p), source.source);
	}

	return new Filter(p, source);
};

Filter.prototype.run = function(sink, scheduler) {
	return this.source.run(new FilterSink(this.p, sink), scheduler);
};

function FilterSink(p, sink) {
	this.p = p;
	this.sink = sink;
}

FilterSink.prototype.end   = Pipe.prototype.end;
FilterSink.prototype.error = Pipe.prototype.error;

FilterSink.prototype.event = function(t, x) {
	var p = this.p;
	p(x) && this.sink.event(t, x);
};

function and(p, q) {
	return function(x) {
		return p(x) && q(x);
	};
}

},{"../sink/Pipe":53}],37:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Pipe = require('../sink/Pipe');

module.exports = FilterMap;

function FilterMap(p, f, source) {
	this.p = p;
	this.f = f;
	this.source = source;
}

FilterMap.prototype.run = function(sink, scheduler) {
	return this.source.run(new FilterMapSink(this.p, this.f, sink), scheduler);
};

function FilterMapSink(p, f, sink) {
	this.p = p;
	this.f = f;
	this.sink = sink;
}

FilterMapSink.prototype.event = function(t, x) {
	var f = this.f;
	var p = this.p;
	p(x) && this.sink.event(t, f(x));
};

FilterMapSink.prototype.end = Pipe.prototype.end;
FilterMapSink.prototype.error = Pipe.prototype.error;

},{"../sink/Pipe":53}],38:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Pipe = require('../sink/Pipe');
var Filter = require('./Filter');
var FilterMap = require('./FilterMap');
var base = require('@most/prelude');

module.exports = Map;

function Map(f, source) {
	this.f = f;
	this.source = source;
}

/**
 * Create a mapped source, fusing adjacent map.map, filter.map,
 * and filter.map.map if possible
 * @param {function(*):*} f mapping function
 * @param {{run:function}} source source to map
 * @returns {Map|FilterMap} mapped source, possibly fused
 */
Map.create = function createMap(f, source) {
	if(source instanceof Map) {
		return new Map(base.compose(f, source.f), source.source);
	}

	if(source instanceof Filter) {
		return new FilterMap(source.p, f, source.source);
	}

	return new Map(f, source);
};

Map.prototype.run = function(sink, scheduler) {
	return this.source.run(new MapSink(this.f, sink), scheduler);
};

function MapSink(f, sink) {
	this.f = f;
	this.sink = sink;
}

MapSink.prototype.end   = Pipe.prototype.end;
MapSink.prototype.error = Pipe.prototype.error;

MapSink.prototype.event = function(t, x) {
	var f = this.f;
	this.sink.event(t, f(x));
};

},{"../sink/Pipe":53,"./Filter":36,"./FilterMap":37,"@most/prelude":69}],39:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = invoke;

function invoke(f, args) {
	/*eslint complexity: [2,7]*/
	switch(args.length) {
		case 0: return f();
		case 1: return f(args[0]);
		case 2: return f(args[0], args[1]);
		case 3: return f(args[0], args[1], args[2]);
		case 4: return f(args[0], args[1], args[2], args[3]);
		case 5: return f(args[0], args[1], args[2], args[3], args[4]);
		default:
			return f.apply(void 0, args);
	}
}

},{}],40:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

exports.isIterable = isIterable;
exports.getIterator = getIterator;
exports.makeIterable = makeIterable;

/*global Set, Symbol*/
var iteratorSymbol;
// Firefox ships a partial implementation using the name @@iterator.
// https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14
if (typeof Set === 'function' && typeof new Set()['@@iterator'] === 'function') {
	iteratorSymbol = '@@iterator';
} else {
	iteratorSymbol = typeof Symbol === 'function' && Symbol.iterator ||
	'_es6shim_iterator_';
}

function isIterable(o) {
	return typeof o[iteratorSymbol] === 'function';
}

function getIterator(o) {
	return o[iteratorSymbol]();
}

function makeIterable(f, o) {
	o[iteratorSymbol] = f;
	return o;
}

},{}],41:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var dispose = require('../disposable/dispose');

exports.fromObservable = fromObservable;
exports.ObservableSource = ObservableSource;
exports.SubscriberSink = SubscriberSink;

function fromObservable(observable) {
	return new Stream(new ObservableSource(observable));
}

function ObservableSource(observable) {
	this.observable = observable;
}

ObservableSource.prototype.run = function(sink, scheduler) {
	var sub = this.observable.subscribe(new SubscriberSink(sink, scheduler));
	if(typeof sub === 'function') {
		return dispose.create(sub);
	} else if(sub && typeof sub.unsubscribe === 'function') {
		return dispose.create(unsubscribe, sub);
	}

	throw new TypeError('Observable returned invalid subscription ' + String(sub));
}

function SubscriberSink(sink, scheduler) {
	this.sink = sink;
	this.scheduler = scheduler;
}

SubscriberSink.prototype.next = function(x) {
	this.sink.event(this.scheduler.now(), x);
}

SubscriberSink.prototype.complete = function(x) {
	this.sink.end(this.scheduler.now(), x);
}

SubscriberSink.prototype.error = function(e) {
	this.sink.error(this.scheduler.now(), e);
}

function unsubscribe(subscription) {
	return subscription.unsubscribe();
}

},{"../Stream":5,"../disposable/dispose":34}],42:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var symbolObservable = require('symbol-observable');

module.exports = getObservable;

function getObservable(o) {
	var obs = null;
	if(o != null && typeof o === 'object') {
		var method = o[symbolObservable];
		if(typeof method === 'function') {
			obs = method.call(o);
			if(obs == null || typeof obs !== 'object') {
				throw new TypeError('invalid observable ' + obs);
			}
		}
	}

	return obs;
}

},{"symbol-observable":70}],43:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var defaultScheduler = require('../scheduler/defaultScheduler');
var dispose = require('../disposable/dispose');
var fatalError = require('../fatalError');

exports.subscribe = subscribe;
exports.SubscribeObserver = SubscribeObserver;
exports.Subscription = Subscription;

function subscribe(subscriber, stream) {
	if(subscriber == null || typeof subscriber !== 'object') {
		throw new TypeError('subscriber must be an object');
	}

	var disposable = dispose.settable();
	var observer = new SubscribeObserver(fatalError, subscriber, disposable);

	disposable.setDisposable(stream.source.run(observer, defaultScheduler));

	return new Subscription(disposable);
}

function SubscribeObserver(fatalError, subscriber, disposable) {
	this.fatalError = fatalError;
	this.subscriber = subscriber;
	this.disposable = disposable;
}

SubscribeObserver.prototype.event = function(t, x) {
	if(typeof this.subscriber.next === 'function') {
		this.subscriber.next(x);
	}
};

SubscribeObserver.prototype.end = function(t, x) {
	var s = this.subscriber;
	doDispose(this.fatalError, s, s.complete, s.error, this.disposable, x);
};

SubscribeObserver.prototype.error = function(t, e) {
	var s = this.subscriber;
	doDispose(this.fatalError, s, s.error, s.error, this.disposable, e);
};

function Subscription(disposable) {
	this.disposable = disposable;
}

Subscription.prototype.unsubscribe = function() {
	this.disposable.dispose();
}

function doDispose(fatal, subscriber, complete, error, disposable, x) {
	Promise.resolve(disposable.dispose()).then(function () {
		if(typeof complete === 'function') {
			complete.call(subscriber, x);
		}
	}).catch(function(e) {
		if(typeof error === 'function') {
			error.call(subscriber, e);
		}
	}).catch(fatal);
}

},{"../disposable/dispose":34,"../fatalError":35,"../scheduler/defaultScheduler":47}],44:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Observer = require('./sink/Observer');
var dispose = require('./disposable/dispose');
var defaultScheduler = require('./scheduler/defaultScheduler');

exports.withDefaultScheduler = withDefaultScheduler;
exports.withScheduler = withScheduler;

function withDefaultScheduler(f, source) {
	return withScheduler(f, source, defaultScheduler);
}

function withScheduler(f, source, scheduler) {
	return new Promise(function (resolve, reject) {
		runSource(f, source, scheduler, resolve, reject);
	});
}

function runSource(f, source, scheduler, resolve, reject) {
	var disposable = dispose.settable();
	var observer = new Observer(f, resolve, reject, disposable);

	disposable.setDisposable(source.run(observer, scheduler));
}

},{"./disposable/dispose":34,"./scheduler/defaultScheduler":47,"./sink/Observer":52}],45:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var fatal = require('../fatalError');

module.exports = PropagateTask;

function PropagateTask(run, value, sink) {
	this._run = run;
	this.value = value;
	this.sink = sink;
	this.active = true;
}

PropagateTask.event = function(value, sink) {
	return new PropagateTask(emit, value, sink);
};

PropagateTask.end = function(value, sink) {
	return new PropagateTask(end, value, sink);
};

PropagateTask.error = function(value, sink) {
	return new PropagateTask(error, value, sink);
};

PropagateTask.prototype.dispose = function() {
	this.active = false;
};

PropagateTask.prototype.run = function(t) {
	if(!this.active) {
		return;
	}
	this._run(t, this.value, this.sink);
};

PropagateTask.prototype.error = function(t, e) {
	if(!this.active) {
		return fatal(e);
	}
	this.sink.error(t, e);
};

function error(t, e, sink) {
	sink.error(t, e);
}

function emit(t, x, sink) {
	sink.event(t, x);
}

function end(t, x, sink) {
	sink.end(t, x);
}

},{"../fatalError":35}],46:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var base = require('@most/prelude');

module.exports = Scheduler;

function ScheduledTask(delay, period, task, scheduler) {
	this.time = delay;
	this.period = period;
	this.task = task;
	this.scheduler = scheduler;
	this.active = true;
}

ScheduledTask.prototype.run = function() {
	return this.task.run(this.time);
};

ScheduledTask.prototype.error = function(e) {
	return this.task.error(this.time, e);
};

ScheduledTask.prototype.dispose = function() {
	this.scheduler.cancel(this);
	return this.task.dispose();
};

function runTask(task) {
	try {
		return task.run();
	} catch(e) {
		return task.error(e);
	}
}

function Scheduler(timer) {
	this.timer = timer;

	this._timer = null;
	this._nextArrival = 0;
	this._tasks = [];

	var self = this;
	this._runReadyTasksBound = function() {
		self._runReadyTasks(self.now());
	};
}

Scheduler.prototype.now = function() {
	return this.timer.now();
};

Scheduler.prototype.asap = function(task) {
	return this.schedule(0, -1, task);
};

Scheduler.prototype.delay = function(delay, task) {
	return this.schedule(delay, -1, task);
};

Scheduler.prototype.periodic = function(period, task) {
	return this.schedule(0, period, task);
};

Scheduler.prototype.schedule = function(delay, period, task) {
	var now = this.now();
	var st = new ScheduledTask(now + Math.max(0, delay), period, task, this);

	insertByTime(st, this._tasks);
	this._scheduleNextRun(now);
	return st;
};

Scheduler.prototype.cancel = function(task) {
	task.active = false;
	var i = binarySearch(task.time, this._tasks);

	if(i >= 0 && i < this._tasks.length) {
		var at = base.findIndex(task, this._tasks[i].events);
		if(at >= 0) {
			this._tasks[i].events.splice(at, 1);
			this._reschedule();
		}
	}
};

Scheduler.prototype.cancelAll = function(f) {
	for(var i=0; i<this._tasks.length; ++i) {
		removeAllFrom(f, this._tasks[i]);
	}
	this._reschedule();
};

function removeAllFrom(f, timeslot) {
	timeslot.events = base.removeAll(f, timeslot.events);
}

Scheduler.prototype._reschedule = function() {
	if(this._tasks.length === 0) {
		this._unschedule();
	} else {
		this._scheduleNextRun(this.now());
	}
};

Scheduler.prototype._unschedule = function() {
	this.timer.clearTimer(this._timer);
	this._timer = null;
};

Scheduler.prototype._scheduleNextRun = function(now) {
	if(this._tasks.length === 0) {
		return;
	}

	var nextArrival = this._tasks[0].time;

	if(this._timer === null) {
		this._scheduleNextArrival(nextArrival, now);
	} else if(nextArrival < this._nextArrival) {
		this._unschedule();
		this._scheduleNextArrival(nextArrival, now);
	}
};

Scheduler.prototype._scheduleNextArrival = function(nextArrival, now) {
	this._nextArrival = nextArrival;
	var delay = Math.max(0, nextArrival - now);
	this._timer = this.timer.setTimer(this._runReadyTasksBound, delay);
};


Scheduler.prototype._runReadyTasks = function(now) {
	this._timer = null;

	this._tasks = this._findAndRunTasks(now);

	this._scheduleNextRun(this.now());
};

Scheduler.prototype._findAndRunTasks = function(now) {
	var tasks = this._tasks;
	var l = tasks.length;
	var i = 0;

	while(i < l && tasks[i].time <= now) {
		++i;
	}

	this._tasks = tasks.slice(i);

	// Run all ready tasks
	for (var j = 0; j < i; ++j) {
		this._tasks = runTasks(tasks[j], this._tasks);
	}
	return this._tasks;
};

function runTasks(timeslot, tasks) {
	var events = timeslot.events;
	for(var i=0; i<events.length; ++i) {
		var task = events[i];

		if(task.active) {
			runTask(task);

			// Reschedule periodic repeating tasks
			// Check active again, since a task may have canceled itself
			if(task.period >= 0) {
				task.time = task.time + task.period;
				insertByTime(task, tasks);
			}
		}
	}

	return tasks;
}

function insertByTime(task, timeslots) {
	var l = timeslots.length;

	if(l === 0) {
		timeslots.push(newTimeslot(task.time, [task]));
		return;
	}

	var i = binarySearch(task.time, timeslots);

	if(i >= l) {
		timeslots.push(newTimeslot(task.time, [task]));
	} else if(task.time === timeslots[i].time) {
		timeslots[i].events.push(task);
	} else {
		timeslots.splice(i, 0, newTimeslot(task.time, [task]));
	}
}

function binarySearch(t, sortedArray) {
	var lo = 0;
	var hi = sortedArray.length;
	var mid, y;

	while (lo < hi) {
		mid = Math.floor((lo + hi) / 2);
		y = sortedArray[mid];

		if (t === y.time) {
			return mid;
		} else if (t < y.time) {
			hi = mid;
		} else {
			lo = mid + 1;
		}
	}
	return hi;
}

function newTimeslot(t, events) {
	return { time: t, events: events };
}

},{"@most/prelude":69}],47:[function(require,module,exports){
(function (process){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Scheduler = require('./Scheduler');
var setTimeoutTimer = require('./timeoutTimer');
var nodeTimer = require('./nodeTimer');

var isNode = typeof process === 'object'
		&& typeof process.nextTick === 'function';

module.exports = new Scheduler(isNode ? nodeTimer : setTimeoutTimer);

}).call(this,require('_process'))
//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9zY2hlZHVsZXIvZGVmYXVsdFNjaGVkdWxlci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EiLCJmaWxlIjoiZ2VuZXJhdGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBAbGljZW5zZSBNSVQgTGljZW5zZSAoYykgY29weXJpZ2h0IDIwMTAtMjAxNiBvcmlnaW5hbCBhdXRob3Igb3IgYXV0aG9ycyAqL1xuLyoqIEBhdXRob3IgQnJpYW4gQ2F2YWxpZXIgKi9cbi8qKiBAYXV0aG9yIEpvaG4gSGFubiAqL1xuXG52YXIgU2NoZWR1bGVyID0gcmVxdWlyZSgnLi9TY2hlZHVsZXInKTtcbnZhciBzZXRUaW1lb3V0VGltZXIgPSByZXF1aXJlKCcuL3RpbWVvdXRUaW1lcicpO1xudmFyIG5vZGVUaW1lciA9IHJlcXVpcmUoJy4vbm9kZVRpbWVyJyk7XG5cbnZhciBpc05vZGUgPSB0eXBlb2YgcHJvY2VzcyA9PT0gJ29iamVjdCdcblx0XHQmJiB0eXBlb2YgcHJvY2Vzcy5uZXh0VGljayA9PT0gJ2Z1bmN0aW9uJztcblxubW9kdWxlLmV4cG9ydHMgPSBuZXcgU2NoZWR1bGVyKGlzTm9kZSA/IG5vZGVUaW1lciA6IHNldFRpbWVvdXRUaW1lcik7XG4iXX0=
},{"./Scheduler":46,"./nodeTimer":48,"./timeoutTimer":49,"_process":1}],48:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var defer = require('../defer');

/*global setTimeout, clearTimeout*/

function Task(f) {
	this.f = f;
	this.active = true;
}

Task.prototype.run = function() {
	if(!this.active) {
		return;
	}
	var f = this.f;
	return f();
};

Task.prototype.error = function(e) {
	throw e;
};

Task.prototype.cancel = function() {
	this.active = false;
};

function runAsTask(f) {
	var task = new Task(f);
	defer(task);
	return task;
}

module.exports = {
	now: Date.now,
	setTimer: function(f, dt) {
		return dt <= 0 ? runAsTask(f) : setTimeout(f, dt);
	},
	clearTimer: function(t) {
		return t instanceof Task ? t.cancel() : clearTimeout(t);
	}
};

},{"../defer":31}],49:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

/*global setTimeout, clearTimeout*/

module.exports = {
	now: Date.now,
	setTimer: function(f, dt) {
		return setTimeout(f, dt);
	},
	clearTimer: function(t) {
		return clearTimeout(t);
	}
};

},{}],50:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var defer = require('../defer');

module.exports = DeferredSink;

function DeferredSink(sink) {
	this.sink = sink;
	this.events = [];
	this.active = true;
}

DeferredSink.prototype.event = function(t, x) {
	if(!this.active) {
		return;
	}

	if(this.events.length === 0) {
		defer(new PropagateAllTask(this.sink, this.events));
	}

	this.events.push({ time: t, value: x });
};

DeferredSink.prototype.error = function(t, e) {
	this._end(new ErrorTask(t, e, this.sink));
};

DeferredSink.prototype.end = function(t, x) {
	this._end(new EndTask(t, x, this.sink));
};

DeferredSink.prototype._end = function(task) {
	this.active = false;
	this.events = void 0;
	defer(task);
}

function PropagateAllTask(sink, events) {
	this.sink = sink;
	this.events = events;
}

PropagateAllTask.prototype.run = function() {
	var events = this.events;
	var sink = this.sink;
	var event;

	for(var i = 0, l = events.length; i<l; ++i) {
		event = events[i];
		sink.event(event.time, event.value);
	}

	events.length = 0;
};

PropagateAllTask.prototype.error = function(e) {
	this.sink.error(0, e);
};

function EndTask(t, x, sink) {
	this.time = t;
	this.value = x;
	this.sink = sink;
}

EndTask.prototype.run = function() {
	this.sink.end(this.time, this.value);
};

EndTask.prototype.error = function(e) {
	this.sink.error(this.time, e);
};

function ErrorTask(t, e, sink) {
	this.time = t;
	this.value = e;
	this.sink = sink;
}

ErrorTask.prototype.run = function() {
	this.sink.error(this.time, this.value);
};

ErrorTask.prototype.error = function(e) {
	throw e;
};

},{"../defer":31}],51:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Sink = require('./Pipe');

module.exports = IndexSink;

function IndexSink(i, sink) {
	this.sink = sink;
	this.index = i;
	this.active = true;
	this.value = void 0;
}

IndexSink.prototype.event = function(t, x) {
	if(!this.active) {
		return;
	}
	this.value = x;
	this.sink.event(t, this);
};

IndexSink.prototype.end = function(t, x) {
	if(!this.active) {
		return;
	}
	this.active = false;
	this.sink.end(t, { index: this.index, value: x });
};

IndexSink.prototype.error = Sink.prototype.error;

},{"./Pipe":53}],52:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = Observer;

/**
 * Sink that accepts functions to apply to each event, and to end, and error
 * signals.
 * @constructor
 */
function Observer(event, end, error, disposable) {
	this._event = event;
	this._end = end;
	this._error = error;
	this._disposable = disposable;
	this.active = true;
}

Observer.prototype.event = function(t, x) {
	if (!this.active) {
		return;
	}
	this._event(x);
};

Observer.prototype.end = function(t, x) {
	if (!this.active) {
		return;
	}
	this.active = false;
	disposeThen(this._end, this._error, this._disposable, x);
};

Observer.prototype.error = function(t, e) {
	this.active = false;
	disposeThen(this._error, this._error, this._disposable, e);
};

function disposeThen(end, error, disposable, x) {
	Promise.resolve(disposable.dispose()).then(function () {
		end(x);
	}, error);
}

},{}],53:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = Pipe;

/**
 * A sink mixin that simply forwards event, end, and error to
 * another sink.
 * @param sink
 * @constructor
 */
function Pipe(sink) {
	this.sink = sink;
}

Pipe.prototype.event = function(t, x) {
	return this.sink.event(t, x);
};

Pipe.prototype.end = function(t, x) {
	return this.sink.end(t, x);
};

Pipe.prototype.error = function(t, e) {
	return this.sink.error(t, e);
};

},{}],54:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

module.exports = SafeSink;

function SafeSink(sink) {
	this.sink = sink;
	this.active = true;
}

SafeSink.prototype.event = function(t, x) {
	if(!this.active) {
		return;
	}
	this.sink.event(t, x);
};

SafeSink.prototype.end = function(t, x) {
	if(!this.active) {
		return;
	}
	this.disable();
	this.sink.end(t, x);
};

SafeSink.prototype.error = function(t, e) {
	this.disable();
	this.sink.error(t, e);
};

SafeSink.prototype.disable = function() {
	this.active = false;
	return this.sink;
}

},{}],55:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var DeferredSink = require('../sink/DeferredSink');
var dispose = require('../disposable/dispose');
var tryEvent = require('./tryEvent');

module.exports = EventEmitterSource;

function EventEmitterSource(event, source) {
	this.event = event;
	this.source = source;
}

EventEmitterSource.prototype.run = function(sink, scheduler) {
	// NOTE: Because EventEmitter allows events in the same call stack as
	// a listener is added, use a DeferredSink to buffer events
	// until the stack clears, then propagate.  This maintains most.js's
	// invariant that no event will be delivered in the same call stack
	// as an observer begins observing.
	var dsink = new DeferredSink(sink);

	function addEventVariadic(a) {
		var l = arguments.length;
		if(l > 1) {
			var arr = new Array(l);
			for(var i=0; i<l; ++i) {
				arr[i] = arguments[i];
			}
			tryEvent.tryEvent(scheduler.now(), arr, dsink);
		} else {
			tryEvent.tryEvent(scheduler.now(), a, dsink);
		}
	}

	this.source.addListener(this.event, addEventVariadic);

	return dispose.create(disposeEventEmitter, { target: this, addEvent: addEventVariadic });
};

function disposeEventEmitter(info) {
	var target = info.target;
	target.source.removeListener(target.event, info.addEvent);
}

},{"../disposable/dispose":34,"../sink/DeferredSink":50,"./tryEvent":66}],56:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var dispose = require('../disposable/dispose');
var tryEvent = require('./tryEvent');

module.exports = EventTargetSource;

function EventTargetSource(event, source, capture) {
	this.event = event;
	this.source = source;
	this.capture = capture;
}

EventTargetSource.prototype.run = function(sink, scheduler) {
	function addEvent(e) {
		tryEvent.tryEvent(scheduler.now(), e, sink);
	}

	this.source.addEventListener(this.event, addEvent, this.capture);

	return dispose.create(disposeEventTarget,
		{ target: this, addEvent: addEvent });
};

function disposeEventTarget(info) {
	var target = info.target;
	target.source.removeEventListener(target.event, info.addEvent, target.capture);
}

},{"../disposable/dispose":34,"./tryEvent":66}],57:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var dispose = require('../disposable/dispose');
var PropagateTask = require('../scheduler/PropagateTask');

exports.of = streamOf;
exports.empty = empty;
exports.never = never;

/**
 * Stream containing only x
 * @param {*} x
 * @returns {Stream}
 */
 function streamOf(x) {
 	return new Stream(new Just(x));
 }

 function Just(x) {
 	this.value = x;
 }

 Just.prototype.run = function(sink, scheduler) {
 	return scheduler.asap(new PropagateTask(runJust, this.value, sink));
 };

 function runJust(t, x, sink) {
 	sink.event(t, x);
 	sink.end(t, void 0);
 }

/**
 * Stream containing no events and ends immediately
 * @returns {Stream}
 */
function empty() {
	return EMPTY;
}

function EmptySource() {}

EmptySource.prototype.run = function(sink, scheduler) {
	var task = PropagateTask.end(void 0, sink);
	scheduler.asap(task);

	return dispose.create(disposeEmpty, task);
};

function disposeEmpty(task) {
	return task.dispose();
}

var EMPTY = new Stream(new EmptySource());

/**
 * Stream containing no events and never ends
 * @returns {Stream}
 */
function never() {
	return NEVER;
}

function NeverSource() {}

NeverSource.prototype.run = function() {
	return dispose.empty();
};

var NEVER = new Stream(new NeverSource());

},{"../Stream":5,"../disposable/dispose":34,"../scheduler/PropagateTask":45}],58:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var MulticastSource = require('@most/multicast').MulticastSource;
var DeferredSink = require('../sink/DeferredSink');
var tryEvent = require('./tryEvent');

exports.create = create;

/**
 * @deprecated
 */
function create(run) {
	return new Stream(new MulticastSource(new SubscriberSource(run)));
}

function SubscriberSource(subscribe) {
	this._subscribe = subscribe;
}

SubscriberSource.prototype.run = function(sink, scheduler) {
	return new Subscription(new DeferredSink(sink), scheduler, this._subscribe);
};

function Subscription(sink, scheduler, subscribe) {
	this.sink = sink;
	this.scheduler = scheduler;
	this.active = true;
	this._unsubscribe = this._init(subscribe);
}

Subscription.prototype._init = function(subscribe) {
	var s = this;

	try {
		return subscribe(add, end, error);
	} catch(e) {
		error(e);
	}

	function add(x) {
		s._add(x);
	}
	function end(x) {
		s._end(x);
	}
	function error(e) {
		s._error(e);
	}
};

Subscription.prototype._add = function(x) {
	if(!this.active) {
		return;
	}
	tryEvent.tryEvent(this.scheduler.now(), x, this.sink);
};

Subscription.prototype._end = function(x) {
	if(!this.active) {
		return;
	}
	this.active = false;
	tryEvent.tryEnd(this.scheduler.now(), x, this.sink);
};

Subscription.prototype._error = function(x) {
	this.active = false;
	this.sink.error(this.scheduler.now(), x);
};

Subscription.prototype.dispose = function() {
	this.active = false;
	if(typeof this._unsubscribe === 'function') {
		return this._unsubscribe.call(void 0);
	}
};

},{"../Stream":5,"../sink/DeferredSink":50,"./tryEvent":66,"@most/multicast":68}],59:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var fromArray = require('./fromArray').fromArray;
var isIterable = require('../iterable').isIterable;
var fromIterable = require('./fromIterable').fromIterable;
var getObservable = require('../observable/getObservable');
var fromObservable = require('../observable/fromObservable').fromObservable;
var isArrayLike = require('@most/prelude').isArrayLike;

exports.from = from;

function from(a) { // eslint-disable-line complexity
	if(a instanceof Stream) {
		return a;
	}

	var observable = getObservable(a);
	if(observable != null) {
		return fromObservable(observable);
	}

	if(Array.isArray(a) || isArrayLike(a)) {
		return fromArray(a);
	}

	if(isIterable(a)) {
		return fromIterable(a);
	}

	throw new TypeError('from(x) must be observable, iterable, or array-like: ' + a);
}

},{"../Stream":5,"../iterable":40,"../observable/fromObservable":41,"../observable/getObservable":42,"./fromArray":60,"./fromIterable":62,"@most/prelude":69}],60:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var PropagateTask = require('../scheduler/PropagateTask');

exports.fromArray = fromArray;

function fromArray (a) {
	return new Stream(new ArraySource(a));
}

function ArraySource(a) {
	this.array = a;
}

ArraySource.prototype.run = function(sink, scheduler) {
	return scheduler.asap(new PropagateTask(runProducer, this.array, sink));
};

function runProducer(t, array, sink) {
	for(var i=0, l=array.length; i<l && this.active; ++i) {
		sink.event(t, array[i]);
	}

	this.active && end(t);

	function end(t) {
		sink.end(t);
	}
}

},{"../Stream":5,"../scheduler/PropagateTask":45}],61:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var MulticastSource = require('@most/multicast').MulticastSource;
var EventTargetSource = require('./EventTargetSource');
var EventEmitterSource = require('./EventEmitterSource');

exports.fromEvent = fromEvent;

/**
 * Create a stream from an EventTarget, such as a DOM Node, or EventEmitter.
 * @param {String} event event type name, e.g. 'click'
 * @param {EventTarget|EventEmitter} source EventTarget or EventEmitter
 * @param {boolean?} useCapture for DOM events, whether to use
 *  capturing--passed as 3rd parameter to addEventListener.
 * @returns {Stream} stream containing all events of the specified type
 * from the source.
 */
function fromEvent(event, source /*, useCapture = false */) {
	var s;

	if(typeof source.addEventListener === 'function' && typeof source.removeEventListener === 'function') {
		var capture = arguments.length > 2 && !!arguments[2];
		s = new MulticastSource(new EventTargetSource(event, source, capture));
	} else if(typeof source.addListener === 'function' && typeof source.removeListener === 'function') {
		s = new EventEmitterSource(event, source);
	} else {
		throw new Error('source must support addEventListener/removeEventListener or addListener/removeListener');
	}

	return new Stream(s);
}

},{"../Stream":5,"./EventEmitterSource":55,"./EventTargetSource":56,"@most/multicast":68}],62:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var getIterator = require('../iterable').getIterator;
var PropagateTask = require('../scheduler/PropagateTask');

exports.fromIterable = fromIterable;

function fromIterable(iterable) {
	return new Stream(new IterableSource(iterable));
}

function IterableSource(iterable) {
	this.iterable = iterable;
}

IterableSource.prototype.run = function(sink, scheduler) {
	return new IteratorProducer(getIterator(this.iterable), sink, scheduler);
};

function IteratorProducer(iterator, sink, scheduler) {
	this.scheduler = scheduler;
	this.iterator = iterator;
	this.task = new PropagateTask(runProducer, this, sink);
	scheduler.asap(this.task);
}

IteratorProducer.prototype.dispose = function() {
	return this.task.dispose();
};

function runProducer(t, producer, sink) {
	var x = producer.iterator.next();
	if(x.done) {
		sink.end(t, x.value);
	} else {
		sink.event(t, x.value);
	}

	producer.scheduler.asap(producer.task);
}

},{"../Stream":5,"../iterable":40,"../scheduler/PropagateTask":45}],63:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2014 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var base = require('@most/prelude');

exports.generate = generate;

/**
 * Compute a stream using an *async* generator, which yields promises
 * to control event times.
 * @param f
 * @returns {Stream}
 */
function generate(f /*, ...args */) {
	return new Stream(new GenerateSource(f, base.tail(arguments)));
}

function GenerateSource(f, args) {
	this.f = f;
	this.args = args;
}

GenerateSource.prototype.run = function(sink, scheduler) {
	return new Generate(this.f.apply(void 0, this.args), sink, scheduler);
};

function Generate(iterator, sink, scheduler) {
	this.iterator = iterator;
	this.sink = sink;
	this.scheduler = scheduler;
	this.active = true;

	var self = this;
	function err(e) {
		self.sink.error(self.scheduler.now(), e);
	}

	Promise.resolve(this).then(next).catch(err);
}

function next(generate, x) {
	return generate.active ? handle(generate, generate.iterator.next(x)) : x;
}

function handle(generate, result) {
	if (result.done) {
		return generate.sink.end(generate.scheduler.now(), result.value);
	}

	return Promise.resolve(result.value).then(function (x) {
		return emit(generate, x);
	}, function(e) {
		return error(generate, e);
	});
}

function emit(generate, x) {
	generate.sink.event(generate.scheduler.now(), x);
	return next(generate, x);
}

function error(generate, e) {
	return handle(generate, generate.iterator.throw(e));
}

Generate.prototype.dispose = function() {
	this.active = false;
};

},{"../Stream":5,"@most/prelude":69}],64:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');

exports.iterate = iterate;

/**
 * Compute a stream by iteratively calling f to produce values
 * Event times may be controlled by returning a Promise from f
 * @param {function(x:*):*|Promise<*>} f
 * @param {*} x initial value
 * @returns {Stream}
 */
function iterate(f, x) {
	return new Stream(new IterateSource(f, x));
}

function IterateSource(f, x) {
	this.f = f;
	this.value = x;
}

IterateSource.prototype.run = function(sink, scheduler) {
	return new Iterate(this.f, this.value, sink, scheduler);
};

function Iterate(f, initial, sink, scheduler) {
	this.f = f;
	this.sink = sink;
	this.scheduler = scheduler;
	this.active = true;

	var x = initial;

	var self = this;
	function err(e) {
		self.sink.error(self.scheduler.now(), e);
	}

	function start(iterate) {
		return stepIterate(iterate, x);
	}

	Promise.resolve(this).then(start).catch(err);
}

Iterate.prototype.dispose = function() {
	this.active = false;
};

function stepIterate(iterate, x) {
	iterate.sink.event(iterate.scheduler.now(), x);

	if(!iterate.active) {
		return x;
	}

	var f = iterate.f;
	return Promise.resolve(f(x)).then(function(y) {
		return continueIterate(iterate, y);
	});
}

function continueIterate(iterate, x) {
	return !iterate.active ? iterate.value : stepIterate(iterate, x);
}

},{"../Stream":5}],65:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');
var dispose = require('../disposable/dispose');
var MulticastSource = require('@most/multicast').MulticastSource;
var PropagateTask = require('../scheduler/PropagateTask');

exports.periodic = periodic;

/**
 * Create a stream that emits the current time periodically
 * @param {Number} period periodicity of events in millis
 * @param {*) value value to emit each period
 * @returns {Stream} new stream that emits the current time every period
 */
function periodic(period, value) {
	return new Stream(new MulticastSource(new Periodic(period, value)));
}

function Periodic(period, value) {
	this.period = period;
	this.value = value;
}

Periodic.prototype.run = function(sink, scheduler) {
	return scheduler.periodic(this.period, new PropagateTask(emit, this.value, sink));
};

function emit(t, x, sink) {
	sink.event(t, x);
}

},{"../Stream":5,"../disposable/dispose":34,"../scheduler/PropagateTask":45,"@most/multicast":68}],66:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

exports.tryEvent = tryEvent;
exports.tryEnd = tryEnd;

function tryEvent(t, x, sink) {
	try {
		sink.event(t, x);
	} catch(e) {
		sink.error(t, e);
	}
}

function tryEnd(t, x, sink) {
	try {
		sink.end(t, x);
	} catch(e) {
		sink.error(t, e);
	}
}

},{}],67:[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('../Stream');

exports.unfold = unfold;

/**
 * Compute a stream by unfolding tuples of future values from a seed value
 * Event times may be controlled by returning a Promise from f
 * @param {function(seed:*):{value:*, seed:*, done:boolean}|Promise<{value:*, seed:*, done:boolean}>} f unfolding function accepts
 *  a seed and returns a new tuple with a value, new seed, and boolean done flag.
 *  If tuple.done is true, the stream will end.
 * @param {*} seed seed value
 * @returns {Stream} stream containing all value of all tuples produced by the
 *  unfolding function.
 */
function unfold(f, seed) {
	return new Stream(new UnfoldSource(f, seed));
}

function UnfoldSource(f, seed) {
	this.f = f;
	this.value = seed;
}

UnfoldSource.prototype.run = function(sink, scheduler) {
	return new Unfold(this.f, this.value, sink, scheduler);
};

function Unfold(f, x, sink, scheduler) {
	this.f = f;
	this.sink = sink;
	this.scheduler = scheduler;
	this.active = true;

	var self = this;
	function err(e) {
		self.sink.error(self.scheduler.now(), e);
	}

	function start(unfold) {
		return stepUnfold(unfold, x);
	}

	Promise.resolve(this).then(start).catch(err);
}

Unfold.prototype.dispose = function() {
	this.active = false;
};

function stepUnfold(unfold, x) {
	var f = unfold.f;
	return Promise.resolve(f(x)).then(function(tuple) {
		return continueUnfold(unfold, tuple);
	});
}

function continueUnfold(unfold, tuple) {
	if(tuple.done) {
		unfold.sink.end(unfold.scheduler.now(), tuple.value);
		return tuple.value;
	}

	unfold.sink.event(unfold.scheduler.now(), tuple.value);

	if(!unfold.active) {
		return tuple.value;
	}
	return stepUnfold(unfold, tuple.seed);
}

},{"../Stream":5}],68:[function(require,module,exports){
(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define('@most/multicast', ['exports', '@most/prelude'], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require('@most/prelude'));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.prelude);
    global.mostMulticast = mod.exports;
  }
})(this, function (exports, _prelude) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.MulticastSource = undefined;

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  var _createClass = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }

    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();

  var MulticastDisposable = function () {
    function MulticastDisposable(source, sink) {
      _classCallCheck(this, MulticastDisposable);

      this.source = source;
      this.sink = sink;
      this.disposed = false;
    }

    _createClass(MulticastDisposable, [{
      key: 'dispose',
      value: function dispose() {
        if (this.disposed) {
          return;
        }
        this.disposed = true;
        var remaining = this.source.remove(this.sink);
        return remaining === 0 && this.source._dispose();
      }
    }]);

    return MulticastDisposable;
  }();

  function tryEvent(t, x, sink) {
    try {
      sink.event(t, x);
    } catch (e) {
      sink.error(t, e);
    }
  }

  function tryEnd(t, x, sink) {
    try {
      sink.end(t, x);
    } catch (e) {
      sink.error(t, e);
    }
  }

  var dispose = function dispose(disposable) {
    return disposable.dispose();
  };

  var emptyDisposable = {
    dispose: function dispose() {}
  };

  var MulticastSource = function () {
    function MulticastSource(source) {
      _classCallCheck(this, MulticastSource);

      this.source = source;
      this.sinks = [];
      this._disposable = emptyDisposable;
    }

    _createClass(MulticastSource, [{
      key: 'run',
      value: function run(sink, scheduler) {
        var n = this.add(sink);
        if (n === 1) {
          this._disposable = this.source.run(this, scheduler);
        }
        return new MulticastDisposable(this, sink);
      }
    }, {
      key: '_dispose',
      value: function _dispose() {
        var disposable = this._disposable;
        this._disposable = emptyDisposable;
        return Promise.resolve(disposable).then(dispose);
      }
    }, {
      key: 'add',
      value: function add(sink) {
        this.sinks = (0, _prelude.append)(sink, this.sinks);
        return this.sinks.length;
      }
    }, {
      key: 'remove',
      value: function remove(sink) {
        var i = (0, _prelude.findIndex)(sink, this.sinks);
        // istanbul ignore next
        if (i >= 0) {
          this.sinks = (0, _prelude.remove)(i, this.sinks);
        }

        return this.sinks.length;
      }
    }, {
      key: 'event',
      value: function event(time, value) {
        var s = this.sinks;
        if (s.length === 1) {
          return s[0].event(time, value);
        }
        for (var i = 0; i < s.length; ++i) {
          tryEvent(time, value, s[i]);
        }
      }
    }, {
      key: 'end',
      value: function end(time, value) {
        var s = this.sinks;
        for (var i = 0; i < s.length; ++i) {
          tryEnd(time, value, s[i]);
        }
      }
    }, {
      key: 'error',
      value: function error(time, err) {
        var s = this.sinks;
        for (var i = 0; i < s.length; ++i) {
          s[i].error(time, err);
        }
      }
    }]);

    return MulticastSource;
  }();

  function multicast(stream) {
    var source = stream.source;
    return source instanceof MulticastSource ? stream : new stream.constructor(new MulticastSource(source));
  }

  exports.MulticastSource = MulticastSource;
  exports.default = multicast;
});

},{"@most/prelude":69}],69:[function(require,module,exports){
(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define('@most/prelude', ['exports'], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports);
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports);
    global.mostPrelude = mod.exports;
  }
})(this, function (exports) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  /** @license MIT License (c) copyright 2010-2016 original author or authors */

  // Non-mutating array operations

  // cons :: a -> [a] -> [a]
  // a with x prepended
  function cons(x, a) {
    var l = a.length;
    var b = new Array(l + 1);
    b[0] = x;
    for (var i = 0; i < l; ++i) {
      b[i + 1] = a[i];
    }
    return b;
  }

  // append :: a -> [a] -> [a]
  // a with x appended
  function append(x, a) {
    var l = a.length;
    var b = new Array(l + 1);
    for (var i = 0; i < l; ++i) {
      b[i] = a[i];
    }

    b[l] = x;
    return b;
  }

  // drop :: Int -> [a] -> [a]
  // drop first n elements
  function drop(n, a) {
    // eslint-disable-line complexity
    if (n < 0) {
      throw new TypeError('n must be >= 0');
    }

    var l = a.length;
    if (n === 0 || l === 0) {
      return a;
    }

    if (n >= l) {
      return [];
    }

    return unsafeDrop(n, a, l - n);
  }

  // unsafeDrop :: Int -> [a] -> Int -> [a]
  // Internal helper for drop
  function unsafeDrop(n, a, l) {
    var b = new Array(l);
    for (var i = 0; i < l; ++i) {
      b[i] = a[n + i];
    }
    return b;
  }

  // tail :: [a] -> [a]
  // drop head element
  function tail(a) {
    return drop(1, a);
  }

  // copy :: [a] -> [a]
  // duplicate a (shallow duplication)
  function copy(a) {
    var l = a.length;
    var b = new Array(l);
    for (var i = 0; i < l; ++i) {
      b[i] = a[i];
    }
    return b;
  }

  // map :: (a -> b) -> [a] -> [b]
  // transform each element with f
  function map(f, a) {
    var l = a.length;
    var b = new Array(l);
    for (var i = 0; i < l; ++i) {
      b[i] = f(a[i]);
    }
    return b;
  }

  // reduce :: (a -> b -> a) -> a -> [b] -> a
  // accumulate via left-fold
  function reduce(f, z, a) {
    var r = z;
    for (var i = 0, l = a.length; i < l; ++i) {
      r = f(r, a[i], i);
    }
    return r;
  }

  // replace :: a -> Int -> [a]
  // replace element at index
  function replace(x, i, a) {
    // eslint-disable-line complexity
    if (i < 0) {
      throw new TypeError('i must be >= 0');
    }

    var l = a.length;
    var b = new Array(l);
    for (var j = 0; j < l; ++j) {
      b[j] = i === j ? x : a[j];
    }
    return b;
  }

  // remove :: Int -> [a] -> [a]
  // remove element at index
  function remove(i, a) {
    // eslint-disable-line complexity
    if (i < 0) {
      throw new TypeError('i must be >= 0');
    }

    var l = a.length;
    if (l === 0 || i >= l) {
      // exit early if index beyond end of array
      return a;
    }

    if (l === 1) {
      // exit early if index in bounds and length === 1
      return [];
    }

    return unsafeRemove(i, a, l - 1);
  }

  // unsafeRemove :: Int -> [a] -> Int -> [a]
  // Internal helper to remove element at index
  function unsafeRemove(i, a, l) {
    var b = new Array(l);
    var j = undefined;
    for (j = 0; j < i; ++j) {
      b[j] = a[j];
    }
    for (j = i; j < l; ++j) {
      b[j] = a[j + 1];
    }

    return b;
  }

  // removeAll :: (a -> boolean) -> [a] -> [a]
  // remove all elements matching a predicate
  function removeAll(f, a) {
    var l = a.length;
    var b = new Array(l);
    var j = 0;
    for (var x, i = 0; i < l; ++i) {
      x = a[i];
      if (!f(x)) {
        b[j] = x;
        ++j;
      }
    }

    b.length = j;
    return b;
  }

  // findIndex :: a -> [a] -> Int
  // find index of x in a, from the left
  function findIndex(x, a) {
    for (var i = 0, l = a.length; i < l; ++i) {
      if (x === a[i]) {
        return i;
      }
    }
    return -1;
  }

  // isArrayLike :: * -> boolean
  // Return true iff x is array-like
  function isArrayLike(x) {
    return x != null && typeof x.length === 'number' && typeof x !== 'function';
  }

  /** @license MIT License (c) copyright 2010-2016 original author or authors */

  // id :: a -> a
  var id = function id(x) {
    return x;
  };

  // compose :: (b -> c) -> (a -> b) -> (a -> c)
  var compose = function compose(f, g) {
    return function (x) {
      return f(g(x));
    };
  };

  // apply :: (a -> b) -> a -> b
  var apply = function apply(f, x) {
    return f(x);
  };

  // curry2 :: ((a, b) -> c) -> (a -> b -> c)
  function curry2(f) {
    function curried(a, b) {
      switch (arguments.length) {
        case 0:
          return curried;
        case 1:
          return function (b) {
            return f(a, b);
          };
        default:
          return f(a, b);
      }
    }
    return curried;
  }

  // curry3 :: ((a, b, c) -> d) -> (a -> b -> c -> d)
  function curry3(f) {
    function curried(a, b, c) {
      // eslint-disable-line complexity
      switch (arguments.length) {
        case 0:
          return curried;
        case 1:
          return curry2(function (b, c) {
            return f(a, b, c);
          });
        case 2:
          return function (c) {
            return f(a, b, c);
          };
        default:
          return f(a, b, c);
      }
    }
    return curried;
  }

  exports.cons = cons;
  exports.append = append;
  exports.drop = drop;
  exports.tail = tail;
  exports.copy = copy;
  exports.map = map;
  exports.reduce = reduce;
  exports.replace = replace;
  exports.remove = remove;
  exports.removeAll = removeAll;
  exports.findIndex = findIndex;
  exports.isArrayLike = isArrayLike;
  exports.id = id;
  exports.compose = compose;
  exports.apply = apply;
  exports.curry2 = curry2;
  exports.curry3 = curry3;
});

},{}],70:[function(require,module,exports){
(function (global){
/* global window */
'use strict';

module.exports = require('./ponyfill')(global || window || this);

}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9zeW1ib2wtb2JzZXJ2YWJsZS9pbmRleC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQSIsImZpbGUiOiJnZW5lcmF0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyogZ2xvYmFsIHdpbmRvdyAqL1xuJ3VzZSBzdHJpY3QnO1xuXG5tb2R1bGUuZXhwb3J0cyA9IHJlcXVpcmUoJy4vcG9ueWZpbGwnKShnbG9iYWwgfHwgd2luZG93IHx8IHRoaXMpO1xuIl19
},{"./ponyfill":71}],71:[function(require,module,exports){
'use strict';

module.exports = function symbolObservablePonyfill(root) {
	var result;
	var Symbol = root.Symbol;

	if (typeof Symbol === 'function') {
		if (Symbol.observable) {
			result = Symbol.observable;
		} else {
			result = Symbol('observable');
			Symbol.observable = result;
		}
	} else {
		result = '@@observable';
	}

	return result;
};

},{}],"most":[function(require,module,exports){
/** @license MIT License (c) copyright 2010-2016 original author or authors */
/** @author Brian Cavalier */
/** @author John Hann */

var Stream = require('./lib/Stream');
var base = require('@most/prelude');
var core = require('./lib/source/core');
var from = require('./lib/source/from').from;
var periodic = require('./lib/source/periodic').periodic;
var symbolObservable = require('symbol-observable');

/**
 * Core stream type
 * @type {Stream}
 */
exports.Stream = Stream;

// Add of and empty to constructor for fantasy-land compat
exports.of       = Stream.of    = core.of;
exports.just     = core.of; // easier ES6 import alias
exports.empty    = Stream.empty = core.empty;
exports.never    = core.never;
exports.from     = from;
exports.periodic = periodic;

//-----------------------------------------------------------------------
// Draft ES Observable proposal interop
// https://github.com/zenparsing/es-observable

var subscribe = require('./lib/observable/subscribe').subscribe;

Stream.prototype.subscribe = function(subscriber) {
	return subscribe(subscriber, this);
};

Stream.prototype[symbolObservable] = function() {
	return this;
}

//-----------------------------------------------------------------------
// Fluent adapter

var thru = require('./lib/combinator/thru').thru;

/**
 * Adapt a functional stream transform to fluent style.
 * It applies f to the this stream object
 * @param  {function(s: Stream): Stream} f function that
 * receives the stream itself and must return a new stream
 * @return {Stream}
 */
Stream.prototype.thru = function(f) {
	return thru(f, this);
}

//-----------------------------------------------------------------------
// Creating

var create = require('./lib/source/create');

/**
 * @deprecated
 * Create a stream by imperatively pushing events.
 * @param {function(add:function(x), end:function(e)):function} run function
 *  that will receive 2 functions as arguments, the first to add new values to the
 *  stream and the second to end the stream. It may *return* a function that
 *  will be called once all consumers have stopped observing the stream.
 * @returns {Stream} stream containing all events added by run before end
 */
exports.create = create.create;

//-----------------------------------------------------------------------
// Adapting other sources

var events = require('./lib/source/fromEvent');

/**
 * Create a stream of events from the supplied EventTarget or EventEmitter
 * @param {String} event event name
 * @param {EventTarget|EventEmitter} source EventTarget or EventEmitter. The source
 *  must support either addEventListener/removeEventListener (w3c EventTarget:
 *  http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget),
 *  or addListener/removeListener (node EventEmitter: http://nodejs.org/api/events.html)
 * @returns {Stream} stream of events of the specified type from the source
 */
exports.fromEvent = events.fromEvent;

//-----------------------------------------------------------------------
// Observing

var observe = require('./lib/combinator/observe');

exports.observe = observe.observe;
exports.forEach = observe.observe;
exports.drain   = observe.drain;

/**
 * Process all the events in the stream
 * @returns {Promise} promise that fulfills when the stream ends, or rejects
 *  if the stream fails with an unhandled error.
 */
Stream.prototype.observe = Stream.prototype.forEach = function(f) {
	return observe.observe(f, this);
};

/**
 * Consume all events in the stream, without providing a function to process each.
 * This causes a stream to become active and begin emitting events, and is useful
 * in cases where all processing has been setup upstream via other combinators, and
 * there is no need to process the terminal events.
 * @returns {Promise} promise that fulfills when the stream ends, or rejects
 *  if the stream fails with an unhandled error.
 */
Stream.prototype.drain = function() {
	return observe.drain(this);
};

//-------------------------------------------------------

var loop = require('./lib/combinator/loop').loop;

exports.loop = loop;

/**
 * Generalized feedback loop. Call a stepper function for each event. The stepper
 * will be called with 2 params: the current seed and the an event value.  It must
 * return a new { seed, value } pair. The `seed` will be fed back into the next
 * invocation of stepper, and the `value` will be propagated as the event value.
 * @param {function(seed:*, value:*):{seed:*, value:*}} stepper loop step function
 * @param {*} seed initial seed value passed to first stepper call
 * @returns {Stream} new stream whose values are the `value` field of the objects
 * returned by the stepper
 */
Stream.prototype.loop = function(stepper, seed) {
	return loop(stepper, seed, this);
};

//-------------------------------------------------------

var accumulate = require('./lib/combinator/accumulate');

exports.scan   = accumulate.scan;
exports.reduce = accumulate.reduce;

/**
 * Create a stream containing successive reduce results of applying f to
 * the previous reduce result and the current stream item.
 * @param {function(result:*, x:*):*} f reducer function
 * @param {*} initial initial value
 * @returns {Stream} new stream containing successive reduce results
 */
Stream.prototype.scan = function(f, initial) {
	return accumulate.scan(f, initial, this);
};

/**
 * Reduce the stream to produce a single result.  Note that reducing an infinite
 * stream will return a Promise that never fulfills, but that may reject if an error
 * occurs.
 * @param {function(result:*, x:*):*} f reducer function
 * @param {*} initial optional initial value
 * @returns {Promise} promise for the file result of the reduce
 */
Stream.prototype.reduce = function(f, initial) {
	return accumulate.reduce(f, initial, this);
};

//-----------------------------------------------------------------------
// Building and extending

var unfold = require('./lib/source/unfold');
var iterate = require('./lib/source/iterate');
var generate = require('./lib/source/generate');
var build = require('./lib/combinator/build');

exports.unfold    = unfold.unfold;
exports.iterate   = iterate.iterate;
exports.generate  = generate.generate;
exports.cycle     = build.cycle;
exports.concat    = build.concat;
exports.startWith = build.cons;

/**
 * @deprecated
 * Tie this stream into a circle, thus creating an infinite stream
 * @returns {Stream} new infinite stream
 */
Stream.prototype.cycle = function() {
	return build.cycle(this);
};

/**
 * @param {Stream} tail
 * @returns {Stream} new stream containing all items in this followed by
 *  all items in tail
 */
Stream.prototype.concat = function(tail) {
	return build.concat(this, tail);
};

/**
 * @param {*} x value to prepend
 * @returns {Stream} a new stream with x prepended
 */
Stream.prototype.startWith = function(x) {
	return build.cons(x, this);
};

//-----------------------------------------------------------------------
// Transforming

var transform = require('./lib/combinator/transform');
var applicative = require('./lib/combinator/applicative');

exports.map      = transform.map;
exports.constant = transform.constant;
exports.tap      = transform.tap;
exports.ap       = applicative.ap;

/**
 * Transform each value in the stream by applying f to each
 * @param {function(*):*} f mapping function
 * @returns {Stream} stream containing items transformed by f
 */
Stream.prototype.map = function(f) {
	return transform.map(f, this);
};

/**
 * Assume this stream contains functions, and apply each function to each item
 * in the provided stream.  This generates, in effect, a cross product.
 * @param {Stream} xs stream of items to which
 * @returns {Stream} stream containing the cross product of items
 */
Stream.prototype.ap = function(xs) {
	return applicative.ap(this, xs);
};

/**
 * Replace each value in the stream with x
 * @param {*} x
 * @returns {Stream} stream containing items replaced with x
 */
Stream.prototype.constant = function(x) {
	return transform.constant(x, this);
};

/**
 * Perform a side effect for each item in the stream
 * @param {function(x:*):*} f side effect to execute for each item. The
 *  return value will be discarded.
 * @returns {Stream} new stream containing the same items as this stream
 */
Stream.prototype.tap = function(f) {
	return transform.tap(f, this);
};

//-----------------------------------------------------------------------
// Transducer support

var transduce = require('./lib/combinator/transduce');

exports.transduce = transduce.transduce;

/**
 * Transform this stream by passing its events through a transducer.
 * @param  {function} transducer transducer function
 * @return {Stream} stream of events transformed by the transducer
 */
Stream.prototype.transduce = function(transducer) {
	return transduce.transduce(transducer, this);
};

//-----------------------------------------------------------------------
// FlatMapping

var flatMap = require('./lib/combinator/flatMap');

exports.flatMap = exports.chain = flatMap.flatMap;
exports.join    = flatMap.join;

/**
 * Map each value in the stream to a new stream, and merge it into the
 * returned outer stream. Event arrival times are preserved.
 * @param {function(x:*):Stream} f chaining function, must return a Stream
 * @returns {Stream} new stream containing all events from each stream returned by f
 */
Stream.prototype.flatMap = Stream.prototype.chain = function(f) {
	return flatMap.flatMap(f, this);
};

/**
 * Monadic join. Flatten a Stream<Stream<X>> to Stream<X> by merging inner
 * streams to the outer. Event arrival times are preserved.
 * @returns {Stream<X>} new stream containing all events of all inner streams
 */
Stream.prototype.join = function() {
	return flatMap.join(this);
};

var continueWith = require('./lib/combinator/continueWith').continueWith;

exports.continueWith = continueWith;
exports.flatMapEnd = continueWith;

/**
 * Map the end event to a new stream, and begin emitting its values.
 * @param {function(x:*):Stream} f function that receives the end event value,
 * and *must* return a new Stream to continue with.
 * @returns {Stream} new stream that emits all events from the original stream,
 * followed by all events from the stream returned by f.
 */
Stream.prototype.continueWith = Stream.prototype.flatMapEnd = function(f) {
	return continueWith(f, this);
};

var concatMap = require('./lib/combinator/concatMap').concatMap;

exports.concatMap = concatMap;

Stream.prototype.concatMap = function(f) {
	return concatMap(f, this);
};

//-----------------------------------------------------------------------
// Concurrent merging

var mergeConcurrently = require('./lib/combinator/mergeConcurrently');

exports.mergeConcurrently = mergeConcurrently.mergeConcurrently;

/**
 * Flatten a Stream<Stream<X>> to Stream<X> by merging inner
 * streams to the outer, limiting the number of inner streams that may
 * be active concurrently.
 * @param {number} concurrency at most this many inner streams will be
 *  allowed to be active concurrently.
 * @return {Stream<X>} new stream containing all events of all inner
 *  streams, with limited concurrency.
 */
Stream.prototype.mergeConcurrently = function(concurrency) {
	return mergeConcurrently.mergeConcurrently(concurrency, this);
};

//-----------------------------------------------------------------------
// Merging

var merge = require('./lib/combinator/merge');

exports.merge = merge.merge;
exports.mergeArray = merge.mergeArray;

/**
 * Merge this stream and all the provided streams
 * @returns {Stream} stream containing items from this stream and s in time
 * order.  If two events are simultaneous they will be merged in
 * arbitrary order.
 */
Stream.prototype.merge = function(/*...streams*/) {
	return merge.mergeArray(base.cons(this, arguments));
};

//-----------------------------------------------------------------------
// Combining

var combine = require('./lib/combinator/combine');

exports.combine = combine.combine;
exports.combineArray = combine.combineArray;

/**
 * Combine latest events from all input streams
 * @param {function(...events):*} f function to combine most recent events
 * @returns {Stream} stream containing the result of applying f to the most recent
 *  event of each input stream, whenever a new event arrives on any stream.
 */
Stream.prototype.combine = function(f /*, ...streams*/) {
	return combine.combineArray(f, base.replace(this, 0, arguments));
};

//-----------------------------------------------------------------------
// Sampling

var sample = require('./lib/combinator/sample');

exports.sample = sample.sample;
exports.sampleWith = sample.sampleWith;

/**
 * When an event arrives on sampler, emit the latest event value from stream.
 * @param {Stream} sampler stream of events at whose arrival time
 *  signal's latest value will be propagated
 * @returns {Stream} sampled stream of values
 */
Stream.prototype.sampleWith = function(sampler) {
	return sample.sampleWith(sampler, this);
};

/**
 * When an event arrives on this stream, emit the result of calling f with the latest
 * values of all streams being sampled
 * @param {function(...values):*} f function to apply to each set of sampled values
 * @returns {Stream} stream of sampled and transformed values
 */
Stream.prototype.sample = function(f /* ...streams */) {
	return sample.sampleArray(f, this, base.tail(arguments));
};

//-----------------------------------------------------------------------
// Zipping

var zip = require('./lib/combinator/zip');

exports.zip = zip.zip;

/**
 * Pair-wise combine items with those in s. Given 2 streams:
 * [1,2,3] zipWith f [4,5,6] -> [f(1,4),f(2,5),f(3,6)]
 * Note: zip causes fast streams to buffer and wait for slow streams.
 * @param {function(a:Stream, b:Stream, ...):*} f function to combine items
 * @returns {Stream} new stream containing pairs
 */
Stream.prototype.zip = function(f /*, ...streams*/) {
	return zip.zipArray(f, base.replace(this, 0, arguments));
};

//-----------------------------------------------------------------------
// Switching

var switchLatest = require('./lib/combinator/switch').switch;

exports.switch       = switchLatest;
exports.switchLatest = switchLatest;

/**
 * Given a stream of streams, return a new stream that adopts the behavior
 * of the most recent inner stream.
 * @returns {Stream} switching stream
 */
Stream.prototype.switch = Stream.prototype.switchLatest = function() {
	return switchLatest(this);
};

//-----------------------------------------------------------------------
// Filtering

var filter = require('./lib/combinator/filter');

exports.filter          = filter.filter;
exports.skipRepeats     = exports.distinct   = filter.skipRepeats;
exports.skipRepeatsWith = exports.distinctBy = filter.skipRepeatsWith;

/**
 * Retain only items matching a predicate
 * stream:                           -12345678-
 * filter(x => x % 2 === 0, stream): --2-4-6-8-
 * @param {function(x:*):boolean} p filtering predicate called for each item
 * @returns {Stream} stream containing only items for which predicate returns truthy
 */
Stream.prototype.filter = function(p) {
	return filter.filter(p, this);
};

/**
 * Skip repeated events, using === to compare items
 * stream:           -abbcd-
 * distinct(stream): -ab-cd-
 * @returns {Stream} stream with no repeated events
 */
Stream.prototype.skipRepeats = function() {
	return filter.skipRepeats(this);
};

/**
 * Skip repeated events, using supplied equals function to compare items
 * @param {function(a:*, b:*):boolean} equals function to compare items
 * @returns {Stream} stream with no repeated events
 */
Stream.prototype.skipRepeatsWith = function(equals) {
	return filter.skipRepeatsWith(equals, this);
};

//-----------------------------------------------------------------------
// Slicing

var slice = require('./lib/combinator/slice');

exports.take      = slice.take;
exports.skip      = slice.skip;
exports.slice     = slice.slice;
exports.takeWhile = slice.takeWhile;
exports.skipWhile = slice.skipWhile;

/**
 * stream:          -abcd-
 * take(2, stream): -ab|
 * @param {Number} n take up to this many events
 * @returns {Stream} stream containing at most the first n items from this stream
 */
Stream.prototype.take = function(n) {
	return slice.take(n, this);
};

/**
 * stream:          -abcd->
 * skip(2, stream): ---cd->
 * @param {Number} n skip this many events
 * @returns {Stream} stream not containing the first n events
 */
Stream.prototype.skip = function(n) {
	return slice.skip(n, this);
};

/**
 * Slice a stream by event index. Equivalent to, but more efficient than
 * stream.take(end).skip(start);
 * NOTE: Negative start and end are not supported
 * @param {Number} start skip all events before the start index
 * @param {Number} end allow all events from the start index to the end index
 * @returns {Stream} stream containing items where start <= index < end
 */
Stream.prototype.slice = function(start, end) {
	return slice.slice(start, end, this);
};

/**
 * stream:                        -123451234->
 * takeWhile(x => x < 5, stream): -1234|
 * @param {function(x:*):boolean} p predicate
 * @returns {Stream} stream containing items up to, but not including, the
 * first item for which p returns falsy.
 */
Stream.prototype.takeWhile = function(p) {
	return slice.takeWhile(p, this);
};

/**
 * stream:                        -123451234->
 * skipWhile(x => x < 5, stream): -----51234->
 * @param {function(x:*):boolean} p predicate
 * @returns {Stream} stream containing items following *and including* the
 * first item for which p returns falsy.
 */
Stream.prototype.skipWhile = function(p) {
	return slice.skipWhile(p, this);
};

//-----------------------------------------------------------------------
// Time slicing

var timeslice = require('./lib/combinator/timeslice');

exports.until  = exports.takeUntil = timeslice.takeUntil;
exports.since  = exports.skipUntil = timeslice.skipUntil;
exports.during = timeslice.during;

/**
 * stream:                    -a-b-c-d-e-f-g->
 * signal:                    -------x
 * takeUntil(signal, stream): -a-b-c-|
 * @param {Stream} signal retain only events in stream before the first
 * event in signal
 * @returns {Stream} new stream containing only events that occur before
 * the first event in signal.
 */
Stream.prototype.until = Stream.prototype.takeUntil = function(signal) {
	return timeslice.takeUntil(signal, this);
};

/**
 * stream:                    -a-b-c-d-e-f-g->
 * signal:                    -------x
 * takeUntil(signal, stream): -------d-e-f-g->
 * @param {Stream} signal retain only events in stream at or after the first
 * event in signal
 * @returns {Stream} new stream containing only events that occur after
 * the first event in signal.
 */
Stream.prototype.since = Stream.prototype.skipUntil = function(signal) {
	return timeslice.skipUntil(signal, this);
};

/**
 * stream:                    -a-b-c-d-e-f-g->
 * timeWindow:                -----s
 * s:                               -----t
 * stream.during(timeWindow): -----c-d-e-|
 * @param {Stream<Stream>} timeWindow a stream whose first event (s) represents
 *  the window start time.  That event (s) is itself a stream whose first event (t)
 *  represents the window end time
 * @returns {Stream} new stream containing only events within the provided timespan
 */
Stream.prototype.during = function(timeWindow) {
	return timeslice.during(timeWindow, this);
};

//-----------------------------------------------------------------------
// Delaying

var delay = require('./lib/combinator/delay').delay;

exports.delay = delay;

/**
 * @param {Number} delayTime milliseconds to delay each item
 * @returns {Stream} new stream containing the same items, but delayed by ms
 */
Stream.prototype.delay = function(delayTime) {
	return delay(delayTime, this);
};

//-----------------------------------------------------------------------
// Getting event timestamp

var timestamp = require('./lib/combinator/timestamp').timestamp;

exports.timestamp = timestamp;

/**
 * Expose event timestamps into the stream. Turns a Stream<X> into
 * Stream<{time:t, value:X}>
 * @returns {Stream<{time:number, value:*}>}
 */
Stream.prototype.timestamp = function() {
	return timestamp(this);
};

//-----------------------------------------------------------------------
// Rate limiting

var limit = require('./lib/combinator/limit');

exports.throttle = limit.throttle;
exports.debounce = limit.debounce;

/**
 * Limit the rate of events
 * stream:              abcd----abcd----
 * throttle(2, stream): a-c-----a-c-----
 * @param {Number} period time to suppress events
 * @returns {Stream} new stream that skips events for throttle period
 */
Stream.prototype.throttle = function(period) {
	return limit.throttle(period, this);
};

/**
 * Wait for a burst of events to subside and emit only the last event in the burst
 * stream:              abcd----abcd----
 * debounce(2, stream): -----d-------d--
 * @param {Number} period events occuring more frequently than this
 *  on the provided scheduler will be suppressed
 * @returns {Stream} new debounced stream
 */
Stream.prototype.debounce = function(period) {
	return limit.debounce(period, this);
};

//-----------------------------------------------------------------------
// Awaiting Promises

var promises = require('./lib/combinator/promises');

exports.fromPromise = promises.fromPromise;
exports.await       = promises.awaitPromises;

/**
 * Await promises, turning a Stream<Promise<X>> into Stream<X>.  Preserves
 * event order, but timeshifts events based on promise resolution time.
 * @returns {Stream<X>} stream containing non-promise values
 */
Stream.prototype.await = function() {
	return promises.awaitPromises(this);
};

//-----------------------------------------------------------------------
// Error handling

var errors = require('./lib/combinator/errors');

exports.recoverWith  = errors.flatMapError;
exports.flatMapError = errors.flatMapError;
exports.throwError   = errors.throwError;

/**
 * If this stream encounters an error, recover and continue with items from stream
 * returned by f.
 * stream:                  -a-b-c-X-
 * f(X):                           d-e-f-g-
 * flatMapError(f, stream): -a-b-c-d-e-f-g-
 * @param {function(error:*):Stream} f function which returns a new stream
 * @returns {Stream} new stream which will recover from an error by calling f
 */
Stream.prototype.recoverWith = Stream.prototype.flatMapError = function(f) {
	return errors.flatMapError(f, this);
};

//-----------------------------------------------------------------------
// Multicasting

var multicast = require('@most/multicast').default;

exports.multicast = multicast;

/**
 * Transform the stream into multicast stream.  That means that many subscribers
 * to the stream will not cause multiple invocations of the internal machinery.
 * @returns {Stream} new stream which will multicast events to all observers.
 */
Stream.prototype.multicast = function() {
	return multicast(this);
};

},{"./lib/Stream":5,"./lib/combinator/accumulate":6,"./lib/combinator/applicative":7,"./lib/combinator/build":8,"./lib/combinator/combine":9,"./lib/combinator/concatMap":10,"./lib/combinator/continueWith":11,"./lib/combinator/delay":12,"./lib/combinator/errors":13,"./lib/combinator/filter":14,"./lib/combinator/flatMap":15,"./lib/combinator/limit":16,"./lib/combinator/loop":17,"./lib/combinator/merge":18,"./lib/combinator/mergeConcurrently":19,"./lib/combinator/observe":20,"./lib/combinator/promises":21,"./lib/combinator/sample":22,"./lib/combinator/slice":23,"./lib/combinator/switch":24,"./lib/combinator/thru":25,"./lib/combinator/timeslice":26,"./lib/combinator/timestamp":27,"./lib/combinator/transduce":28,"./lib/combinator/transform":29,"./lib/combinator/zip":30,"./lib/observable/subscribe":43,"./lib/source/core":57,"./lib/source/create":58,"./lib/source/from":59,"./lib/source/fromEvent":61,"./lib/source/generate":63,"./lib/source/iterate":64,"./lib/source/periodic":65,"./lib/source/unfold":67,"@most/multicast":68,"@most/prelude":69,"symbol-observable":70}]},{},[])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/process/browser.js","lib/LinkedList.js","lib/Promise.js","lib/Queue.js","lib/Stream.js","lib/combinator/accumulate.js","lib/combinator/applicative.js","lib/combinator/build.js","lib/combinator/combine.js","lib/combinator/concatMap.js","lib/combinator/continueWith.js","lib/combinator/delay.js","lib/combinator/errors.js","lib/combinator/filter.js","lib/combinator/flatMap.js","lib/combinator/limit.js","lib/combinator/loop.js","lib/combinator/merge.js","lib/combinator/mergeConcurrently.js","lib/combinator/observe.js","lib/combinator/promises.js","lib/combinator/sample.js","lib/combinator/slice.js","lib/combinator/switch.js","lib/combinator/thru.js","lib/combinator/timeslice.js","lib/combinator/timestamp.js","lib/combinator/transduce.js","lib/combinator/transform.js","lib/combinator/zip.js","lib/defer.js","lib/disposable/Disposable.js","lib/disposable/SettableDisposable.js","lib/disposable/dispose.js","lib/fatalError.js","lib/fusion/Filter.js","lib/fusion/FilterMap.js","lib/fusion/Map.js","lib/invoke.js","lib/iterable.js","lib/observable/fromObservable.js","lib/observable/getObservable.js","lib/observable/subscribe.js","lib/runSource.js","lib/scheduler/PropagateTask.js","lib/scheduler/Scheduler.js","lib/scheduler/defaultScheduler.js","lib/scheduler/nodeTimer.js","lib/scheduler/timeoutTimer.js","lib/sink/DeferredSink.js","lib/sink/IndexSink.js","lib/sink/Observer.js","lib/sink/Pipe.js","lib/sink/SafeSink.js","lib/source/EventEmitterSource.js","lib/source/EventTargetSource.js","lib/source/core.js","lib/source/create.js","lib/source/from.js","lib/source/fromArray.js","lib/source/fromEvent.js","lib/source/fromIterable.js","lib/source/generate.js","lib/source/iterate.js","lib/source/periodic.js","lib/source/tryEvent.js","lib/source/unfold.js","node_modules/@most/multicast/dist/multicast.js","node_modules/@most/prelude/dist/prelude.js","node_modules/symbol-observable/index.js","node_modules/symbol-observable/ponyfill.js","most.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACh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nLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canMutationObserver = typeof window !== 'undefined'\n    && window.MutationObserver;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    var queue = [];\n\n    if (canMutationObserver) {\n        var hiddenDiv = document.createElement(\"div\");\n        var observer = new MutationObserver(function () {\n            var queueList = queue.slice();\n            queue.length = 0;\n            queueList.forEach(function (fn) {\n                fn();\n            });\n        });\n\n        observer.observe(hiddenDiv, { attributes: true });\n\n        return function nextTick(fn) {\n            if (!queue.length) {\n                hiddenDiv.setAttribute('yes', 'no');\n            }\n            queue.push(fn);\n        };\n    }\n\n    if (canPost) {\n        window.addEventListener('message', function (ev) {\n            var source = ev.source;\n            if ((source === window || source === null) && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = LinkedList;\n\n/**\n * Doubly linked list\n * @constructor\n */\nfunction LinkedList() {\n\tthis.head = null;\n\tthis.length = 0;\n}\n\n/**\n * Add a node to the end of the list\n * @param {{prev:Object|null, next:Object|null, dispose:function}} x node to add\n */\nLinkedList.prototype.add = function(x) {\n\tif(this.head !== null) {\n\t\tthis.head.prev = x;\n\t\tx.next = this.head;\n\t}\n\tthis.head = x;\n\t++this.length;\n};\n\n/**\n * Remove the provided node from the list\n * @param {{prev:Object|null, next:Object|null, dispose:function}} x node to remove\n */\nLinkedList.prototype.remove = function(x) {\n\t--this.length;\n\tif(x === this.head) {\n\t\tthis.head = this.head.next;\n\t}\n\tif(x.next !== null) {\n\t\tx.next.prev = x.prev;\n\t\tx.next = null;\n\t}\n\tif(x.prev !== null) {\n\t\tx.prev.next = x.next;\n\t\tx.prev = null;\n\t}\n};\n\n/**\n * @returns {boolean} true iff there are no nodes in the list\n */\nLinkedList.prototype.isEmpty = function() {\n\treturn this.length === 0;\n};\n\n/**\n * Dispose all nodes\n * @returns {Promise} promise that fulfills when all nodes have been disposed,\n *  or rejects if an error occurs while disposing\n */\nLinkedList.prototype.dispose = function() {\n\tif(this.isEmpty()) {\n\t\treturn Promise.resolve();\n\t}\n\n\tvar promises = [];\n\tvar x = this.head;\n\tthis.head = null;\n\tthis.length = 0;\n\n\twhile(x !== null) {\n\t\tpromises.push(x.dispose());\n\t\tx = x.next;\n\t}\n\n\treturn Promise.all(promises);\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nexports.isPromise = isPromise;\n\nfunction isPromise(p) {\n\treturn p !== null && typeof p === 'object' && typeof p.then === 'function';\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\n// Based on https://github.com/petkaantonov/deque\n\nmodule.exports = Queue;\n\nfunction Queue(capPow2) {\n\tthis._capacity = capPow2||32;\n\tthis._length = 0;\n\tthis._head = 0;\n}\n\nQueue.prototype.push = function (x) {\n\tvar len = this._length;\n\tthis._checkCapacity(len + 1);\n\n\tvar i = (this._head + len) & (this._capacity - 1);\n\tthis[i] = x;\n\tthis._length = len + 1;\n};\n\nQueue.prototype.shift = function () {\n\tvar head = this._head;\n\tvar x = this[head];\n\n\tthis[head] = void 0;\n\tthis._head = (head + 1) & (this._capacity - 1);\n\tthis._length--;\n\treturn x;\n};\n\nQueue.prototype.isEmpty = function() {\n\treturn this._length === 0;\n};\n\nQueue.prototype.length = function () {\n\treturn this._length;\n};\n\nQueue.prototype._checkCapacity = function (size) {\n\tif (this._capacity < size) {\n\t\tthis._ensureCapacity(this._capacity << 1);\n\t}\n};\n\nQueue.prototype._ensureCapacity = function (capacity) {\n\tvar oldCapacity = this._capacity;\n\tthis._capacity = capacity;\n\n\tvar last = this._head + this._length;\n\n\tif (last > oldCapacity) {\n\t\tcopy(this, 0, this, oldCapacity, last & (oldCapacity - 1));\n\t}\n};\n\nfunction copy(src, srcIndex, dst, dstIndex, len) {\n\tfor (var j = 0; j < len; ++j) {\n\t\tdst[j + dstIndex] = src[j + srcIndex];\n\t\tsrc[j + srcIndex] = void 0;\n\t}\n}\n\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = Stream;\n\nfunction Stream(source) {\n\tthis.source = source;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Pipe = require('../sink/Pipe');\nvar runSource = require('../runSource');\nvar dispose = require('../disposable/dispose');\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.scan = scan;\nexports.reduce = reduce;\n\n/**\n * Create a stream containing successive reduce results of applying f to\n * the previous reduce result and the current stream item.\n * @param {function(result:*, x:*):*} f reducer function\n * @param {*} initial initial value\n * @param {Stream} stream stream to scan\n * @returns {Stream} new stream containing successive reduce results\n */\nfunction scan(f, initial, stream) {\n\treturn new Stream(new Scan(f, initial, stream.source));\n}\n\nfunction Scan(f, z, source) {\n\tthis.source = source;\n\tthis.f = f;\n\tthis.value = z;\n}\n\nScan.prototype.run = function(sink, scheduler) {\n\tvar d1 = scheduler.asap(PropagateTask.event(this.value, sink));\n\tvar d2 = this.source.run(new ScanSink(this.f, this.value, sink), scheduler);\n\treturn dispose.all([d1, d2]);\n};\n\nfunction ScanSink(f, z, sink) {\n\tthis.f = f;\n\tthis.value = z;\n\tthis.sink = sink;\n}\n\nScanSink.prototype.event = function(t, x) {\n\tvar f = this.f;\n\tthis.value = f(this.value, x);\n\tthis.sink.event(t, this.value);\n};\n\nScanSink.prototype.error = Pipe.prototype.error;\nScanSink.prototype.end = Pipe.prototype.end;\n\n/**\n * Reduce a stream to produce a single result.  Note that reducing an infinite\n * stream will return a Promise that never fulfills, but that may reject if an error\n * occurs.\n * @param {function(result:*, x:*):*} f reducer function\n * @param {*} initial initial value\n * @param {Stream} stream to reduce\n * @returns {Promise} promise for the file result of the reduce\n */\nfunction reduce(f, initial, stream) {\n\treturn runSource.withDefaultScheduler(noop, new Reduce(f, initial, stream.source));\n}\n\nfunction Reduce(f, z, source) {\n\tthis.source = source;\n\tthis.f = f;\n\tthis.value = z;\n}\n\nReduce.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new ReduceSink(this.f, this.value, sink), scheduler);\n};\n\nfunction ReduceSink(f, z, sink) {\n\tthis.f = f;\n\tthis.value = z;\n\tthis.sink = sink;\n}\n\nReduceSink.prototype.event = function(t, x) {\n\tvar f = this.f;\n\tthis.value = f(this.value, x);\n\tthis.sink.event(t, this.value);\n};\n\nReduceSink.prototype.error = Pipe.prototype.error;\n\nReduceSink.prototype.end = function(t) {\n\tthis.sink.end(t, this.value);\n};\n\nfunction noop() {}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar combine = require('./combine').combine;\nvar apply = require('@most/prelude').apply;\n\nexports.ap  = ap;\n\n/**\n * Assume fs is a stream containing functions, and apply the latest function\n * in fs to the latest value in xs.\n * fs:         --f---------g--------h------>\n * xs:         -a-------b-------c-------d-->\n * ap(fs, xs): --fa-----fb-gb---gc--hc--hd->\n * @param {Stream} fs stream of functions to apply to the latest x\n * @param {Stream} xs stream of values to which to apply all the latest f\n * @returns {Stream} stream containing all the applications of fs to xs\n */\nfunction ap(fs, xs) {\n\treturn combine(apply, fs, xs);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar streamOf = require('../source/core').of;\nvar continueWith = require('./continueWith').continueWith;\n\nexports.concat = concat;\nexports.cycle = cycle;\nexports.cons = cons;\n\n/**\n * @param {*} x value to prepend\n * @param {Stream} stream\n * @returns {Stream} new stream with x prepended\n */\nfunction cons(x, stream) {\n\treturn concat(streamOf(x), stream);\n}\n\n/**\n * @param {Stream} left\n * @param {Stream} right\n * @returns {Stream} new stream containing all events in left followed by all\n *  events in right.  This *timeshifts* right to the end of left.\n */\nfunction concat(left, right) {\n\treturn continueWith(function() {\n\t\treturn right;\n\t}, left);\n}\n\n/**\n * @deprecated\n * Tie stream into a circle, creating an infinite stream\n * @param {Stream} stream\n * @returns {Stream} new infinite stream\n */\nfunction cycle(stream) {\n\treturn continueWith(function cycleNext() {\n\t\treturn cycle(stream);\n\t}, stream);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar transform = require('./transform');\nvar core = require('../source/core');\nvar Pipe = require('../sink/Pipe');\nvar IndexSink = require('../sink/IndexSink');\nvar dispose = require('../disposable/dispose');\nvar base = require('@most/prelude');\nvar invoke = require('../invoke');\n\nvar map = base.map;\nvar tail = base.tail;\n\nexports.combineArray = combineArray;\nexports.combine = combine;\n\n/**\n * Combine latest events from all input streams\n * @param {function(...events):*} f function to combine most recent events\n * @returns {Stream} stream containing the result of applying f to the most recent\n *  event of each input stream, whenever a new event arrives on any stream.\n */\nfunction combine(f /*, ...streams */) {\n\treturn combineArray(f, tail(arguments));\n}\n\n/**\n * Combine latest events from all input streams\n * @param {function(...events):*} f function to combine most recent events\n * @param {[Stream]} streams most recent events\n * @returns {Stream} stream containing the result of applying f to the most recent\n *  event of each input stream, whenever a new event arrives on any stream.\n */\nfunction combineArray(f, streams) {\n\tvar l = streams.length;\n\treturn l === 0 ? core.empty()\n\t\t : l === 1 ? transform.map(f, streams[0])\n\t\t : new Stream(combineSources(f, streams));\n}\n\nfunction combineSources(f, streams) {\n\treturn new Combine(f, map(getSource, streams))\n}\n\nfunction getSource(stream) {\n\treturn stream.source;\n}\n\nfunction Combine(f, sources) {\n\tthis.f = f;\n\tthis.sources = sources;\n}\n\nCombine.prototype.run = function(sink, scheduler) {\n\tvar l = this.sources.length;\n\tvar disposables = new Array(l);\n\tvar sinks = new Array(l);\n\n\tvar mergeSink = new CombineSink(disposables, sinks, sink, this.f);\n\n\tfor(var indexSink, i=0; i<l; ++i) {\n\t\tindexSink = sinks[i] = new IndexSink(i, mergeSink);\n\t\tdisposables[i] = this.sources[i].run(indexSink, scheduler);\n\t}\n\n\treturn dispose.all(disposables);\n};\n\nfunction CombineSink(disposables, sinks, sink, f) {\n\tthis.sink = sink;\n\tthis.disposables = disposables;\n\tthis.sinks = sinks;\n\tthis.f = f;\n\n\tvar l = sinks.length;\n\tthis.awaiting = l;\n\tthis.values = new Array(l);\n\tthis.hasValue = new Array(l);\n\tfor(var i = 0; i < l; ++i) {\n\t\tthis.hasValue[i] = false;\n\t}\n\n\tthis.activeCount = sinks.length;\n}\n\nCombineSink.prototype.error = Pipe.prototype.error;\n\nCombineSink.prototype.event = function(t, indexedValue) {\n\tvar i = indexedValue.index;\n\tvar awaiting = this._updateReady(i);\n\n\tthis.values[i] = indexedValue.value;\n\tif(awaiting === 0) {\n\t\tthis.sink.event(t, invoke(this.f, this.values));\n\t}\n};\n\nCombineSink.prototype._updateReady = function(index) {\n\tif(this.awaiting > 0) {\n\t\tif(!this.hasValue[index]) {\n\t\t\tthis.hasValue[index] = true\n\t\t\tthis.awaiting -= 1\n\t\t}\n\t}\n\treturn this.awaiting;\n}\n\nCombineSink.prototype.end = function(t, indexedValue) {\n\tdispose.tryDispose(t, this.disposables[indexedValue.index], this.sink);\n\tif(--this.activeCount === 0) {\n\t\tthis.sink.end(t, indexedValue.value);\n\t}\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar mergeMapConcurrently = require('./mergeConcurrently').mergeMapConcurrently;\n\nexports.concatMap = concatMap;\n\n/**\n * Map each value in stream to a new stream, and concatenate them all\n * stream:              -a---b---cX\n * f(a):                 1-1-1-1X\n * f(b):                        -2-2-2-2X\n * f(c):                                -3-3-3-3X\n * stream.concatMap(f): -1-1-1-1-2-2-2-2-3-3-3-3X\n * @param {function(x:*):Stream} f function to map each value to a stream\n * @param {Stream} stream\n * @returns {Stream} new stream containing all events from each stream returned by f\n */\nfunction concatMap(f, stream) {\n\treturn mergeMapConcurrently(f, 1, stream);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Sink = require('../sink/Pipe');\nvar dispose = require('../disposable/dispose');\nvar isPromise = require('../Promise').isPromise;\n\nexports.continueWith = continueWith;\n\nfunction continueWith(f, stream) {\n\treturn new Stream(new ContinueWith(f, stream.source));\n}\n\nfunction ContinueWith(f, source) {\n\tthis.f = f;\n\tthis.source = source;\n}\n\nContinueWith.prototype.run = function(sink, scheduler) {\n\treturn new ContinueWithSink(this.f, this.source, sink, scheduler);\n};\n\nfunction ContinueWithSink(f, source, sink, scheduler) {\n\tthis.f = f;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.active = true;\n\tthis.disposable = dispose.once(source.run(this, scheduler));\n}\n\nContinueWithSink.prototype.error = Sink.prototype.error;\n\nContinueWithSink.prototype.event = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis.sink.event(t, x);\n};\n\nContinueWithSink.prototype.end = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\n\tdispose.tryDispose(t, this.disposable, this.sink);\n\tthis._startNext(t, x, this.sink);\n};\n\nContinueWithSink.prototype._startNext = function(t, x, sink) {\n\ttry {\n\t\tthis.disposable = this._continue(this.f, x, sink);\n\t} catch(e) {\n\t\tsink.error(t, e);\n\t}\n};\n\nContinueWithSink.prototype._continue = function(f, x, sink) {\n\treturn f(x).source.run(sink, this.scheduler);\n};\n\nContinueWithSink.prototype.dispose = function() {\n\tthis.active = false;\n\treturn this.disposable.dispose();\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Sink = require('../sink/Pipe');\nvar dispose = require('../disposable/dispose');\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.delay = delay;\n\n/**\n * @param {Number} delayTime milliseconds to delay each item\n * @param {Stream} stream\n * @returns {Stream} new stream containing the same items, but delayed by ms\n */\nfunction delay(delayTime, stream) {\n\treturn delayTime <= 0 ? stream\n\t\t : new Stream(new Delay(delayTime, stream.source));\n}\n\nfunction Delay(dt, source) {\n\tthis.dt = dt;\n\tthis.source = source;\n}\n\nDelay.prototype.run = function(sink, scheduler) {\n\tvar delaySink = new DelaySink(this.dt, sink, scheduler);\n\treturn dispose.all([delaySink, this.source.run(delaySink, scheduler)]);\n};\n\nfunction DelaySink(dt, sink, scheduler) {\n\tthis.dt = dt;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n}\n\nDelaySink.prototype.dispose = function() {\n\tvar self = this;\n\tthis.scheduler.cancelAll(function(task) {\n\t\treturn task.sink === self.sink;\n\t});\n};\n\nDelaySink.prototype.event = function(t, x) {\n\tthis.scheduler.delay(this.dt, PropagateTask.event(x, this.sink));\n};\n\nDelaySink.prototype.end = function(t, x) {\n\tthis.scheduler.delay(this.dt, PropagateTask.end(x, this.sink));\n};\n\nDelaySink.prototype.error = Sink.prototype.error;\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar SafeSink = require('../sink/SafeSink');\nvar Pipe = require('../sink/Pipe');\nvar dispose = require('../disposable/dispose');\nvar tryEvent = require('../source/tryEvent');\nvar isPromise = require('../Promise').isPromise;\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.flatMapError = recoverWith;\nexports.recoverWith  = recoverWith;\nexports.throwError   = throwError;\n\n/**\n * If stream encounters an error, recover and continue with items from stream\n * returned by f.\n * @param {function(error:*):Stream} f function which returns a new stream\n * @param {Stream} stream\n * @returns {Stream} new stream which will recover from an error by calling f\n */\nfunction recoverWith(f, stream) {\n\treturn new Stream(new RecoverWith(f, stream.source));\n}\n\n/**\n * Create a stream containing only an error\n * @param {*} e error value, preferably an Error or Error subtype\n * @returns {Stream} new stream containing only an error\n */\nfunction throwError(e) {\n\treturn new Stream(new ErrorSource(e));\n}\n\nfunction ErrorSource(e) {\n\tthis.value = e;\n}\n\nErrorSource.prototype.run = function(sink, scheduler) {\n\treturn scheduler.asap(new PropagateTask(runError, this.value, sink));\n};\n\nfunction runError(t, e, sink) {\n\tsink.error(t, e);\n}\n\nfunction RecoverWith(f, source) {\n\tthis.f = f;\n\tthis.source = source;\n}\n\nRecoverWith.prototype.run = function(sink, scheduler) {\n\treturn new RecoverWithSink(this.f, this.source, sink, scheduler);\n};\n\nfunction RecoverWithSink(f, source, sink, scheduler) {\n\tthis.f = f;\n\tthis.sink = new SafeSink(sink);\n\tthis.scheduler = scheduler;\n\tthis.disposable = source.run(this, scheduler);\n}\n\nRecoverWithSink.prototype.event = function(t, x) {\n\t\ttryEvent.tryEvent(t, x, this.sink);\n}\n\nRecoverWithSink.prototype.end = function(t, x) {\n\t\ttryEvent.tryEnd(t, x, this.sink);\n}\n\nRecoverWithSink.prototype.error = function(t, e) {\n\tvar nextSink = this.sink.disable();\n\n\tdispose.tryDispose(t, this.disposable, this.sink);\n\tthis._startNext(t, e, nextSink);\n};\n\nRecoverWithSink.prototype._startNext = function(t, x, sink) {\n\ttry {\n\t\tthis.disposable = this._continue(this.f, x, sink);\n\t} catch(e) {\n\t\tsink.error(t, e);\n\t}\n};\n\nRecoverWithSink.prototype._continue = function(f, x, sink) {\n\tvar stream = f(x);\n\treturn stream.source.run(sink, this.scheduler);\n};\n\nRecoverWithSink.prototype.dispose = function() {\n\treturn this.disposable.dispose();\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Sink = require('../sink/Pipe');\nvar Filter = require('../fusion/Filter');\n\nexports.filter = filter;\nexports.skipRepeats = skipRepeats;\nexports.skipRepeatsWith = skipRepeatsWith;\n\n/**\n * Retain only items matching a predicate\n * @param {function(x:*):boolean} p filtering predicate called for each item\n * @param {Stream} stream stream to filter\n * @returns {Stream} stream containing only items for which predicate returns truthy\n */\nfunction filter(p, stream) {\n\treturn new Stream(Filter.create(p, stream.source));\n}\n\n/**\n * Skip repeated events, using === to detect duplicates\n * @param {Stream} stream stream from which to omit repeated events\n * @returns {Stream} stream without repeated events\n */\nfunction skipRepeats(stream) {\n\treturn skipRepeatsWith(same, stream);\n}\n\n/**\n * Skip repeated events using the provided equals function to detect duplicates\n * @param {function(a:*, b:*):boolean} equals optional function to compare items\n * @param {Stream} stream stream from which to omit repeated events\n * @returns {Stream} stream without repeated events\n */\nfunction skipRepeatsWith(equals, stream) {\n\treturn new Stream(new SkipRepeats(equals, stream.source));\n}\n\nfunction SkipRepeats(equals, source) {\n\tthis.equals = equals;\n\tthis.source = source;\n}\n\nSkipRepeats.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new SkipRepeatsSink(this.equals, sink), scheduler);\n};\n\nfunction SkipRepeatsSink(equals, sink) {\n\tthis.equals = equals;\n\tthis.sink = sink;\n\tthis.value = void 0;\n\tthis.init = true;\n}\n\nSkipRepeatsSink.prototype.end   = Sink.prototype.end;\nSkipRepeatsSink.prototype.error = Sink.prototype.error;\n\nSkipRepeatsSink.prototype.event = function(t, x) {\n\tif(this.init) {\n\t\tthis.init = false;\n\t\tthis.value = x;\n\t\tthis.sink.event(t, x);\n\t} else if(!this.equals(this.value, x)) {\n\t\tthis.value = x;\n\t\tthis.sink.event(t, x);\n\t}\n};\n\nfunction same(a, b) {\n\treturn a === b;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar mergeConcurrently = require('./mergeConcurrently').mergeConcurrently;\nvar mergeMapConcurrently = require('./mergeConcurrently').mergeMapConcurrently;\n\nexports.flatMap = flatMap;\nexports.join = join;\n\n/**\n * Map each value in the stream to a new stream, and merge it into the\n * returned outer stream. Event arrival times are preserved.\n * @param {function(x:*):Stream} f chaining function, must return a Stream\n * @param {Stream} stream\n * @returns {Stream} new stream containing all events from each stream returned by f\n */\nfunction flatMap(f, stream) {\n\treturn mergeMapConcurrently(f, Infinity, stream);\n}\n\n/**\n * Monadic join. Flatten a Stream<Stream<X>> to Stream<X> by merging inner\n * streams to the outer. Event arrival times are preserved.\n * @param {Stream<Stream<X>>} stream stream of streams\n * @returns {Stream<X>} new stream containing all events of all inner streams\n */\nfunction join(stream) {\n\treturn mergeConcurrently(Infinity, stream);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Sink = require('../sink/Pipe');\nvar dispose = require('../disposable/dispose');\nvar PropagateTask = require('../scheduler/PropagateTask');\nvar Map = require('../fusion/Map');\n\nexports.throttle = throttle;\nexports.debounce = debounce;\n\n/**\n * Limit the rate of events by suppressing events that occur too often\n * @param {Number} period time to suppress events\n * @param {Stream} stream\n * @returns {Stream}\n */\nfunction throttle(period, stream) {\n\treturn new Stream(throttleSource(period, stream.source));\n}\n\nfunction throttleSource(period, source) {\n\treturn source instanceof Map ? commuteMapThrottle(period, source)\n\t\t: source instanceof Throttle ? fuseThrottle(period, source)\n\t\t: new Throttle(period, source)\n}\n\nfunction commuteMapThrottle(period, source) {\n\treturn Map.create(source.f, throttleSource(period, source.source))\n}\n\nfunction fuseThrottle(period, source) {\n\treturn new Throttle(Math.max(period, source.period), source.source)\n}\n\nfunction Throttle(period, source) {\n\tthis.period = period;\n\tthis.source = source;\n}\n\nThrottle.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new ThrottleSink(this.period, sink), scheduler);\n};\n\nfunction ThrottleSink(period, sink) {\n\tthis.time = 0;\n\tthis.period = period;\n\tthis.sink = sink;\n}\n\nThrottleSink.prototype.event = function(t, x) {\n\tif(t >= this.time) {\n\t\tthis.time = t + this.period;\n\t\tthis.sink.event(t, x);\n\t}\n};\n\nThrottleSink.prototype.end   = Sink.prototype.end;\n\nThrottleSink.prototype.error = Sink.prototype.error;\n\n/**\n * Wait for a burst of events to subside and emit only the last event in the burst\n * @param {Number} period events occuring more frequently than this\n *  will be suppressed\n * @param {Stream} stream stream to debounce\n * @returns {Stream} new debounced stream\n */\nfunction debounce(period, stream) {\n\treturn new Stream(new Debounce(period, stream.source));\n}\n\nfunction Debounce(dt, source) {\n\tthis.dt = dt;\n\tthis.source = source;\n}\n\nDebounce.prototype.run = function(sink, scheduler) {\n\treturn new DebounceSink(this.dt, this.source, sink, scheduler);\n};\n\nfunction DebounceSink(dt, source, sink, scheduler) {\n\tthis.dt = dt;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.value = void 0;\n\tthis.timer = null;\n\n\tvar sourceDisposable = source.run(this, scheduler);\n\tthis.disposable = dispose.all([this, sourceDisposable]);\n}\n\nDebounceSink.prototype.event = function(t, x) {\n\tthis._clearTimer();\n\tthis.value = x;\n\tthis.timer = this.scheduler.delay(this.dt, PropagateTask.event(x, this.sink));\n};\n\nDebounceSink.prototype.end = function(t, x) {\n\tif(this._clearTimer()) {\n\t\tthis.sink.event(t, this.value);\n\t\tthis.value = void 0;\n\t}\n\tthis.sink.end(t, x);\n};\n\nDebounceSink.prototype.error = function(t, x) {\n\tthis._clearTimer();\n\tthis.sink.error(t, x);\n};\n\nDebounceSink.prototype.dispose = function() {\n\tthis._clearTimer();\n};\n\nDebounceSink.prototype._clearTimer = function() {\n\tif(this.timer === null) {\n\t\treturn false;\n\t}\n\tthis.timer.dispose();\n\tthis.timer = null;\n\treturn true;\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Pipe = require('../sink/Pipe');\n\nexports.loop = loop;\n\n/**\n * Generalized feedback loop. Call a stepper function for each event. The stepper\n * will be called with 2 params: the current seed and the an event value.  It must\n * return a new { seed, value } pair. The `seed` will be fed back into the next\n * invocation of stepper, and the `value` will be propagated as the event value.\n * @param {function(seed:*, value:*):{seed:*, value:*}} stepper loop step function\n * @param {*} seed initial seed value passed to first stepper call\n * @param {Stream} stream event stream\n * @returns {Stream} new stream whose values are the `value` field of the objects\n * returned by the stepper\n */\nfunction loop(stepper, seed, stream) {\n\treturn new Stream(new Loop(stepper, seed, stream.source));\n}\n\nfunction Loop(stepper, seed, source) {\n\tthis.step = stepper;\n\tthis.seed = seed;\n\tthis.source = source;\n}\n\nLoop.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new LoopSink(this.step, this.seed, sink), scheduler);\n};\n\nfunction LoopSink(stepper, seed, sink) {\n\tthis.step = stepper;\n\tthis.seed = seed;\n\tthis.sink = sink;\n}\n\nLoopSink.prototype.error = Pipe.prototype.error;\n\nLoopSink.prototype.event = function(t, x) {\n\tvar result = this.step(this.seed, x);\n\tthis.seed = result.seed;\n\tthis.sink.event(t, result.value);\n};\n\nLoopSink.prototype.end = function(t) {\n\tthis.sink.end(t, this.seed);\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Pipe = require('../sink/Pipe');\nvar IndexSink = require('../sink/IndexSink');\nvar empty = require('../source/core').empty;\nvar dispose = require('../disposable/dispose');\nvar base = require('@most/prelude');\n\nvar copy = base.copy;\nvar reduce = base.reduce;\n\nexports.merge = merge;\nexports.mergeArray = mergeArray;\n\n/**\n * @returns {Stream} stream containing events from all streams in the argument\n * list in time order.  If two events are simultaneous they will be merged in\n * arbitrary order.\n */\nfunction merge(/*...streams*/) {\n\treturn mergeArray(copy(arguments));\n}\n\n/**\n * @param {Array} streams array of stream to merge\n * @returns {Stream} stream containing events from all input observables\n * in time order.  If two events are simultaneous they will be merged in\n * arbitrary order.\n */\nfunction mergeArray(streams) {\n    var l = streams.length;\n    return l === 0 ? empty()\n\t\t : l === 1 ? streams[0]\n\t\t : new Stream(mergeSources(streams));\n}\n\n/**\n * This implements fusion/flattening for merge.  It will\n * fuse adjacent merge operations.  For example:\n * - a.merge(b).merge(c) effectively becomes merge(a, b, c)\n * - merge(a, merge(b, c)) effectively becomes merge(a, b, c)\n * It does this by concatenating the sources arrays of\n * any nested Merge sources, in effect \"flattening\" nested\n * merge operations into a single merge.\n */\nfunction mergeSources(streams) {\n\treturn new Merge(reduce(appendSources, [], streams))\n}\n\nfunction appendSources(sources, stream) {\n\tvar source = stream.source;\n\treturn source instanceof Merge\n\t\t? sources.concat(source.sources)\n\t\t: sources.concat(source)\n}\n\nfunction Merge(sources) {\n\tthis.sources = sources;\n}\n\nMerge.prototype.run = function(sink, scheduler) {\n\tvar l = this.sources.length;\n\tvar disposables = new Array(l);\n\tvar sinks = new Array(l);\n\n\tvar mergeSink = new MergeSink(disposables, sinks, sink);\n\n\tfor(var indexSink, i=0; i<l; ++i) {\n\t\tindexSink = sinks[i] = new IndexSink(i, mergeSink);\n\t\tdisposables[i] = this.sources[i].run(indexSink, scheduler);\n\t}\n\n\treturn dispose.all(disposables);\n};\n\nfunction MergeSink(disposables, sinks, sink) {\n\tthis.sink = sink;\n\tthis.disposables = disposables;\n\tthis.activeCount = sinks.length;\n}\n\nMergeSink.prototype.error = Pipe.prototype.error;\n\nMergeSink.prototype.event = function(t, indexValue) {\n\tthis.sink.event(t, indexValue.value);\n};\n\nMergeSink.prototype.end = function(t, indexedValue) {\n\tdispose.tryDispose(t, this.disposables[indexedValue.index], this.sink);\n\tif(--this.activeCount === 0) {\n\t\tthis.sink.end(t, indexedValue.value);\n\t}\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar dispose = require('../disposable/dispose');\nvar LinkedList = require('../LinkedList');\nvar identity = require('@most/prelude').id;\n\nexports.mergeConcurrently = mergeConcurrently;\nexports.mergeMapConcurrently = mergeMapConcurrently;\n\nfunction mergeConcurrently(concurrency, stream) {\n\treturn mergeMapConcurrently(identity, concurrency, stream);\n}\n\nfunction mergeMapConcurrently(f, concurrency, stream) {\n\treturn new Stream(new MergeConcurrently(f, concurrency, stream.source));\n}\n\nfunction MergeConcurrently(f, concurrency, source) {\n\tthis.f = f;\n\tthis.concurrency = concurrency;\n\tthis.source = source;\n}\n\nMergeConcurrently.prototype.run = function(sink, scheduler) {\n\treturn new Outer(this.f, this.concurrency, this.source, sink, scheduler);\n};\n\nfunction Outer(f, concurrency, source, sink, scheduler) {\n\tthis.f = f;\n\tthis.concurrency = concurrency;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.pending = [];\n\tthis.current = new LinkedList();\n\tthis.disposable = dispose.once(source.run(this, scheduler));\n\tthis.active = true;\n}\n\nOuter.prototype.event = function(t, x) {\n\tthis._addInner(t, x);\n};\n\nOuter.prototype._addInner = function(t, x) {\n\tif(this.current.length < this.concurrency) {\n\t\tthis._startInner(t, x);\n\t} else {\n\t\tthis.pending.push(x);\n\t}\n};\n\nOuter.prototype._startInner = function(t, x) {\n\ttry {\n\t\tthis._initInner(t, x);\n\t} catch(e) {\n\t\tthis.error(t, e);\n\t}\n};\n\nOuter.prototype._initInner = function(t, x) {\n\tvar innerSink = new Inner(t, this, this.sink);\n\tinnerSink.disposable = mapAndRun(this.f, x, innerSink, this.scheduler);\n\tthis.current.add(innerSink);\n}\n\nfunction mapAndRun(f, x, sink, scheduler) {\n\treturn f(x).source.run(sink, scheduler);\n}\n\nOuter.prototype.end = function(t, x) {\n\tthis.active = false;\n\tdispose.tryDispose(t, this.disposable, this.sink);\n\tthis._checkEnd(t, x);\n};\n\nOuter.prototype.error = function(t, e) {\n\tthis.active = false;\n\tthis.sink.error(t, e);\n};\n\nOuter.prototype.dispose = function() {\n\tthis.active = false;\n\tthis.pending.length = 0;\n\treturn Promise.all([this.disposable.dispose(), this.current.dispose()]);\n};\n\nOuter.prototype._endInner = function(t, x, inner) {\n\tthis.current.remove(inner);\n\tdispose.tryDispose(t, inner, this);\n\n\tif(this.pending.length === 0) {\n\t\tthis._checkEnd(t, x);\n\t} else {\n\t\tthis._startInner(t, this.pending.shift());\n\t}\n};\n\nOuter.prototype._checkEnd = function(t, x) {\n\tif(!this.active && this.current.isEmpty()) {\n\t\tthis.sink.end(t, x);\n\t}\n};\n\nfunction Inner(time, outer, sink) {\n\tthis.prev = this.next = null;\n\tthis.time = time;\n\tthis.outer = outer;\n\tthis.sink = sink;\n\tthis.disposable = void 0;\n}\n\nInner.prototype.event = function(t, x) {\n\tthis.sink.event(Math.max(t, this.time), x);\n};\n\nInner.prototype.end = function(t, x) {\n\tthis.outer._endInner(Math.max(t, this.time), x, this);\n};\n\nInner.prototype.error = function(t, e) {\n\tthis.outer.error(Math.max(t, this.time), e);\n};\n\nInner.prototype.dispose = function() {\n\treturn this.disposable.dispose();\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar runSource = require('../runSource');\n\nexports.observe = observe;\nexports.drain = drain;\n\n/**\n * Observe all the event values in the stream in time order. The\n * provided function `f` will be called for each event value\n * @param {function(x:T):*} f function to call with each event value\n * @param {Stream<T>} stream stream to observe\n * @return {Promise} promise that fulfills after the stream ends without\n *  an error, or rejects if the stream ends with an error.\n */\nfunction observe(f, stream) {\n\treturn runSource.withDefaultScheduler(f, stream.source);\n}\n\n/**\n * \"Run\" a stream by\n * @param stream\n * @return {*}\n */\nfunction drain(stream) {\n\treturn runSource.withDefaultScheduler(noop, stream.source);\n}\n\nfunction noop() {}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar fatal = require('../fatalError');\nvar just = require('../source/core').of;\n\nexports.fromPromise = fromPromise;\nexports.awaitPromises = awaitPromises;\n\n/**\n * Create a stream containing only the promise's fulfillment\n * value at the time it fulfills.\n * @param {Promise<T>} p promise\n * @return {Stream<T>} stream containing promise's fulfillment value.\n *  If the promise rejects, the stream will error\n */\nfunction fromPromise(p) {\n\treturn awaitPromises(just(p));\n}\n\n/**\n * Turn a Stream<Promise<T>> into Stream<T> by awaiting each promise.\n * Event order is preserved.\n * @param {Stream<Promise<T>>} stream\n * @return {Stream<T>} stream of fulfillment values.  The stream will\n * error if any promise rejects.\n */\nfunction awaitPromises(stream) {\n\treturn new Stream(new Await(stream.source));\n}\n\nfunction Await(source) {\n\tthis.source = source;\n}\n\nAwait.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new AwaitSink(sink, scheduler), scheduler);\n};\n\nfunction AwaitSink(sink, scheduler) {\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.queue = Promise.resolve();\n\tvar self = this;\n\n\t// Pre-create closures, to avoid creating them per event\n\tthis._eventBound = function(x) {\n\t\tself.sink.event(self.scheduler.now(), x);\n\t};\n\n\tthis._endBound = function(x) {\n\t\tself.sink.end(self.scheduler.now(), x);\n\t};\n\n\tthis._errorBound = function(e) {\n\t\tself.sink.error(self.scheduler.now(), e);\n\t};\n}\n\nAwaitSink.prototype.event = function(t, promise) {\n\tvar self = this;\n\tthis.queue = this.queue.then(function() {\n\t\treturn self._event(promise);\n\t}).catch(this._errorBound);\n};\n\nAwaitSink.prototype.end = function(t, x) {\n\tvar self = this;\n\tthis.queue = this.queue.then(function() {\n\t\treturn self._end(x);\n\t}).catch(this._errorBound);\n};\n\nAwaitSink.prototype.error = function(t, e) {\n\tvar self = this;\n\t// Don't resolve error values, propagate directly\n\tthis.queue = this.queue.then(function() {\n\t\treturn self._errorBound(e);\n\t}).catch(fatal);\n};\n\nAwaitSink.prototype._event = function(promise) {\n\treturn promise.then(this._eventBound);\n};\n\nAwaitSink.prototype._end = function(x) {\n\treturn Promise.resolve(x).then(this._endBound);\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Pipe = require('../sink/Pipe');\nvar dispose = require('../disposable/dispose');\nvar base = require('@most/prelude');\nvar invoke = require('../invoke');\n\nexports.sample = sample;\nexports.sampleWith = sampleWith;\nexports.sampleArray = sampleArray;\n\n/**\n * When an event arrives on sampler, emit the result of calling f with the latest\n * values of all streams being sampled\n * @param {function(...values):*} f function to apply to each set of sampled values\n * @param {Stream} sampler streams will be sampled whenever an event arrives\n *  on sampler\n * @returns {Stream} stream of sampled and transformed values\n */\nfunction sample(f, sampler /*, ...streams */) {\n\treturn sampleArray(f, sampler, base.drop(2, arguments));\n}\n\n/**\n * When an event arrives on sampler, emit the latest event value from stream.\n * @param {Stream} sampler stream of events at whose arrival time\n *  stream's latest value will be propagated\n * @param {Stream} stream stream of values\n * @returns {Stream} sampled stream of values\n */\nfunction sampleWith(sampler, stream) {\n\treturn new Stream(new Sampler(base.id, sampler.source, [stream.source]));\n}\n\nfunction sampleArray(f, sampler, streams) {\n\treturn new Stream(new Sampler(f, sampler.source, base.map(getSource, streams)));\n}\n\nfunction getSource(stream) {\n\treturn stream.source;\n}\n\nfunction Sampler(f, sampler, sources) {\n\tthis.f = f;\n\tthis.sampler = sampler;\n\tthis.sources = sources;\n}\n\nSampler.prototype.run = function(sink, scheduler) {\n\tvar l = this.sources.length;\n\tvar disposables = new Array(l+1);\n\tvar sinks = new Array(l);\n\n\tvar sampleSink = new SampleSink(this.f, sinks, sink);\n\n\tfor(var hold, i=0; i<l; ++i) {\n\t\thold = sinks[i] = new Hold(sampleSink);\n\t\tdisposables[i] = this.sources[i].run(hold, scheduler);\n\t}\n\n\tdisposables[i] = this.sampler.run(sampleSink, scheduler);\n\n\treturn dispose.all(disposables);\n};\n\nfunction Hold(sink) {\n\tthis.sink = sink;\n\tthis.hasValue = false;\n}\n\nHold.prototype.event = function(t, x) {\n\tthis.value = x;\n\tthis.hasValue = true;\n\tthis.sink._notify(this);\n};\n\nHold.prototype.end = function () {};\nHold.prototype.error = Pipe.prototype.error;\n\nfunction SampleSink(f, sinks, sink) {\n\tthis.f = f;\n\tthis.sinks = sinks;\n\tthis.sink = sink;\n\tthis.active = false;\n}\n\nSampleSink.prototype._notify = function() {\n\tif(!this.active) {\n\t\tthis.active = this.sinks.every(hasValue);\n\t}\n};\n\nSampleSink.prototype.event = function(t) {\n\tif(this.active) {\n\t\tthis.sink.event(t, invoke(this.f, base.map(getValue, this.sinks)));\n\t}\n};\n\nSampleSink.prototype.end = Pipe.prototype.end;\nSampleSink.prototype.error = Pipe.prototype.error;\n\nfunction hasValue(hold) {\n\treturn hold.hasValue;\n}\n\nfunction getValue(hold) {\n\treturn hold.value;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Sink = require('../sink/Pipe');\nvar core = require('../source/core');\nvar dispose = require('../disposable/dispose');\nvar Map = require('../fusion/Map');\n\nexports.take = take;\nexports.skip = skip;\nexports.slice = slice;\nexports.takeWhile = takeWhile;\nexports.skipWhile = skipWhile;\n\n/**\n * @param {number} n\n * @param {Stream} stream\n * @returns {Stream} new stream containing only up to the first n items from stream\n */\nfunction take(n, stream) {\n\treturn slice(0, n, stream);\n}\n\n/**\n * @param {number} n\n * @param {Stream} stream\n * @returns {Stream} new stream with the first n items removed\n */\nfunction skip(n, stream) {\n\treturn slice(n, Infinity, stream);\n}\n\n/**\n * Slice a stream by index. Negative start/end indexes are not supported\n * @param {number} start\n * @param {number} end\n * @param {Stream} stream\n * @returns {Stream} stream containing items where start <= index < end\n */\nfunction slice(start, end, stream) {\n\treturn end <= start ? core.empty()\n\t\t: new Stream(sliceSource(start, end, stream.source));\n}\n\nfunction sliceSource(start, end, source) {\n\treturn source instanceof Map ? commuteMapSlice(start, end, source)\n\t\t: source instanceof Slice ? fuseSlice(start, end, source)\n\t\t: new Slice(start, end, source);\n}\n\nfunction commuteMapSlice(start, end, source) {\n\treturn Map.create(source.f, sliceSource(start, end, source.source))\n}\n\nfunction fuseSlice(start, end, source) {\n\tstart += source.min;\n\tend = Math.min(end + source.min, source.max);\n\treturn new Slice(start, end, source.source);\n}\n\nfunction Slice(min, max, source) {\n\tthis.source = source;\n\tthis.min = min;\n\tthis.max = max;\n}\n\nSlice.prototype.run = function(sink, scheduler) {\n\treturn new SliceSink(this.min, this.max - this.min, this.source, sink, scheduler);\n};\n\nfunction SliceSink(skip, take, source, sink, scheduler) {\n\tthis.sink = sink;\n\tthis.skip = skip;\n\tthis.take = take;\n\tthis.disposable = dispose.once(source.run(this, scheduler));\n}\n\nSliceSink.prototype.end   = Sink.prototype.end;\nSliceSink.prototype.error = Sink.prototype.error;\n\nSliceSink.prototype.event = function(t, x) {\n\tif(this.skip > 0) {\n\t\tthis.skip -= 1;\n\t\treturn;\n\t}\n\n\tif(this.take === 0) {\n\t\treturn;\n\t}\n\n\tthis.take -= 1;\n\tthis.sink.event(t, x);\n\tif(this.take === 0) {\n\t\tthis.dispose();\n\t\tthis.sink.end(t, x);\n\t}\n};\n\nSliceSink.prototype.dispose = function() {\n\treturn this.disposable.dispose();\n};\n\nfunction takeWhile(p, stream) {\n\treturn new Stream(new TakeWhile(p, stream.source));\n}\n\nfunction TakeWhile(p, source) {\n\tthis.p = p;\n\tthis.source = source;\n}\n\nTakeWhile.prototype.run = function(sink, scheduler) {\n\treturn new TakeWhileSink(this.p, this.source, sink, scheduler);\n};\n\nfunction TakeWhileSink(p, source, sink, scheduler) {\n\tthis.p = p;\n\tthis.sink = sink;\n\tthis.active = true;\n\tthis.disposable = dispose.once(source.run(this, scheduler));\n}\n\nTakeWhileSink.prototype.end   = Sink.prototype.end;\nTakeWhileSink.prototype.error = Sink.prototype.error;\n\nTakeWhileSink.prototype.event = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\n\tvar p = this.p;\n\tthis.active = p(x);\n\tif(this.active) {\n\t\tthis.sink.event(t, x);\n\t} else {\n\t\tthis.dispose();\n\t\tthis.sink.end(t, x);\n\t}\n};\n\nTakeWhileSink.prototype.dispose = function() {\n\treturn this.disposable.dispose();\n};\n\nfunction skipWhile(p, stream) {\n\treturn new Stream(new SkipWhile(p, stream.source));\n}\n\nfunction SkipWhile(p, source) {\n\tthis.p = p;\n\tthis.source = source;\n}\n\nSkipWhile.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new SkipWhileSink(this.p, sink), scheduler);\n};\n\nfunction SkipWhileSink(p, sink) {\n\tthis.p = p;\n\tthis.sink = sink;\n\tthis.skipping = true;\n}\n\nSkipWhileSink.prototype.end   = Sink.prototype.end;\nSkipWhileSink.prototype.error = Sink.prototype.error;\n\nSkipWhileSink.prototype.event = function(t, x) {\n\tif(this.skipping) {\n\t\tvar p = this.p;\n\t\tthis.skipping = p(x);\n\t\tif(this.skipping) {\n\t\t\treturn;\n\t\t}\n\t}\n\n\tthis.sink.event(t, x);\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar dispose = require('../disposable/dispose');\n\nexports.switch = switchLatest;\n\n/**\n * Given a stream of streams, return a new stream that adopts the behavior\n * of the most recent inner stream.\n * @param {Stream} stream of streams on which to switch\n * @returns {Stream} switching stream\n */\nfunction switchLatest(stream) {\n\treturn new Stream(new Switch(stream.source));\n}\n\nfunction Switch(source) {\n\tthis.source = source;\n}\n\nSwitch.prototype.run = function(sink, scheduler) {\n\tvar switchSink = new SwitchSink(sink, scheduler);\n\treturn dispose.all(switchSink, this.source.run(switchSink, scheduler));\n};\n\nfunction SwitchSink(sink, scheduler) {\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.current = null;\n\tthis.ended = false;\n}\n\nSwitchSink.prototype.event = function(t, stream) {\n\tthis._disposeCurrent(t); // TODO: capture the result of this dispose\n\tthis.current = new Segment(t, Infinity, this, this.sink);\n\tthis.current.disposable = stream.source.run(this.current, this.scheduler);\n};\n\nSwitchSink.prototype.end = function(t, x) {\n\tthis.ended = true;\n\tthis._checkEnd(t, x);\n};\n\nSwitchSink.prototype.error = function(t, e) {\n\tthis.ended = true;\n\tthis.sink.error(t, e);\n};\n\nSwitchSink.prototype.dispose = function() {\n\treturn this._disposeCurrent(0);\n};\n\nSwitchSink.prototype._disposeCurrent = function(t) {\n\tif(this.current !== null) {\n\t\treturn this.current._dispose(t);\n\t}\n};\n\nSwitchSink.prototype._disposeInner = function(t, inner) {\n\tinner._dispose(t); // TODO: capture the result of this dispose\n\tif(inner === this.current) {\n\t\tthis.current = null;\n\t}\n};\n\nSwitchSink.prototype._checkEnd = function(t, x) {\n\tif(this.ended && this.current === null) {\n\t\tthis.sink.end(t, x);\n\t}\n};\n\nSwitchSink.prototype._endInner = function(t, x, inner) {\n\tthis._disposeInner(t, inner);\n\tthis._checkEnd(t, x);\n};\n\nSwitchSink.prototype._errorInner = function(t, e, inner) {\n\tthis._disposeInner(t, inner);\n\tthis.sink.error(t, e);\n};\n\nfunction Segment(min, max, outer, sink) {\n\tthis.min = min;\n\tthis.max = max;\n\tthis.outer = outer;\n\tthis.sink = sink;\n\tthis.disposable = dispose.empty();\n}\n\nSegment.prototype.event = function(t, x) {\n\tif(t < this.max) {\n\t\tthis.sink.event(Math.max(t, this.min), x);\n\t}\n};\n\nSegment.prototype.end = function(t, x) {\n\tthis.outer._endInner(Math.max(t, this.min), x, this);\n};\n\nSegment.prototype.error = function(t, e) {\n\tthis.outer._errorInner(Math.max(t, this.min), e, this);\n};\n\nSegment.prototype._dispose = function(t) {\n\tthis.max = t;\n\tdispose.tryDispose(t, this.disposable, this.sink)\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nexports.thru = function thru(f, stream) {\n\treturn f(stream);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Pipe = require('../sink/Pipe');\nvar dispose = require('../disposable/dispose');\nvar join = require('../combinator/flatMap').join;\n\nexports.during    = during;\nexports.takeUntil = takeUntil;\nexports.skipUntil = skipUntil;\n\nfunction takeUntil(signal, stream) {\n\treturn new Stream(new Until(signal.source, stream.source));\n}\n\nfunction skipUntil(signal, stream) {\n\treturn new Stream(new Since(signal.source, stream.source));\n}\n\nfunction during(timeWindow, stream) {\n\treturn takeUntil(join(timeWindow), skipUntil(timeWindow, stream));\n}\n\nfunction Until(maxSignal, source) {\n\tthis.maxSignal = maxSignal;\n\tthis.source = source;\n}\n\nUntil.prototype.run = function(sink, scheduler) {\n\tvar min = new Bound(-Infinity, sink);\n\tvar max = new UpperBound(this.maxSignal, sink, scheduler);\n\tvar disposable = this.source.run(new TimeWindowSink(min, max, sink), scheduler);\n\n\treturn dispose.all([min, max, disposable]);\n};\n\nfunction Since(minSignal, source) {\n\tthis.minSignal = minSignal;\n\tthis.source = source;\n}\n\nSince.prototype.run = function(sink, scheduler) {\n\tvar min = new LowerBound(this.minSignal, sink, scheduler);\n\tvar max = new Bound(Infinity, sink);\n\tvar disposable = this.source.run(new TimeWindowSink(min, max, sink), scheduler);\n\n\treturn dispose.all([min, max, disposable]);\n};\n\nfunction Bound(value, sink) {\n\tthis.value = value;\n\tthis.sink = sink;\n}\n\nBound.prototype.error = Pipe.prototype.error;\nBound.prototype.event = noop;\nBound.prototype.end = noop;\nBound.prototype.dispose = noop;\n\nfunction TimeWindowSink(min, max, sink) {\n\tthis.min = min;\n\tthis.max = max;\n\tthis.sink = sink;\n}\n\nTimeWindowSink.prototype.event = function(t, x) {\n\tif(t >= this.min.value && t < this.max.value) {\n\t\tthis.sink.event(t, x);\n\t}\n};\n\nTimeWindowSink.prototype.error = Pipe.prototype.error;\nTimeWindowSink.prototype.end = Pipe.prototype.end;\n\nfunction LowerBound(signal, sink, scheduler) {\n\tthis.value = Infinity;\n\tthis.sink = sink;\n\tthis.disposable = signal.run(this, scheduler);\n}\n\nLowerBound.prototype.event = function(t /*, x */) {\n\tif(t < this.value) {\n\t\tthis.value = t;\n\t}\n};\n\nLowerBound.prototype.end = noop;\nLowerBound.prototype.error = Pipe.prototype.error;\n\nLowerBound.prototype.dispose = function() {\n\treturn this.disposable.dispose();\n};\n\nfunction UpperBound(signal, sink, scheduler) {\n\tthis.value = Infinity;\n\tthis.sink = sink;\n\tthis.disposable = signal.run(this, scheduler);\n}\n\nUpperBound.prototype.event = function(t, x) {\n\tif(t < this.value) {\n\t\tthis.value = t;\n\t\tthis.sink.end(t, x);\n\t}\n};\n\nUpperBound.prototype.end = noop;\nUpperBound.prototype.error = Pipe.prototype.error;\n\nUpperBound.prototype.dispose = function() {\n\treturn this.disposable.dispose();\n};\n\nfunction noop() {}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Sink = require('../sink/Pipe');\n\nexports.timestamp = timestamp;\n\nfunction timestamp(stream) {\n\treturn new Stream(new Timestamp(stream.source));\n}\n\nfunction Timestamp(source) {\n\tthis.source = source;\n}\n\nTimestamp.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new TimestampSink(sink), scheduler);\n};\n\nfunction TimestampSink(sink) {\n\tthis.sink = sink;\n}\n\nTimestampSink.prototype.end   = Sink.prototype.end;\nTimestampSink.prototype.error = Sink.prototype.error;\n\nTimestampSink.prototype.event = function(t, x) {\n\tthis.sink.event(t, { time: t, value: x });\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\n\nexports.transduce = transduce;\n\n/**\n * Transform a stream by passing its events through a transducer.\n * @param  {function} transducer transducer function\n * @param  {Stream} stream stream whose events will be passed through the\n *  transducer\n * @return {Stream} stream of events transformed by the transducer\n */\nfunction transduce(transducer, stream) {\n\treturn new Stream(new Transduce(transducer, stream.source));\n}\n\nfunction Transduce(transducer, source) {\n\tthis.transducer = transducer;\n\tthis.source = source;\n}\n\nTransduce.prototype.run = function(sink, scheduler) {\n\tvar xf = this.transducer(new Transformer(sink));\n\treturn this.source.run(new TransduceSink(getTxHandler(xf), sink), scheduler);\n};\n\nfunction TransduceSink(adapter, sink) {\n\tthis.xf = adapter;\n\tthis.sink = sink;\n}\n\nTransduceSink.prototype.event = function(t, x) {\n\tvar next = this.xf.step(t, x);\n\n\treturn this.xf.isReduced(next)\n\t\t? this.sink.end(t, this.xf.getResult(next))\n\t\t: next;\n};\n\nTransduceSink.prototype.end = function(t, x) {\n\treturn this.xf.result(x);\n};\n\nTransduceSink.prototype.error = function(t, e) {\n\treturn this.sink.error(t, e);\n};\n\nfunction Transformer(sink) {\n\tthis.time = -Infinity;\n\tthis.sink = sink;\n}\n\nTransformer.prototype['@@transducer/init'] = Transformer.prototype.init = function() {};\n\nTransformer.prototype['@@transducer/step'] = Transformer.prototype.step = function(t, x) {\n\tif(!isNaN(t)) {\n\t\tthis.time = Math.max(t, this.time);\n\t}\n\treturn this.sink.event(this.time, x);\n};\n\nTransformer.prototype['@@transducer/result'] = Transformer.prototype.result = function(x) {\n\treturn this.sink.end(this.time, x);\n};\n\n/**\n * Given an object supporting the new or legacy transducer protocol,\n * create an adapter for it.\n * @param {object} tx transform\n * @returns {TxAdapter|LegacyTxAdapter}\n */\nfunction getTxHandler(tx) {\n\treturn typeof tx['@@transducer/step'] === 'function'\n\t\t? new TxAdapter(tx)\n\t\t: new LegacyTxAdapter(tx);\n}\n\n/**\n * Adapter for new official transducer protocol\n * @param {object} tx transform\n * @constructor\n */\nfunction TxAdapter(tx) {\n\tthis.tx = tx;\n}\n\nTxAdapter.prototype.step = function(t, x) {\n\treturn this.tx['@@transducer/step'](t, x);\n};\nTxAdapter.prototype.result = function(x) {\n\treturn this.tx['@@transducer/result'](x);\n};\nTxAdapter.prototype.isReduced = function(x) {\n\treturn x != null && x['@@transducer/reduced'];\n};\nTxAdapter.prototype.getResult = function(x) {\n\treturn x['@@transducer/value'];\n};\n\n/**\n * Adapter for older transducer protocol\n * @param {object} tx transform\n * @constructor\n */\nfunction LegacyTxAdapter(tx) {\n\tthis.tx = tx;\n}\n\nLegacyTxAdapter.prototype.step = function(t, x) {\n\treturn this.tx.step(t, x);\n};\nLegacyTxAdapter.prototype.result = function(x) {\n\treturn this.tx.result(x);\n};\nLegacyTxAdapter.prototype.isReduced = function(x) {\n\treturn x != null && x.__transducers_reduced__;\n};\nLegacyTxAdapter.prototype.getResult = function(x) {\n\treturn x.value;\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar Map = require('../fusion/Map');\n\nexports.map = map;\nexports.constant = constant;\nexports.tap = tap;\n\n/**\n * Transform each value in the stream by applying f to each\n * @param {function(*):*} f mapping function\n * @param {Stream} stream stream to map\n * @returns {Stream} stream containing items transformed by f\n */\nfunction map(f, stream) {\n\treturn new Stream(Map.create(f, stream.source));\n}\n\n/**\n * Replace each value in the stream with x\n * @param {*} x\n * @param {Stream} stream\n * @returns {Stream} stream containing items replaced with x\n */\nfunction constant(x, stream) {\n\treturn map(function() {\n\t\treturn x;\n\t}, stream);\n}\n\n/**\n * Perform a side effect for each item in the stream\n * @param {function(x:*):*} f side effect to execute for each item. The\n *  return value will be discarded.\n * @param {Stream} stream stream to tap\n * @returns {Stream} new stream containing the same items as this stream\n */\nfunction tap(f, stream) {\n\treturn map(function(x) {\n\t\tf(x);\n\t\treturn x;\n\t}, stream);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar transform = require('./transform');\nvar core = require('../source/core');\nvar Sink = require('../sink/Pipe');\nvar IndexSink = require('../sink/IndexSink');\nvar dispose = require('../disposable/dispose');\nvar base = require('@most/prelude');\nvar invoke = require('../invoke');\nvar Queue = require('../Queue');\n\nvar map = base.map;\nvar tail = base.tail;\n\nexports.zip = zip;\nexports.zipArray = zipArray;\n\n/**\n * Combine streams pairwise (or tuple-wise) by index by applying f to values\n * at corresponding indices.  The returned stream ends when any of the input\n * streams ends.\n * @param {function} f function to combine values\n * @returns {Stream} new stream with items at corresponding indices combined\n *  using f\n */\nfunction zip(f /*,...streams */) {\n\treturn zipArray(f, tail(arguments));\n}\n\n/**\n * Combine streams pairwise (or tuple-wise) by index by applying f to values\n * at corresponding indices.  The returned stream ends when any of the input\n * streams ends.\n * @param {function} f function to combine values\n * @param {[Stream]} streams streams to zip using f\n * @returns {Stream} new stream with items at corresponding indices combined\n *  using f\n */\nfunction zipArray(f, streams) {\n\treturn streams.length === 0 ? core.empty()\n\t\t : streams.length === 1 ? transform.map(f, streams[0])\n\t\t : new Stream(new Zip(f, map(getSource, streams)));\n}\n\nfunction getSource(stream) {\n\treturn stream.source;\n}\n\nfunction Zip(f, sources) {\n\tthis.f = f;\n\tthis.sources = sources;\n}\n\nZip.prototype.run = function(sink, scheduler) {\n\tvar l = this.sources.length;\n\tvar disposables = new Array(l);\n\tvar sinks = new Array(l);\n\tvar buffers = new Array(l);\n\n\tvar zipSink = new ZipSink(this.f, buffers, sinks, sink);\n\n\tfor(var indexSink, i=0; i<l; ++i) {\n\t\tbuffers[i] = new Queue();\n\t\tindexSink = sinks[i] = new IndexSink(i, zipSink);\n\t\tdisposables[i] = this.sources[i].run(indexSink, scheduler);\n\t}\n\n\treturn dispose.all(disposables);\n};\n\nfunction ZipSink(f, buffers, sinks, sink) {\n\tthis.f = f;\n\tthis.sinks = sinks;\n\tthis.sink = sink;\n\tthis.buffers = buffers;\n}\n\nZipSink.prototype.event = function(t, indexedValue) {\n\tvar buffers = this.buffers;\n\tvar buffer = buffers[indexedValue.index];\n\n\tbuffer.push(indexedValue.value);\n\n\tif(buffer.length() === 1) {\n\t\tif(!ready(this.buffers)) {\n\t\t\treturn;\n\t\t}\n\n\t\temitZipped(this.f, t, buffers, this.sink);\n\n\t\tif (ended(this.buffers, this.sinks)) {\n\t\t\tthis.sink.end(t, void 0);\n\t\t}\n\t}\n};\n\nZipSink.prototype.end = function(t, indexedValue) {\n\tvar buffer = this.buffers[indexedValue.index];\n\tif(buffer.isEmpty()) {\n\t\tthis.sink.end(t, indexedValue.value);\n\t}\n};\n\nZipSink.prototype.error = Sink.prototype.error;\n\nfunction emitZipped (f, t, buffers, sink) {\n\tsink.event(t, invoke(f, map(head, buffers)));\n}\n\nfunction head(buffer) {\n\treturn buffer.shift();\n}\n\nfunction ended(buffers, sinks) {\n\tfor(var i=0, l=buffers.length; i<l; ++i) {\n\t\tif(buffers[i].isEmpty() && !sinks[i].active) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n}\n\nfunction ready(buffers) {\n\tfor(var i=0, l=buffers.length; i<l; ++i) {\n\t\tif(buffers[i].isEmpty()) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = defer;\n\nfunction defer(task) {\n\treturn Promise.resolve(task).then(runTask);\n}\n\nfunction runTask(task) {\n\ttry {\n\t\treturn task.run();\n\t} catch(e) {\n\t\treturn task.error(e);\n\t}\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = Disposable;\n\n/**\n * Create a new Disposable which will dispose its underlying resource.\n * @param {function} dispose function\n * @param {*?} data any data to be passed to disposer function\n * @constructor\n */\nfunction Disposable(dispose, data) {\n\tthis._dispose = dispose;\n\tthis._data = data;\n}\n\nDisposable.prototype.dispose = function() {\n\treturn this._dispose(this._data);\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = SettableDisposable;\n\nfunction SettableDisposable() {\n\tthis.disposable = void 0;\n\tthis.disposed = false;\n\tthis._resolve = void 0;\n\n\tvar self = this;\n\tthis.result = new Promise(function(resolve) {\n\t\tself._resolve = resolve;\n\t});\n}\n\nSettableDisposable.prototype.setDisposable = function(disposable) {\n\tif(this.disposable !== void 0) {\n\t\tthrow new Error('setDisposable called more than once');\n\t}\n\n\tthis.disposable = disposable;\n\n\tif(this.disposed) {\n\t\tthis._resolve(disposable.dispose());\n\t}\n};\n\nSettableDisposable.prototype.dispose = function() {\n\tif(this.disposed) {\n\t\treturn this.result;\n\t}\n\n\tthis.disposed = true;\n\n\tif(this.disposable !== void 0) {\n\t\tthis.result = this.disposable.dispose();\n\t}\n\n\treturn this.result;\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Disposable = require('./Disposable');\nvar SettableDisposable = require('./SettableDisposable');\nvar isPromise = require('../Promise').isPromise;\nvar base = require('@most/prelude');\n\nvar map = base.map;\nvar identity = base.id;\n\nexports.tryDispose = tryDispose;\nexports.create = create;\nexports.once = once;\nexports.empty = empty;\nexports.all = all;\nexports.settable = settable;\nexports.promised = promised;\n\n/**\n * Call disposable.dispose.  If it returns a promise, catch promise\n * error and forward it through the provided sink.\n * @param {number} t time\n * @param {{dispose: function}} disposable\n * @param {{error: function}} sink\n * @return {*} result of disposable.dispose\n */\nfunction tryDispose(t, disposable, sink) {\n\tvar result = disposeSafely(disposable);\n\treturn isPromise(result)\n\t\t? result.catch(function (e) {\n\t\t\tsink.error(t, e);\n\t\t})\n\t\t: result;\n}\n\n/**\n * Create a new Disposable which will dispose its underlying resource\n * at most once.\n * @param {function} dispose function\n * @param {*?} data any data to be passed to disposer function\n * @return {Disposable}\n */\nfunction create(dispose, data) {\n\treturn once(new Disposable(dispose, data));\n}\n\n/**\n * Create a noop disposable. Can be used to satisfy a Disposable\n * requirement when no actual resource needs to be disposed.\n * @return {Disposable|exports|module.exports}\n */\nfunction empty() {\n\treturn new Disposable(identity, void 0);\n}\n\n/**\n * Create a disposable that will dispose all input disposables in parallel.\n * @param {Array<Disposable>} disposables\n * @return {Disposable}\n */\nfunction all(disposables) {\n\treturn create(disposeAll, disposables);\n}\n\nfunction disposeAll(disposables) {\n\treturn Promise.all(map(disposeSafely, disposables));\n}\n\nfunction disposeSafely(disposable) {\n\ttry {\n\t\treturn disposable.dispose();\n\t} catch(e) {\n\t\treturn Promise.reject(e);\n\t}\n}\n\n/**\n * Create a disposable from a promise for another disposable\n * @param {Promise<Disposable>} disposablePromise\n * @return {Disposable}\n */\nfunction promised(disposablePromise) {\n\treturn create(disposePromise, disposablePromise);\n}\n\nfunction disposePromise(disposablePromise) {\n\treturn disposablePromise.then(disposeOne);\n}\n\nfunction disposeOne(disposable) {\n\treturn disposable.dispose();\n}\n\n/**\n * Create a disposable proxy that allows its underlying disposable to\n * be set later.\n * @return {SettableDisposable}\n */\nfunction settable() {\n\treturn new SettableDisposable();\n}\n\n/**\n * Wrap an existing disposable (which may not already have been once()d)\n * so that it will only dispose its underlying resource at most once.\n * @param {{ dispose: function() }} disposable\n * @return {Disposable} wrapped disposable\n */\nfunction once(disposable) {\n\treturn new Disposable(disposeMemoized, memoized(disposable));\n}\n\nfunction disposeMemoized(memoized) {\n\tif(!memoized.disposed) {\n\t\tmemoized.disposed = true;\n\t\tmemoized.value = disposeSafely(memoized.disposable);\n\t\tmemoized.disposable = void 0;\n\t}\n\n\treturn memoized.value;\n}\n\nfunction memoized(disposable) {\n\treturn { disposed: false, disposable: disposable, value: void 0 };\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = fatalError;\n\nfunction fatalError (e) {\n\tsetTimeout(function() {\n\t\tthrow e;\n\t}, 0);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Pipe = require('../sink/Pipe');\n\nmodule.exports = Filter;\n\nfunction Filter(p, source) {\n\tthis.p = p;\n\tthis.source = source;\n}\n\n/**\n * Create a filtered source, fusing adjacent filter.filter if possible\n * @param {function(x:*):boolean} p filtering predicate\n * @param {{run:function}} source source to filter\n * @returns {Filter} filtered source\n */\nFilter.create = function createFilter(p, source) {\n\tif (source instanceof Filter) {\n\t\treturn new Filter(and(source.p, p), source.source);\n\t}\n\n\treturn new Filter(p, source);\n};\n\nFilter.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new FilterSink(this.p, sink), scheduler);\n};\n\nfunction FilterSink(p, sink) {\n\tthis.p = p;\n\tthis.sink = sink;\n}\n\nFilterSink.prototype.end   = Pipe.prototype.end;\nFilterSink.prototype.error = Pipe.prototype.error;\n\nFilterSink.prototype.event = function(t, x) {\n\tvar p = this.p;\n\tp(x) && this.sink.event(t, x);\n};\n\nfunction and(p, q) {\n\treturn function(x) {\n\t\treturn p(x) && q(x);\n\t};\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Pipe = require('../sink/Pipe');\n\nmodule.exports = FilterMap;\n\nfunction FilterMap(p, f, source) {\n\tthis.p = p;\n\tthis.f = f;\n\tthis.source = source;\n}\n\nFilterMap.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new FilterMapSink(this.p, this.f, sink), scheduler);\n};\n\nfunction FilterMapSink(p, f, sink) {\n\tthis.p = p;\n\tthis.f = f;\n\tthis.sink = sink;\n}\n\nFilterMapSink.prototype.event = function(t, x) {\n\tvar f = this.f;\n\tvar p = this.p;\n\tp(x) && this.sink.event(t, f(x));\n};\n\nFilterMapSink.prototype.end = Pipe.prototype.end;\nFilterMapSink.prototype.error = Pipe.prototype.error;\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Pipe = require('../sink/Pipe');\nvar Filter = require('./Filter');\nvar FilterMap = require('./FilterMap');\nvar base = require('@most/prelude');\n\nmodule.exports = Map;\n\nfunction Map(f, source) {\n\tthis.f = f;\n\tthis.source = source;\n}\n\n/**\n * Create a mapped source, fusing adjacent map.map, filter.map,\n * and filter.map.map if possible\n * @param {function(*):*} f mapping function\n * @param {{run:function}} source source to map\n * @returns {Map|FilterMap} mapped source, possibly fused\n */\nMap.create = function createMap(f, source) {\n\tif(source instanceof Map) {\n\t\treturn new Map(base.compose(f, source.f), source.source);\n\t}\n\n\tif(source instanceof Filter) {\n\t\treturn new FilterMap(source.p, f, source.source);\n\t}\n\n\treturn new Map(f, source);\n};\n\nMap.prototype.run = function(sink, scheduler) {\n\treturn this.source.run(new MapSink(this.f, sink), scheduler);\n};\n\nfunction MapSink(f, sink) {\n\tthis.f = f;\n\tthis.sink = sink;\n}\n\nMapSink.prototype.end   = Pipe.prototype.end;\nMapSink.prototype.error = Pipe.prototype.error;\n\nMapSink.prototype.event = function(t, x) {\n\tvar f = this.f;\n\tthis.sink.event(t, f(x));\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = invoke;\n\nfunction invoke(f, args) {\n\t/*eslint complexity: [2,7]*/\n\tswitch(args.length) {\n\t\tcase 0: return f();\n\t\tcase 1: return f(args[0]);\n\t\tcase 2: return f(args[0], args[1]);\n\t\tcase 3: return f(args[0], args[1], args[2]);\n\t\tcase 4: return f(args[0], args[1], args[2], args[3]);\n\t\tcase 5: return f(args[0], args[1], args[2], args[3], args[4]);\n\t\tdefault:\n\t\t\treturn f.apply(void 0, args);\n\t}\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nexports.isIterable = isIterable;\nexports.getIterator = getIterator;\nexports.makeIterable = makeIterable;\n\n/*global Set, Symbol*/\nvar iteratorSymbol;\n// Firefox ships a partial implementation using the name @@iterator.\n// https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14\nif (typeof Set === 'function' && typeof new Set()['@@iterator'] === 'function') {\n\titeratorSymbol = '@@iterator';\n} else {\n\titeratorSymbol = typeof Symbol === 'function' && Symbol.iterator ||\n\t'_es6shim_iterator_';\n}\n\nfunction isIterable(o) {\n\treturn typeof o[iteratorSymbol] === 'function';\n}\n\nfunction getIterator(o) {\n\treturn o[iteratorSymbol]();\n}\n\nfunction makeIterable(f, o) {\n\to[iteratorSymbol] = f;\n\treturn o;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar dispose = require('../disposable/dispose');\n\nexports.fromObservable = fromObservable;\nexports.ObservableSource = ObservableSource;\nexports.SubscriberSink = SubscriberSink;\n\nfunction fromObservable(observable) {\n\treturn new Stream(new ObservableSource(observable));\n}\n\nfunction ObservableSource(observable) {\n\tthis.observable = observable;\n}\n\nObservableSource.prototype.run = function(sink, scheduler) {\n\tvar sub = this.observable.subscribe(new SubscriberSink(sink, scheduler));\n\tif(typeof sub === 'function') {\n\t\treturn dispose.create(sub);\n\t} else if(sub && typeof sub.unsubscribe === 'function') {\n\t\treturn dispose.create(unsubscribe, sub);\n\t}\n\n\tthrow new TypeError('Observable returned invalid subscription ' + String(sub));\n}\n\nfunction SubscriberSink(sink, scheduler) {\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n}\n\nSubscriberSink.prototype.next = function(x) {\n\tthis.sink.event(this.scheduler.now(), x);\n}\n\nSubscriberSink.prototype.complete = function(x) {\n\tthis.sink.end(this.scheduler.now(), x);\n}\n\nSubscriberSink.prototype.error = function(e) {\n\tthis.sink.error(this.scheduler.now(), e);\n}\n\nfunction unsubscribe(subscription) {\n\treturn subscription.unsubscribe();\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar symbolObservable = require('symbol-observable');\n\nmodule.exports = getObservable;\n\nfunction getObservable(o) {\n\tvar obs = null;\n\tif(o != null && typeof o === 'object') {\n\t\tvar method = o[symbolObservable];\n\t\tif(typeof method === 'function') {\n\t\t\tobs = method.call(o);\n\t\t\tif(obs == null || typeof obs !== 'object') {\n\t\t\t\tthrow new TypeError('invalid observable ' + obs);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn obs;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar defaultScheduler = require('../scheduler/defaultScheduler');\nvar dispose = require('../disposable/dispose');\nvar fatalError = require('../fatalError');\n\nexports.subscribe = subscribe;\nexports.SubscribeObserver = SubscribeObserver;\nexports.Subscription = Subscription;\n\nfunction subscribe(subscriber, stream) {\n\tif(subscriber == null || typeof subscriber !== 'object') {\n\t\tthrow new TypeError('subscriber must be an object');\n\t}\n\n\tvar disposable = dispose.settable();\n\tvar observer = new SubscribeObserver(fatalError, subscriber, disposable);\n\n\tdisposable.setDisposable(stream.source.run(observer, defaultScheduler));\n\n\treturn new Subscription(disposable);\n}\n\nfunction SubscribeObserver(fatalError, subscriber, disposable) {\n\tthis.fatalError = fatalError;\n\tthis.subscriber = subscriber;\n\tthis.disposable = disposable;\n}\n\nSubscribeObserver.prototype.event = function(t, x) {\n\tif(typeof this.subscriber.next === 'function') {\n\t\tthis.subscriber.next(x);\n\t}\n};\n\nSubscribeObserver.prototype.end = function(t, x) {\n\tvar s = this.subscriber;\n\tdoDispose(this.fatalError, s, s.complete, s.error, this.disposable, x);\n};\n\nSubscribeObserver.prototype.error = function(t, e) {\n\tvar s = this.subscriber;\n\tdoDispose(this.fatalError, s, s.error, s.error, this.disposable, e);\n};\n\nfunction Subscription(disposable) {\n\tthis.disposable = disposable;\n}\n\nSubscription.prototype.unsubscribe = function() {\n\tthis.disposable.dispose();\n}\n\nfunction doDispose(fatal, subscriber, complete, error, disposable, x) {\n\tPromise.resolve(disposable.dispose()).then(function () {\n\t\tif(typeof complete === 'function') {\n\t\t\tcomplete.call(subscriber, x);\n\t\t}\n\t}).catch(function(e) {\n\t\tif(typeof error === 'function') {\n\t\t\terror.call(subscriber, e);\n\t\t}\n\t}).catch(fatal);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Observer = require('./sink/Observer');\nvar dispose = require('./disposable/dispose');\nvar defaultScheduler = require('./scheduler/defaultScheduler');\n\nexports.withDefaultScheduler = withDefaultScheduler;\nexports.withScheduler = withScheduler;\n\nfunction withDefaultScheduler(f, source) {\n\treturn withScheduler(f, source, defaultScheduler);\n}\n\nfunction withScheduler(f, source, scheduler) {\n\treturn new Promise(function (resolve, reject) {\n\t\trunSource(f, source, scheduler, resolve, reject);\n\t});\n}\n\nfunction runSource(f, source, scheduler, resolve, reject) {\n\tvar disposable = dispose.settable();\n\tvar observer = new Observer(f, resolve, reject, disposable);\n\n\tdisposable.setDisposable(source.run(observer, scheduler));\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar fatal = require('../fatalError');\n\nmodule.exports = PropagateTask;\n\nfunction PropagateTask(run, value, sink) {\n\tthis._run = run;\n\tthis.value = value;\n\tthis.sink = sink;\n\tthis.active = true;\n}\n\nPropagateTask.event = function(value, sink) {\n\treturn new PropagateTask(emit, value, sink);\n};\n\nPropagateTask.end = function(value, sink) {\n\treturn new PropagateTask(end, value, sink);\n};\n\nPropagateTask.error = function(value, sink) {\n\treturn new PropagateTask(error, value, sink);\n};\n\nPropagateTask.prototype.dispose = function() {\n\tthis.active = false;\n};\n\nPropagateTask.prototype.run = function(t) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis._run(t, this.value, this.sink);\n};\n\nPropagateTask.prototype.error = function(t, e) {\n\tif(!this.active) {\n\t\treturn fatal(e);\n\t}\n\tthis.sink.error(t, e);\n};\n\nfunction error(t, e, sink) {\n\tsink.error(t, e);\n}\n\nfunction emit(t, x, sink) {\n\tsink.event(t, x);\n}\n\nfunction end(t, x, sink) {\n\tsink.end(t, x);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar base = require('@most/prelude');\n\nmodule.exports = Scheduler;\n\nfunction ScheduledTask(delay, period, task, scheduler) {\n\tthis.time = delay;\n\tthis.period = period;\n\tthis.task = task;\n\tthis.scheduler = scheduler;\n\tthis.active = true;\n}\n\nScheduledTask.prototype.run = function() {\n\treturn this.task.run(this.time);\n};\n\nScheduledTask.prototype.error = function(e) {\n\treturn this.task.error(this.time, e);\n};\n\nScheduledTask.prototype.dispose = function() {\n\tthis.scheduler.cancel(this);\n\treturn this.task.dispose();\n};\n\nfunction runTask(task) {\n\ttry {\n\t\treturn task.run();\n\t} catch(e) {\n\t\treturn task.error(e);\n\t}\n}\n\nfunction Scheduler(timer) {\n\tthis.timer = timer;\n\n\tthis._timer = null;\n\tthis._nextArrival = 0;\n\tthis._tasks = [];\n\n\tvar self = this;\n\tthis._runReadyTasksBound = function() {\n\t\tself._runReadyTasks(self.now());\n\t};\n}\n\nScheduler.prototype.now = function() {\n\treturn this.timer.now();\n};\n\nScheduler.prototype.asap = function(task) {\n\treturn this.schedule(0, -1, task);\n};\n\nScheduler.prototype.delay = function(delay, task) {\n\treturn this.schedule(delay, -1, task);\n};\n\nScheduler.prototype.periodic = function(period, task) {\n\treturn this.schedule(0, period, task);\n};\n\nScheduler.prototype.schedule = function(delay, period, task) {\n\tvar now = this.now();\n\tvar st = new ScheduledTask(now + Math.max(0, delay), period, task, this);\n\n\tinsertByTime(st, this._tasks);\n\tthis._scheduleNextRun(now);\n\treturn st;\n};\n\nScheduler.prototype.cancel = function(task) {\n\ttask.active = false;\n\tvar i = binarySearch(task.time, this._tasks);\n\n\tif(i >= 0 && i < this._tasks.length) {\n\t\tvar at = base.findIndex(task, this._tasks[i].events);\n\t\tif(at >= 0) {\n\t\t\tthis._tasks[i].events.splice(at, 1);\n\t\t\tthis._reschedule();\n\t\t}\n\t}\n};\n\nScheduler.prototype.cancelAll = function(f) {\n\tfor(var i=0; i<this._tasks.length; ++i) {\n\t\tremoveAllFrom(f, this._tasks[i]);\n\t}\n\tthis._reschedule();\n};\n\nfunction removeAllFrom(f, timeslot) {\n\ttimeslot.events = base.removeAll(f, timeslot.events);\n}\n\nScheduler.prototype._reschedule = function() {\n\tif(this._tasks.length === 0) {\n\t\tthis._unschedule();\n\t} else {\n\t\tthis._scheduleNextRun(this.now());\n\t}\n};\n\nScheduler.prototype._unschedule = function() {\n\tthis.timer.clearTimer(this._timer);\n\tthis._timer = null;\n};\n\nScheduler.prototype._scheduleNextRun = function(now) {\n\tif(this._tasks.length === 0) {\n\t\treturn;\n\t}\n\n\tvar nextArrival = this._tasks[0].time;\n\n\tif(this._timer === null) {\n\t\tthis._scheduleNextArrival(nextArrival, now);\n\t} else if(nextArrival < this._nextArrival) {\n\t\tthis._unschedule();\n\t\tthis._scheduleNextArrival(nextArrival, now);\n\t}\n};\n\nScheduler.prototype._scheduleNextArrival = function(nextArrival, now) {\n\tthis._nextArrival = nextArrival;\n\tvar delay = Math.max(0, nextArrival - now);\n\tthis._timer = this.timer.setTimer(this._runReadyTasksBound, delay);\n};\n\n\nScheduler.prototype._runReadyTasks = function(now) {\n\tthis._timer = null;\n\n\tthis._tasks = this._findAndRunTasks(now);\n\n\tthis._scheduleNextRun(this.now());\n};\n\nScheduler.prototype._findAndRunTasks = function(now) {\n\tvar tasks = this._tasks;\n\tvar l = tasks.length;\n\tvar i = 0;\n\n\twhile(i < l && tasks[i].time <= now) {\n\t\t++i;\n\t}\n\n\tthis._tasks = tasks.slice(i);\n\n\t// Run all ready tasks\n\tfor (var j = 0; j < i; ++j) {\n\t\tthis._tasks = runTasks(tasks[j], this._tasks);\n\t}\n\treturn this._tasks;\n};\n\nfunction runTasks(timeslot, tasks) {\n\tvar events = timeslot.events;\n\tfor(var i=0; i<events.length; ++i) {\n\t\tvar task = events[i];\n\n\t\tif(task.active) {\n\t\t\trunTask(task);\n\n\t\t\t// Reschedule periodic repeating tasks\n\t\t\t// Check active again, since a task may have canceled itself\n\t\t\tif(task.period >= 0) {\n\t\t\t\ttask.time = task.time + task.period;\n\t\t\t\tinsertByTime(task, tasks);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn tasks;\n}\n\nfunction insertByTime(task, timeslots) {\n\tvar l = timeslots.length;\n\n\tif(l === 0) {\n\t\ttimeslots.push(newTimeslot(task.time, [task]));\n\t\treturn;\n\t}\n\n\tvar i = binarySearch(task.time, timeslots);\n\n\tif(i >= l) {\n\t\ttimeslots.push(newTimeslot(task.time, [task]));\n\t} else if(task.time === timeslots[i].time) {\n\t\ttimeslots[i].events.push(task);\n\t} else {\n\t\ttimeslots.splice(i, 0, newTimeslot(task.time, [task]));\n\t}\n}\n\nfunction binarySearch(t, sortedArray) {\n\tvar lo = 0;\n\tvar hi = sortedArray.length;\n\tvar mid, y;\n\n\twhile (lo < hi) {\n\t\tmid = Math.floor((lo + hi) / 2);\n\t\ty = sortedArray[mid];\n\n\t\tif (t === y.time) {\n\t\t\treturn mid;\n\t\t} else if (t < y.time) {\n\t\t\thi = mid;\n\t\t} else {\n\t\t\tlo = mid + 1;\n\t\t}\n\t}\n\treturn hi;\n}\n\nfunction newTimeslot(t, events) {\n\treturn { time: t, events: events };\n}\n","(function (process){\n/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Scheduler = require('./Scheduler');\nvar setTimeoutTimer = require('./timeoutTimer');\nvar nodeTimer = require('./nodeTimer');\n\nvar isNode = typeof process === 'object'\n\t\t&& typeof process.nextTick === 'function';\n\nmodule.exports = new Scheduler(isNode ? nodeTimer : setTimeoutTimer);\n\n}).call(this,require('_process'))\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9zY2hlZHVsZXIvZGVmYXVsdFNjaGVkdWxlci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EiLCJmaWxlIjoiZ2VuZXJhdGVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBAbGljZW5zZSBNSVQgTGljZW5zZSAoYykgY29weXJpZ2h0IDIwMTAtMjAxNiBvcmlnaW5hbCBhdXRob3Igb3IgYXV0aG9ycyAqL1xuLyoqIEBhdXRob3IgQnJpYW4gQ2F2YWxpZXIgKi9cbi8qKiBAYXV0aG9yIEpvaG4gSGFubiAqL1xuXG52YXIgU2NoZWR1bGVyID0gcmVxdWlyZSgnLi9TY2hlZHVsZXInKTtcbnZhciBzZXRUaW1lb3V0VGltZXIgPSByZXF1aXJlKCcuL3RpbWVvdXRUaW1lcicpO1xudmFyIG5vZGVUaW1lciA9IHJlcXVpcmUoJy4vbm9kZVRpbWVyJyk7XG5cbnZhciBpc05vZGUgPSB0eXBlb2YgcHJvY2VzcyA9PT0gJ29iamVjdCdcblx0XHQmJiB0eXBlb2YgcHJvY2Vzcy5uZXh0VGljayA9PT0gJ2Z1bmN0aW9uJztcblxubW9kdWxlLmV4cG9ydHMgPSBuZXcgU2NoZWR1bGVyKGlzTm9kZSA/IG5vZGVUaW1lciA6IHNldFRpbWVvdXRUaW1lcik7XG4iXX0=","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar defer = require('../defer');\n\n/*global setTimeout, clearTimeout*/\n\nfunction Task(f) {\n\tthis.f = f;\n\tthis.active = true;\n}\n\nTask.prototype.run = function() {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tvar f = this.f;\n\treturn f();\n};\n\nTask.prototype.error = function(e) {\n\tthrow e;\n};\n\nTask.prototype.cancel = function() {\n\tthis.active = false;\n};\n\nfunction runAsTask(f) {\n\tvar task = new Task(f);\n\tdefer(task);\n\treturn task;\n}\n\nmodule.exports = {\n\tnow: Date.now,\n\tsetTimer: function(f, dt) {\n\t\treturn dt <= 0 ? runAsTask(f) : setTimeout(f, dt);\n\t},\n\tclearTimer: function(t) {\n\t\treturn t instanceof Task ? t.cancel() : clearTimeout(t);\n\t}\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\n/*global setTimeout, clearTimeout*/\n\nmodule.exports = {\n\tnow: Date.now,\n\tsetTimer: function(f, dt) {\n\t\treturn setTimeout(f, dt);\n\t},\n\tclearTimer: function(t) {\n\t\treturn clearTimeout(t);\n\t}\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar defer = require('../defer');\n\nmodule.exports = DeferredSink;\n\nfunction DeferredSink(sink) {\n\tthis.sink = sink;\n\tthis.events = [];\n\tthis.active = true;\n}\n\nDeferredSink.prototype.event = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\n\tif(this.events.length === 0) {\n\t\tdefer(new PropagateAllTask(this.sink, this.events));\n\t}\n\n\tthis.events.push({ time: t, value: x });\n};\n\nDeferredSink.prototype.error = function(t, e) {\n\tthis._end(new ErrorTask(t, e, this.sink));\n};\n\nDeferredSink.prototype.end = function(t, x) {\n\tthis._end(new EndTask(t, x, this.sink));\n};\n\nDeferredSink.prototype._end = function(task) {\n\tthis.active = false;\n\tthis.events = void 0;\n\tdefer(task);\n}\n\nfunction PropagateAllTask(sink, events) {\n\tthis.sink = sink;\n\tthis.events = events;\n}\n\nPropagateAllTask.prototype.run = function() {\n\tvar events = this.events;\n\tvar sink = this.sink;\n\tvar event;\n\n\tfor(var i = 0, l = events.length; i<l; ++i) {\n\t\tevent = events[i];\n\t\tsink.event(event.time, event.value);\n\t}\n\n\tevents.length = 0;\n};\n\nPropagateAllTask.prototype.error = function(e) {\n\tthis.sink.error(0, e);\n};\n\nfunction EndTask(t, x, sink) {\n\tthis.time = t;\n\tthis.value = x;\n\tthis.sink = sink;\n}\n\nEndTask.prototype.run = function() {\n\tthis.sink.end(this.time, this.value);\n};\n\nEndTask.prototype.error = function(e) {\n\tthis.sink.error(this.time, e);\n};\n\nfunction ErrorTask(t, e, sink) {\n\tthis.time = t;\n\tthis.value = e;\n\tthis.sink = sink;\n}\n\nErrorTask.prototype.run = function() {\n\tthis.sink.error(this.time, this.value);\n};\n\nErrorTask.prototype.error = function(e) {\n\tthrow e;\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Sink = require('./Pipe');\n\nmodule.exports = IndexSink;\n\nfunction IndexSink(i, sink) {\n\tthis.sink = sink;\n\tthis.index = i;\n\tthis.active = true;\n\tthis.value = void 0;\n}\n\nIndexSink.prototype.event = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis.value = x;\n\tthis.sink.event(t, this);\n};\n\nIndexSink.prototype.end = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis.active = false;\n\tthis.sink.end(t, { index: this.index, value: x });\n};\n\nIndexSink.prototype.error = Sink.prototype.error;\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = Observer;\n\n/**\n * Sink that accepts functions to apply to each event, and to end, and error\n * signals.\n * @constructor\n */\nfunction Observer(event, end, error, disposable) {\n\tthis._event = event;\n\tthis._end = end;\n\tthis._error = error;\n\tthis._disposable = disposable;\n\tthis.active = true;\n}\n\nObserver.prototype.event = function(t, x) {\n\tif (!this.active) {\n\t\treturn;\n\t}\n\tthis._event(x);\n};\n\nObserver.prototype.end = function(t, x) {\n\tif (!this.active) {\n\t\treturn;\n\t}\n\tthis.active = false;\n\tdisposeThen(this._end, this._error, this._disposable, x);\n};\n\nObserver.prototype.error = function(t, e) {\n\tthis.active = false;\n\tdisposeThen(this._error, this._error, this._disposable, e);\n};\n\nfunction disposeThen(end, error, disposable, x) {\n\tPromise.resolve(disposable.dispose()).then(function () {\n\t\tend(x);\n\t}, error);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = Pipe;\n\n/**\n * A sink mixin that simply forwards event, end, and error to\n * another sink.\n * @param sink\n * @constructor\n */\nfunction Pipe(sink) {\n\tthis.sink = sink;\n}\n\nPipe.prototype.event = function(t, x) {\n\treturn this.sink.event(t, x);\n};\n\nPipe.prototype.end = function(t, x) {\n\treturn this.sink.end(t, x);\n};\n\nPipe.prototype.error = function(t, e) {\n\treturn this.sink.error(t, e);\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nmodule.exports = SafeSink;\n\nfunction SafeSink(sink) {\n\tthis.sink = sink;\n\tthis.active = true;\n}\n\nSafeSink.prototype.event = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis.sink.event(t, x);\n};\n\nSafeSink.prototype.end = function(t, x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis.disable();\n\tthis.sink.end(t, x);\n};\n\nSafeSink.prototype.error = function(t, e) {\n\tthis.disable();\n\tthis.sink.error(t, e);\n};\n\nSafeSink.prototype.disable = function() {\n\tthis.active = false;\n\treturn this.sink;\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar DeferredSink = require('../sink/DeferredSink');\nvar dispose = require('../disposable/dispose');\nvar tryEvent = require('./tryEvent');\n\nmodule.exports = EventEmitterSource;\n\nfunction EventEmitterSource(event, source) {\n\tthis.event = event;\n\tthis.source = source;\n}\n\nEventEmitterSource.prototype.run = function(sink, scheduler) {\n\t// NOTE: Because EventEmitter allows events in the same call stack as\n\t// a listener is added, use a DeferredSink to buffer events\n\t// until the stack clears, then propagate.  This maintains most.js's\n\t// invariant that no event will be delivered in the same call stack\n\t// as an observer begins observing.\n\tvar dsink = new DeferredSink(sink);\n\n\tfunction addEventVariadic(a) {\n\t\tvar l = arguments.length;\n\t\tif(l > 1) {\n\t\t\tvar arr = new Array(l);\n\t\t\tfor(var i=0; i<l; ++i) {\n\t\t\t\tarr[i] = arguments[i];\n\t\t\t}\n\t\t\ttryEvent.tryEvent(scheduler.now(), arr, dsink);\n\t\t} else {\n\t\t\ttryEvent.tryEvent(scheduler.now(), a, dsink);\n\t\t}\n\t}\n\n\tthis.source.addListener(this.event, addEventVariadic);\n\n\treturn dispose.create(disposeEventEmitter, { target: this, addEvent: addEventVariadic });\n};\n\nfunction disposeEventEmitter(info) {\n\tvar target = info.target;\n\ttarget.source.removeListener(target.event, info.addEvent);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar dispose = require('../disposable/dispose');\nvar tryEvent = require('./tryEvent');\n\nmodule.exports = EventTargetSource;\n\nfunction EventTargetSource(event, source, capture) {\n\tthis.event = event;\n\tthis.source = source;\n\tthis.capture = capture;\n}\n\nEventTargetSource.prototype.run = function(sink, scheduler) {\n\tfunction addEvent(e) {\n\t\ttryEvent.tryEvent(scheduler.now(), e, sink);\n\t}\n\n\tthis.source.addEventListener(this.event, addEvent, this.capture);\n\n\treturn dispose.create(disposeEventTarget,\n\t\t{ target: this, addEvent: addEvent });\n};\n\nfunction disposeEventTarget(info) {\n\tvar target = info.target;\n\ttarget.source.removeEventListener(target.event, info.addEvent, target.capture);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar dispose = require('../disposable/dispose');\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.of = streamOf;\nexports.empty = empty;\nexports.never = never;\n\n/**\n * Stream containing only x\n * @param {*} x\n * @returns {Stream}\n */\n function streamOf(x) {\n \treturn new Stream(new Just(x));\n }\n\n function Just(x) {\n \tthis.value = x;\n }\n\n Just.prototype.run = function(sink, scheduler) {\n \treturn scheduler.asap(new PropagateTask(runJust, this.value, sink));\n };\n\n function runJust(t, x, sink) {\n \tsink.event(t, x);\n \tsink.end(t, void 0);\n }\n\n/**\n * Stream containing no events and ends immediately\n * @returns {Stream}\n */\nfunction empty() {\n\treturn EMPTY;\n}\n\nfunction EmptySource() {}\n\nEmptySource.prototype.run = function(sink, scheduler) {\n\tvar task = PropagateTask.end(void 0, sink);\n\tscheduler.asap(task);\n\n\treturn dispose.create(disposeEmpty, task);\n};\n\nfunction disposeEmpty(task) {\n\treturn task.dispose();\n}\n\nvar EMPTY = new Stream(new EmptySource());\n\n/**\n * Stream containing no events and never ends\n * @returns {Stream}\n */\nfunction never() {\n\treturn NEVER;\n}\n\nfunction NeverSource() {}\n\nNeverSource.prototype.run = function() {\n\treturn dispose.empty();\n};\n\nvar NEVER = new Stream(new NeverSource());\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar MulticastSource = require('@most/multicast').MulticastSource;\nvar DeferredSink = require('../sink/DeferredSink');\nvar tryEvent = require('./tryEvent');\n\nexports.create = create;\n\n/**\n * @deprecated\n */\nfunction create(run) {\n\treturn new Stream(new MulticastSource(new SubscriberSource(run)));\n}\n\nfunction SubscriberSource(subscribe) {\n\tthis._subscribe = subscribe;\n}\n\nSubscriberSource.prototype.run = function(sink, scheduler) {\n\treturn new Subscription(new DeferredSink(sink), scheduler, this._subscribe);\n};\n\nfunction Subscription(sink, scheduler, subscribe) {\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.active = true;\n\tthis._unsubscribe = this._init(subscribe);\n}\n\nSubscription.prototype._init = function(subscribe) {\n\tvar s = this;\n\n\ttry {\n\t\treturn subscribe(add, end, error);\n\t} catch(e) {\n\t\terror(e);\n\t}\n\n\tfunction add(x) {\n\t\ts._add(x);\n\t}\n\tfunction end(x) {\n\t\ts._end(x);\n\t}\n\tfunction error(e) {\n\t\ts._error(e);\n\t}\n};\n\nSubscription.prototype._add = function(x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\ttryEvent.tryEvent(this.scheduler.now(), x, this.sink);\n};\n\nSubscription.prototype._end = function(x) {\n\tif(!this.active) {\n\t\treturn;\n\t}\n\tthis.active = false;\n\ttryEvent.tryEnd(this.scheduler.now(), x, this.sink);\n};\n\nSubscription.prototype._error = function(x) {\n\tthis.active = false;\n\tthis.sink.error(this.scheduler.now(), x);\n};\n\nSubscription.prototype.dispose = function() {\n\tthis.active = false;\n\tif(typeof this._unsubscribe === 'function') {\n\t\treturn this._unsubscribe.call(void 0);\n\t}\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar fromArray = require('./fromArray').fromArray;\nvar isIterable = require('../iterable').isIterable;\nvar fromIterable = require('./fromIterable').fromIterable;\nvar getObservable = require('../observable/getObservable');\nvar fromObservable = require('../observable/fromObservable').fromObservable;\nvar isArrayLike = require('@most/prelude').isArrayLike;\n\nexports.from = from;\n\nfunction from(a) { // eslint-disable-line complexity\n\tif(a instanceof Stream) {\n\t\treturn a;\n\t}\n\n\tvar observable = getObservable(a);\n\tif(observable != null) {\n\t\treturn fromObservable(observable);\n\t}\n\n\tif(Array.isArray(a) || isArrayLike(a)) {\n\t\treturn fromArray(a);\n\t}\n\n\tif(isIterable(a)) {\n\t\treturn fromIterable(a);\n\t}\n\n\tthrow new TypeError('from(x) must be observable, iterable, or array-like: ' + a);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.fromArray = fromArray;\n\nfunction fromArray (a) {\n\treturn new Stream(new ArraySource(a));\n}\n\nfunction ArraySource(a) {\n\tthis.array = a;\n}\n\nArraySource.prototype.run = function(sink, scheduler) {\n\treturn scheduler.asap(new PropagateTask(runProducer, this.array, sink));\n};\n\nfunction runProducer(t, array, sink) {\n\tfor(var i=0, l=array.length; i<l && this.active; ++i) {\n\t\tsink.event(t, array[i]);\n\t}\n\n\tthis.active && end(t);\n\n\tfunction end(t) {\n\t\tsink.end(t);\n\t}\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar MulticastSource = require('@most/multicast').MulticastSource;\nvar EventTargetSource = require('./EventTargetSource');\nvar EventEmitterSource = require('./EventEmitterSource');\n\nexports.fromEvent = fromEvent;\n\n/**\n * Create a stream from an EventTarget, such as a DOM Node, or EventEmitter.\n * @param {String} event event type name, e.g. 'click'\n * @param {EventTarget|EventEmitter} source EventTarget or EventEmitter\n * @param {boolean?} useCapture for DOM events, whether to use\n *  capturing--passed as 3rd parameter to addEventListener.\n * @returns {Stream} stream containing all events of the specified type\n * from the source.\n */\nfunction fromEvent(event, source /*, useCapture = false */) {\n\tvar s;\n\n\tif(typeof source.addEventListener === 'function' && typeof source.removeEventListener === 'function') {\n\t\tvar capture = arguments.length > 2 && !!arguments[2];\n\t\ts = new MulticastSource(new EventTargetSource(event, source, capture));\n\t} else if(typeof source.addListener === 'function' && typeof source.removeListener === 'function') {\n\t\ts = new EventEmitterSource(event, source);\n\t} else {\n\t\tthrow new Error('source must support addEventListener/removeEventListener or addListener/removeListener');\n\t}\n\n\treturn new Stream(s);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar getIterator = require('../iterable').getIterator;\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.fromIterable = fromIterable;\n\nfunction fromIterable(iterable) {\n\treturn new Stream(new IterableSource(iterable));\n}\n\nfunction IterableSource(iterable) {\n\tthis.iterable = iterable;\n}\n\nIterableSource.prototype.run = function(sink, scheduler) {\n\treturn new IteratorProducer(getIterator(this.iterable), sink, scheduler);\n};\n\nfunction IteratorProducer(iterator, sink, scheduler) {\n\tthis.scheduler = scheduler;\n\tthis.iterator = iterator;\n\tthis.task = new PropagateTask(runProducer, this, sink);\n\tscheduler.asap(this.task);\n}\n\nIteratorProducer.prototype.dispose = function() {\n\treturn this.task.dispose();\n};\n\nfunction runProducer(t, producer, sink) {\n\tvar x = producer.iterator.next();\n\tif(x.done) {\n\t\tsink.end(t, x.value);\n\t} else {\n\t\tsink.event(t, x.value);\n\t}\n\n\tproducer.scheduler.asap(producer.task);\n}\n","/** @license MIT License (c) copyright 2010-2014 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar base = require('@most/prelude');\n\nexports.generate = generate;\n\n/**\n * Compute a stream using an *async* generator, which yields promises\n * to control event times.\n * @param f\n * @returns {Stream}\n */\nfunction generate(f /*, ...args */) {\n\treturn new Stream(new GenerateSource(f, base.tail(arguments)));\n}\n\nfunction GenerateSource(f, args) {\n\tthis.f = f;\n\tthis.args = args;\n}\n\nGenerateSource.prototype.run = function(sink, scheduler) {\n\treturn new Generate(this.f.apply(void 0, this.args), sink, scheduler);\n};\n\nfunction Generate(iterator, sink, scheduler) {\n\tthis.iterator = iterator;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.active = true;\n\n\tvar self = this;\n\tfunction err(e) {\n\t\tself.sink.error(self.scheduler.now(), e);\n\t}\n\n\tPromise.resolve(this).then(next).catch(err);\n}\n\nfunction next(generate, x) {\n\treturn generate.active ? handle(generate, generate.iterator.next(x)) : x;\n}\n\nfunction handle(generate, result) {\n\tif (result.done) {\n\t\treturn generate.sink.end(generate.scheduler.now(), result.value);\n\t}\n\n\treturn Promise.resolve(result.value).then(function (x) {\n\t\treturn emit(generate, x);\n\t}, function(e) {\n\t\treturn error(generate, e);\n\t});\n}\n\nfunction emit(generate, x) {\n\tgenerate.sink.event(generate.scheduler.now(), x);\n\treturn next(generate, x);\n}\n\nfunction error(generate, e) {\n\treturn handle(generate, generate.iterator.throw(e));\n}\n\nGenerate.prototype.dispose = function() {\n\tthis.active = false;\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\n\nexports.iterate = iterate;\n\n/**\n * Compute a stream by iteratively calling f to produce values\n * Event times may be controlled by returning a Promise from f\n * @param {function(x:*):*|Promise<*>} f\n * @param {*} x initial value\n * @returns {Stream}\n */\nfunction iterate(f, x) {\n\treturn new Stream(new IterateSource(f, x));\n}\n\nfunction IterateSource(f, x) {\n\tthis.f = f;\n\tthis.value = x;\n}\n\nIterateSource.prototype.run = function(sink, scheduler) {\n\treturn new Iterate(this.f, this.value, sink, scheduler);\n};\n\nfunction Iterate(f, initial, sink, scheduler) {\n\tthis.f = f;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.active = true;\n\n\tvar x = initial;\n\n\tvar self = this;\n\tfunction err(e) {\n\t\tself.sink.error(self.scheduler.now(), e);\n\t}\n\n\tfunction start(iterate) {\n\t\treturn stepIterate(iterate, x);\n\t}\n\n\tPromise.resolve(this).then(start).catch(err);\n}\n\nIterate.prototype.dispose = function() {\n\tthis.active = false;\n};\n\nfunction stepIterate(iterate, x) {\n\titerate.sink.event(iterate.scheduler.now(), x);\n\n\tif(!iterate.active) {\n\t\treturn x;\n\t}\n\n\tvar f = iterate.f;\n\treturn Promise.resolve(f(x)).then(function(y) {\n\t\treturn continueIterate(iterate, y);\n\t});\n}\n\nfunction continueIterate(iterate, x) {\n\treturn !iterate.active ? iterate.value : stepIterate(iterate, x);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\nvar dispose = require('../disposable/dispose');\nvar MulticastSource = require('@most/multicast').MulticastSource;\nvar PropagateTask = require('../scheduler/PropagateTask');\n\nexports.periodic = periodic;\n\n/**\n * Create a stream that emits the current time periodically\n * @param {Number} period periodicity of events in millis\n * @param {*) value value to emit each period\n * @returns {Stream} new stream that emits the current time every period\n */\nfunction periodic(period, value) {\n\treturn new Stream(new MulticastSource(new Periodic(period, value)));\n}\n\nfunction Periodic(period, value) {\n\tthis.period = period;\n\tthis.value = value;\n}\n\nPeriodic.prototype.run = function(sink, scheduler) {\n\treturn scheduler.periodic(this.period, new PropagateTask(emit, this.value, sink));\n};\n\nfunction emit(t, x, sink) {\n\tsink.event(t, x);\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nexports.tryEvent = tryEvent;\nexports.tryEnd = tryEnd;\n\nfunction tryEvent(t, x, sink) {\n\ttry {\n\t\tsink.event(t, x);\n\t} catch(e) {\n\t\tsink.error(t, e);\n\t}\n}\n\nfunction tryEnd(t, x, sink) {\n\ttry {\n\t\tsink.end(t, x);\n\t} catch(e) {\n\t\tsink.error(t, e);\n\t}\n}\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('../Stream');\n\nexports.unfold = unfold;\n\n/**\n * Compute a stream by unfolding tuples of future values from a seed value\n * Event times may be controlled by returning a Promise from f\n * @param {function(seed:*):{value:*, seed:*, done:boolean}|Promise<{value:*, seed:*, done:boolean}>} f unfolding function accepts\n *  a seed and returns a new tuple with a value, new seed, and boolean done flag.\n *  If tuple.done is true, the stream will end.\n * @param {*} seed seed value\n * @returns {Stream} stream containing all value of all tuples produced by the\n *  unfolding function.\n */\nfunction unfold(f, seed) {\n\treturn new Stream(new UnfoldSource(f, seed));\n}\n\nfunction UnfoldSource(f, seed) {\n\tthis.f = f;\n\tthis.value = seed;\n}\n\nUnfoldSource.prototype.run = function(sink, scheduler) {\n\treturn new Unfold(this.f, this.value, sink, scheduler);\n};\n\nfunction Unfold(f, x, sink, scheduler) {\n\tthis.f = f;\n\tthis.sink = sink;\n\tthis.scheduler = scheduler;\n\tthis.active = true;\n\n\tvar self = this;\n\tfunction err(e) {\n\t\tself.sink.error(self.scheduler.now(), e);\n\t}\n\n\tfunction start(unfold) {\n\t\treturn stepUnfold(unfold, x);\n\t}\n\n\tPromise.resolve(this).then(start).catch(err);\n}\n\nUnfold.prototype.dispose = function() {\n\tthis.active = false;\n};\n\nfunction stepUnfold(unfold, x) {\n\tvar f = unfold.f;\n\treturn Promise.resolve(f(x)).then(function(tuple) {\n\t\treturn continueUnfold(unfold, tuple);\n\t});\n}\n\nfunction continueUnfold(unfold, tuple) {\n\tif(tuple.done) {\n\t\tunfold.sink.end(unfold.scheduler.now(), tuple.value);\n\t\treturn tuple.value;\n\t}\n\n\tunfold.sink.event(unfold.scheduler.now(), tuple.value);\n\n\tif(!unfold.active) {\n\t\treturn tuple.value;\n\t}\n\treturn stepUnfold(unfold, tuple.seed);\n}\n","(function (global, factory) {\n  if (typeof define === \"function\" && define.amd) {\n    define('@most/multicast', ['exports', '@most/prelude'], factory);\n  } else if (typeof exports !== \"undefined\") {\n    factory(exports, require('@most/prelude'));\n  } else {\n    var mod = {\n      exports: {}\n    };\n    factory(mod.exports, global.prelude);\n    global.mostMulticast = mod.exports;\n  }\n})(this, function (exports, _prelude) {\n  'use strict';\n\n  Object.defineProperty(exports, \"__esModule\", {\n    value: true\n  });\n  exports.MulticastSource = undefined;\n\n  function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  }\n\n  var _createClass = function () {\n    function defineProperties(target, props) {\n      for (var i = 0; i < props.length; i++) {\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n      }\n    }\n\n    return function (Constructor, protoProps, staticProps) {\n      if (protoProps) defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) defineProperties(Constructor, staticProps);\n      return Constructor;\n    };\n  }();\n\n  var MulticastDisposable = function () {\n    function MulticastDisposable(source, sink) {\n      _classCallCheck(this, MulticastDisposable);\n\n      this.source = source;\n      this.sink = sink;\n      this.disposed = false;\n    }\n\n    _createClass(MulticastDisposable, [{\n      key: 'dispose',\n      value: function dispose() {\n        if (this.disposed) {\n          return;\n        }\n        this.disposed = true;\n        var remaining = this.source.remove(this.sink);\n        return remaining === 0 && this.source._dispose();\n      }\n    }]);\n\n    return MulticastDisposable;\n  }();\n\n  function tryEvent(t, x, sink) {\n    try {\n      sink.event(t, x);\n    } catch (e) {\n      sink.error(t, e);\n    }\n  }\n\n  function tryEnd(t, x, sink) {\n    try {\n      sink.end(t, x);\n    } catch (e) {\n      sink.error(t, e);\n    }\n  }\n\n  var dispose = function dispose(disposable) {\n    return disposable.dispose();\n  };\n\n  var emptyDisposable = {\n    dispose: function dispose() {}\n  };\n\n  var MulticastSource = function () {\n    function MulticastSource(source) {\n      _classCallCheck(this, MulticastSource);\n\n      this.source = source;\n      this.sinks = [];\n      this._disposable = emptyDisposable;\n    }\n\n    _createClass(MulticastSource, [{\n      key: 'run',\n      value: function run(sink, scheduler) {\n        var n = this.add(sink);\n        if (n === 1) {\n          this._disposable = this.source.run(this, scheduler);\n        }\n        return new MulticastDisposable(this, sink);\n      }\n    }, {\n      key: '_dispose',\n      value: function _dispose() {\n        var disposable = this._disposable;\n        this._disposable = emptyDisposable;\n        return Promise.resolve(disposable).then(dispose);\n      }\n    }, {\n      key: 'add',\n      value: function add(sink) {\n        this.sinks = (0, _prelude.append)(sink, this.sinks);\n        return this.sinks.length;\n      }\n    }, {\n      key: 'remove',\n      value: function remove(sink) {\n        var i = (0, _prelude.findIndex)(sink, this.sinks);\n        // istanbul ignore next\n        if (i >= 0) {\n          this.sinks = (0, _prelude.remove)(i, this.sinks);\n        }\n\n        return this.sinks.length;\n      }\n    }, {\n      key: 'event',\n      value: function event(time, value) {\n        var s = this.sinks;\n        if (s.length === 1) {\n          return s[0].event(time, value);\n        }\n        for (var i = 0; i < s.length; ++i) {\n          tryEvent(time, value, s[i]);\n        }\n      }\n    }, {\n      key: 'end',\n      value: function end(time, value) {\n        var s = this.sinks;\n        for (var i = 0; i < s.length; ++i) {\n          tryEnd(time, value, s[i]);\n        }\n      }\n    }, {\n      key: 'error',\n      value: function error(time, err) {\n        var s = this.sinks;\n        for (var i = 0; i < s.length; ++i) {\n          s[i].error(time, err);\n        }\n      }\n    }]);\n\n    return MulticastSource;\n  }();\n\n  function multicast(stream) {\n    var source = stream.source;\n    return source instanceof MulticastSource ? stream : new stream.constructor(new MulticastSource(source));\n  }\n\n  exports.MulticastSource = MulticastSource;\n  exports.default = multicast;\n});\n","(function (global, factory) {\n  if (typeof define === \"function\" && define.amd) {\n    define('@most/prelude', ['exports'], factory);\n  } else if (typeof exports !== \"undefined\") {\n    factory(exports);\n  } else {\n    var mod = {\n      exports: {}\n    };\n    factory(mod.exports);\n    global.mostPrelude = mod.exports;\n  }\n})(this, function (exports) {\n  'use strict';\n\n  Object.defineProperty(exports, \"__esModule\", {\n    value: true\n  });\n  /** @license MIT License (c) copyright 2010-2016 original author or authors */\n\n  // Non-mutating array operations\n\n  // cons :: a -> [a] -> [a]\n  // a with x prepended\n  function cons(x, a) {\n    var l = a.length;\n    var b = new Array(l + 1);\n    b[0] = x;\n    for (var i = 0; i < l; ++i) {\n      b[i + 1] = a[i];\n    }\n    return b;\n  }\n\n  // append :: a -> [a] -> [a]\n  // a with x appended\n  function append(x, a) {\n    var l = a.length;\n    var b = new Array(l + 1);\n    for (var i = 0; i < l; ++i) {\n      b[i] = a[i];\n    }\n\n    b[l] = x;\n    return b;\n  }\n\n  // drop :: Int -> [a] -> [a]\n  // drop first n elements\n  function drop(n, a) {\n    // eslint-disable-line complexity\n    if (n < 0) {\n      throw new TypeError('n must be >= 0');\n    }\n\n    var l = a.length;\n    if (n === 0 || l === 0) {\n      return a;\n    }\n\n    if (n >= l) {\n      return [];\n    }\n\n    return unsafeDrop(n, a, l - n);\n  }\n\n  // unsafeDrop :: Int -> [a] -> Int -> [a]\n  // Internal helper for drop\n  function unsafeDrop(n, a, l) {\n    var b = new Array(l);\n    for (var i = 0; i < l; ++i) {\n      b[i] = a[n + i];\n    }\n    return b;\n  }\n\n  // tail :: [a] -> [a]\n  // drop head element\n  function tail(a) {\n    return drop(1, a);\n  }\n\n  // copy :: [a] -> [a]\n  // duplicate a (shallow duplication)\n  function copy(a) {\n    var l = a.length;\n    var b = new Array(l);\n    for (var i = 0; i < l; ++i) {\n      b[i] = a[i];\n    }\n    return b;\n  }\n\n  // map :: (a -> b) -> [a] -> [b]\n  // transform each element with f\n  function map(f, a) {\n    var l = a.length;\n    var b = new Array(l);\n    for (var i = 0; i < l; ++i) {\n      b[i] = f(a[i]);\n    }\n    return b;\n  }\n\n  // reduce :: (a -> b -> a) -> a -> [b] -> a\n  // accumulate via left-fold\n  function reduce(f, z, a) {\n    var r = z;\n    for (var i = 0, l = a.length; i < l; ++i) {\n      r = f(r, a[i], i);\n    }\n    return r;\n  }\n\n  // replace :: a -> Int -> [a]\n  // replace element at index\n  function replace(x, i, a) {\n    // eslint-disable-line complexity\n    if (i < 0) {\n      throw new TypeError('i must be >= 0');\n    }\n\n    var l = a.length;\n    var b = new Array(l);\n    for (var j = 0; j < l; ++j) {\n      b[j] = i === j ? x : a[j];\n    }\n    return b;\n  }\n\n  // remove :: Int -> [a] -> [a]\n  // remove element at index\n  function remove(i, a) {\n    // eslint-disable-line complexity\n    if (i < 0) {\n      throw new TypeError('i must be >= 0');\n    }\n\n    var l = a.length;\n    if (l === 0 || i >= l) {\n      // exit early if index beyond end of array\n      return a;\n    }\n\n    if (l === 1) {\n      // exit early if index in bounds and length === 1\n      return [];\n    }\n\n    return unsafeRemove(i, a, l - 1);\n  }\n\n  // unsafeRemove :: Int -> [a] -> Int -> [a]\n  // Internal helper to remove element at index\n  function unsafeRemove(i, a, l) {\n    var b = new Array(l);\n    var j = undefined;\n    for (j = 0; j < i; ++j) {\n      b[j] = a[j];\n    }\n    for (j = i; j < l; ++j) {\n      b[j] = a[j + 1];\n    }\n\n    return b;\n  }\n\n  // removeAll :: (a -> boolean) -> [a] -> [a]\n  // remove all elements matching a predicate\n  function removeAll(f, a) {\n    var l = a.length;\n    var b = new Array(l);\n    var j = 0;\n    for (var x, i = 0; i < l; ++i) {\n      x = a[i];\n      if (!f(x)) {\n        b[j] = x;\n        ++j;\n      }\n    }\n\n    b.length = j;\n    return b;\n  }\n\n  // findIndex :: a -> [a] -> Int\n  // find index of x in a, from the left\n  function findIndex(x, a) {\n    for (var i = 0, l = a.length; i < l; ++i) {\n      if (x === a[i]) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  // isArrayLike :: * -> boolean\n  // Return true iff x is array-like\n  function isArrayLike(x) {\n    return x != null && typeof x.length === 'number' && typeof x !== 'function';\n  }\n\n  /** @license MIT License (c) copyright 2010-2016 original author or authors */\n\n  // id :: a -> a\n  var id = function id(x) {\n    return x;\n  };\n\n  // compose :: (b -> c) -> (a -> b) -> (a -> c)\n  var compose = function compose(f, g) {\n    return function (x) {\n      return f(g(x));\n    };\n  };\n\n  // apply :: (a -> b) -> a -> b\n  var apply = function apply(f, x) {\n    return f(x);\n  };\n\n  // curry2 :: ((a, b) -> c) -> (a -> b -> c)\n  function curry2(f) {\n    function curried(a, b) {\n      switch (arguments.length) {\n        case 0:\n          return curried;\n        case 1:\n          return function (b) {\n            return f(a, b);\n          };\n        default:\n          return f(a, b);\n      }\n    }\n    return curried;\n  }\n\n  // curry3 :: ((a, b, c) -> d) -> (a -> b -> c -> d)\n  function curry3(f) {\n    function curried(a, b, c) {\n      // eslint-disable-line complexity\n      switch (arguments.length) {\n        case 0:\n          return curried;\n        case 1:\n          return curry2(function (b, c) {\n            return f(a, b, c);\n          });\n        case 2:\n          return function (c) {\n            return f(a, b, c);\n          };\n        default:\n          return f(a, b, c);\n      }\n    }\n    return curried;\n  }\n\n  exports.cons = cons;\n  exports.append = append;\n  exports.drop = drop;\n  exports.tail = tail;\n  exports.copy = copy;\n  exports.map = map;\n  exports.reduce = reduce;\n  exports.replace = replace;\n  exports.remove = remove;\n  exports.removeAll = removeAll;\n  exports.findIndex = findIndex;\n  exports.isArrayLike = isArrayLike;\n  exports.id = id;\n  exports.compose = compose;\n  exports.apply = apply;\n  exports.curry2 = curry2;\n  exports.curry3 = curry3;\n});\n","(function (global){\n/* global window */\n'use strict';\n\nmodule.exports = require('./ponyfill')(global || window || this);\n\n}).call(this,typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})\n//# sourceMappingURL=data:application/json;charset:utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9zeW1ib2wtb2JzZXJ2YWJsZS9pbmRleC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQSIsImZpbGUiOiJnZW5lcmF0ZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyogZ2xvYmFsIHdpbmRvdyAqL1xuJ3VzZSBzdHJpY3QnO1xuXG5tb2R1bGUuZXhwb3J0cyA9IHJlcXVpcmUoJy4vcG9ueWZpbGwnKShnbG9iYWwgfHwgd2luZG93IHx8IHRoaXMpO1xuIl19","'use strict';\n\nmodule.exports = function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n","/** @license MIT License (c) copyright 2010-2016 original author or authors */\n/** @author Brian Cavalier */\n/** @author John Hann */\n\nvar Stream = require('./lib/Stream');\nvar base = require('@most/prelude');\nvar core = require('./lib/source/core');\nvar from = require('./lib/source/from').from;\nvar periodic = require('./lib/source/periodic').periodic;\nvar symbolObservable = require('symbol-observable');\n\n/**\n * Core stream type\n * @type {Stream}\n */\nexports.Stream = Stream;\n\n// Add of and empty to constructor for fantasy-land compat\nexports.of       = Stream.of    = core.of;\nexports.just     = core.of; // easier ES6 import alias\nexports.empty    = Stream.empty = core.empty;\nexports.never    = core.never;\nexports.from     = from;\nexports.periodic = periodic;\n\n//-----------------------------------------------------------------------\n// Draft ES Observable proposal interop\n// https://github.com/zenparsing/es-observable\n\nvar subscribe = require('./lib/observable/subscribe').subscribe;\n\nStream.prototype.subscribe = function(subscriber) {\n\treturn subscribe(subscriber, this);\n};\n\nStream.prototype[symbolObservable] = function() {\n\treturn this;\n}\n\n//-----------------------------------------------------------------------\n// Fluent adapter\n\nvar thru = require('./lib/combinator/thru').thru;\n\n/**\n * Adapt a functional stream transform to fluent style.\n * It applies f to the this stream object\n * @param  {function(s: Stream): Stream} f function that\n * receives the stream itself and must return a new stream\n * @return {Stream}\n */\nStream.prototype.thru = function(f) {\n\treturn thru(f, this);\n}\n\n//-----------------------------------------------------------------------\n// Creating\n\nvar create = require('./lib/source/create');\n\n/**\n * @deprecated\n * Create a stream by imperatively pushing events.\n * @param {function(add:function(x), end:function(e)):function} run function\n *  that will receive 2 functions as arguments, the first to add new values to the\n *  stream and the second to end the stream. It may *return* a function that\n *  will be called once all consumers have stopped observing the stream.\n * @returns {Stream} stream containing all events added by run before end\n */\nexports.create = create.create;\n\n//-----------------------------------------------------------------------\n// Adapting other sources\n\nvar events = require('./lib/source/fromEvent');\n\n/**\n * Create a stream of events from the supplied EventTarget or EventEmitter\n * @param {String} event event name\n * @param {EventTarget|EventEmitter} source EventTarget or EventEmitter. The source\n *  must support either addEventListener/removeEventListener (w3c EventTarget:\n *  http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-EventTarget),\n *  or addListener/removeListener (node EventEmitter: http://nodejs.org/api/events.html)\n * @returns {Stream} stream of events of the specified type from the source\n */\nexports.fromEvent = events.fromEvent;\n\n//-----------------------------------------------------------------------\n// Observing\n\nvar observe = require('./lib/combinator/observe');\n\nexports.observe = observe.observe;\nexports.forEach = observe.observe;\nexports.drain   = observe.drain;\n\n/**\n * Process all the events in the stream\n * @returns {Promise} promise that fulfills when the stream ends, or rejects\n *  if the stream fails with an unhandled error.\n */\nStream.prototype.observe = Stream.prototype.forEach = function(f) {\n\treturn observe.observe(f, this);\n};\n\n/**\n * Consume all events in the stream, without providing a function to process each.\n * This causes a stream to become active and begin emitting events, and is useful\n * in cases where all processing has been setup upstream via other combinators, and\n * there is no need to process the terminal events.\n * @returns {Promise} promise that fulfills when the stream ends, or rejects\n *  if the stream fails with an unhandled error.\n */\nStream.prototype.drain = function() {\n\treturn observe.drain(this);\n};\n\n//-------------------------------------------------------\n\nvar loop = require('./lib/combinator/loop').loop;\n\nexports.loop = loop;\n\n/**\n * Generalized feedback loop. Call a stepper function for each event. The stepper\n * will be called with 2 params: the current seed and the an event value.  It must\n * return a new { seed, value } pair. The `seed` will be fed back into the next\n * invocation of stepper, and the `value` will be propagated as the event value.\n * @param {function(seed:*, value:*):{seed:*, value:*}} stepper loop step function\n * @param {*} seed initial seed value passed to first stepper call\n * @returns {Stream} new stream whose values are the `value` field of the objects\n * returned by the stepper\n */\nStream.prototype.loop = function(stepper, seed) {\n\treturn loop(stepper, seed, this);\n};\n\n//-------------------------------------------------------\n\nvar accumulate = require('./lib/combinator/accumulate');\n\nexports.scan   = accumulate.scan;\nexports.reduce = accumulate.reduce;\n\n/**\n * Create a stream containing successive reduce results of applying f to\n * the previous reduce result and the current stream item.\n * @param {function(result:*, x:*):*} f reducer function\n * @param {*} initial initial value\n * @returns {Stream} new stream containing successive reduce results\n */\nStream.prototype.scan = function(f, initial) {\n\treturn accumulate.scan(f, initial, this);\n};\n\n/**\n * Reduce the stream to produce a single result.  Note that reducing an infinite\n * stream will return a Promise that never fulfills, but that may reject if an error\n * occurs.\n * @param {function(result:*, x:*):*} f reducer function\n * @param {*} initial optional initial value\n * @returns {Promise} promise for the file result of the reduce\n */\nStream.prototype.reduce = function(f, initial) {\n\treturn accumulate.reduce(f, initial, this);\n};\n\n//-----------------------------------------------------------------------\n// Building and extending\n\nvar unfold = require('./lib/source/unfold');\nvar iterate = require('./lib/source/iterate');\nvar generate = require('./lib/source/generate');\nvar build = require('./lib/combinator/build');\n\nexports.unfold    = unfold.unfold;\nexports.iterate   = iterate.iterate;\nexports.generate  = generate.generate;\nexports.cycle     = build.cycle;\nexports.concat    = build.concat;\nexports.startWith = build.cons;\n\n/**\n * @deprecated\n * Tie this stream into a circle, thus creating an infinite stream\n * @returns {Stream} new infinite stream\n */\nStream.prototype.cycle = function() {\n\treturn build.cycle(this);\n};\n\n/**\n * @param {Stream} tail\n * @returns {Stream} new stream containing all items in this followed by\n *  all items in tail\n */\nStream.prototype.concat = function(tail) {\n\treturn build.concat(this, tail);\n};\n\n/**\n * @param {*} x value to prepend\n * @returns {Stream} a new stream with x prepended\n */\nStream.prototype.startWith = function(x) {\n\treturn build.cons(x, this);\n};\n\n//-----------------------------------------------------------------------\n// Transforming\n\nvar transform = require('./lib/combinator/transform');\nvar applicative = require('./lib/combinator/applicative');\n\nexports.map      = transform.map;\nexports.constant = transform.constant;\nexports.tap      = transform.tap;\nexports.ap       = applicative.ap;\n\n/**\n * Transform each value in the stream by applying f to each\n * @param {function(*):*} f mapping function\n * @returns {Stream} stream containing items transformed by f\n */\nStream.prototype.map = function(f) {\n\treturn transform.map(f, this);\n};\n\n/**\n * Assume this stream contains functions, and apply each function to each item\n * in the provided stream.  This generates, in effect, a cross product.\n * @param {Stream} xs stream of items to which\n * @returns {Stream} stream containing the cross product of items\n */\nStream.prototype.ap = function(xs) {\n\treturn applicative.ap(this, xs);\n};\n\n/**\n * Replace each value in the stream with x\n * @param {*} x\n * @returns {Stream} stream containing items replaced with x\n */\nStream.prototype.constant = function(x) {\n\treturn transform.constant(x, this);\n};\n\n/**\n * Perform a side effect for each item in the stream\n * @param {function(x:*):*} f side effect to execute for each item. The\n *  return value will be discarded.\n * @returns {Stream} new stream containing the same items as this stream\n */\nStream.prototype.tap = function(f) {\n\treturn transform.tap(f, this);\n};\n\n//-----------------------------------------------------------------------\n// Transducer support\n\nvar transduce = require('./lib/combinator/transduce');\n\nexports.transduce = transduce.transduce;\n\n/**\n * Transform this stream by passing its events through a transducer.\n * @param  {function} transducer transducer function\n * @return {Stream} stream of events transformed by the transducer\n */\nStream.prototype.transduce = function(transducer) {\n\treturn transduce.transduce(transducer, this);\n};\n\n//-----------------------------------------------------------------------\n// FlatMapping\n\nvar flatMap = require('./lib/combinator/flatMap');\n\nexports.flatMap = exports.chain = flatMap.flatMap;\nexports.join    = flatMap.join;\n\n/**\n * Map each value in the stream to a new stream, and merge it into the\n * returned outer stream. Event arrival times are preserved.\n * @param {function(x:*):Stream} f chaining function, must return a Stream\n * @returns {Stream} new stream containing all events from each stream returned by f\n */\nStream.prototype.flatMap = Stream.prototype.chain = function(f) {\n\treturn flatMap.flatMap(f, this);\n};\n\n/**\n * Monadic join. Flatten a Stream<Stream<X>> to Stream<X> by merging inner\n * streams to the outer. Event arrival times are preserved.\n * @returns {Stream<X>} new stream containing all events of all inner streams\n */\nStream.prototype.join = function() {\n\treturn flatMap.join(this);\n};\n\nvar continueWith = require('./lib/combinator/continueWith').continueWith;\n\nexports.continueWith = continueWith;\nexports.flatMapEnd = continueWith;\n\n/**\n * Map the end event to a new stream, and begin emitting its values.\n * @param {function(x:*):Stream} f function that receives the end event value,\n * and *must* return a new Stream to continue with.\n * @returns {Stream} new stream that emits all events from the original stream,\n * followed by all events from the stream returned by f.\n */\nStream.prototype.continueWith = Stream.prototype.flatMapEnd = function(f) {\n\treturn continueWith(f, this);\n};\n\nvar concatMap = require('./lib/combinator/concatMap').concatMap;\n\nexports.concatMap = concatMap;\n\nStream.prototype.concatMap = function(f) {\n\treturn concatMap(f, this);\n};\n\n//-----------------------------------------------------------------------\n// Concurrent merging\n\nvar mergeConcurrently = require('./lib/combinator/mergeConcurrently');\n\nexports.mergeConcurrently = mergeConcurrently.mergeConcurrently;\n\n/**\n * Flatten a Stream<Stream<X>> to Stream<X> by merging inner\n * streams to the outer, limiting the number of inner streams that may\n * be active concurrently.\n * @param {number} concurrency at most this many inner streams will be\n *  allowed to be active concurrently.\n * @return {Stream<X>} new stream containing all events of all inner\n *  streams, with limited concurrency.\n */\nStream.prototype.mergeConcurrently = function(concurrency) {\n\treturn mergeConcurrently.mergeConcurrently(concurrency, this);\n};\n\n//-----------------------------------------------------------------------\n// Merging\n\nvar merge = require('./lib/combinator/merge');\n\nexports.merge = merge.merge;\nexports.mergeArray = merge.mergeArray;\n\n/**\n * Merge this stream and all the provided streams\n * @returns {Stream} stream containing items from this stream and s in time\n * order.  If two events are simultaneous they will be merged in\n * arbitrary order.\n */\nStream.prototype.merge = function(/*...streams*/) {\n\treturn merge.mergeArray(base.cons(this, arguments));\n};\n\n//-----------------------------------------------------------------------\n// Combining\n\nvar combine = require('./lib/combinator/combine');\n\nexports.combine = combine.combine;\nexports.combineArray = combine.combineArray;\n\n/**\n * Combine latest events from all input streams\n * @param {function(...events):*} f function to combine most recent events\n * @returns {Stream} stream containing the result of applying f to the most recent\n *  event of each input stream, whenever a new event arrives on any stream.\n */\nStream.prototype.combine = function(f /*, ...streams*/) {\n\treturn combine.combineArray(f, base.replace(this, 0, arguments));\n};\n\n//-----------------------------------------------------------------------\n// Sampling\n\nvar sample = require('./lib/combinator/sample');\n\nexports.sample = sample.sample;\nexports.sampleWith = sample.sampleWith;\n\n/**\n * When an event arrives on sampler, emit the latest event value from stream.\n * @param {Stream} sampler stream of events at whose arrival time\n *  signal's latest value will be propagated\n * @returns {Stream} sampled stream of values\n */\nStream.prototype.sampleWith = function(sampler) {\n\treturn sample.sampleWith(sampler, this);\n};\n\n/**\n * When an event arrives on this stream, emit the result of calling f with the latest\n * values of all streams being sampled\n * @param {function(...values):*} f function to apply to each set of sampled values\n * @returns {Stream} stream of sampled and transformed values\n */\nStream.prototype.sample = function(f /* ...streams */) {\n\treturn sample.sampleArray(f, this, base.tail(arguments));\n};\n\n//-----------------------------------------------------------------------\n// Zipping\n\nvar zip = require('./lib/combinator/zip');\n\nexports.zip = zip.zip;\n\n/**\n * Pair-wise combine items with those in s. Given 2 streams:\n * [1,2,3] zipWith f [4,5,6] -> [f(1,4),f(2,5),f(3,6)]\n * Note: zip causes fast streams to buffer and wait for slow streams.\n * @param {function(a:Stream, b:Stream, ...):*} f function to combine items\n * @returns {Stream} new stream containing pairs\n */\nStream.prototype.zip = function(f /*, ...streams*/) {\n\treturn zip.zipArray(f, base.replace(this, 0, arguments));\n};\n\n//-----------------------------------------------------------------------\n// Switching\n\nvar switchLatest = require('./lib/combinator/switch').switch;\n\nexports.switch       = switchLatest;\nexports.switchLatest = switchLatest;\n\n/**\n * Given a stream of streams, return a new stream that adopts the behavior\n * of the most recent inner stream.\n * @returns {Stream} switching stream\n */\nStream.prototype.switch = Stream.prototype.switchLatest = function() {\n\treturn switchLatest(this);\n};\n\n//-----------------------------------------------------------------------\n// Filtering\n\nvar filter = require('./lib/combinator/filter');\n\nexports.filter          = filter.filter;\nexports.skipRepeats     = exports.distinct   = filter.skipRepeats;\nexports.skipRepeatsWith = exports.distinctBy = filter.skipRepeatsWith;\n\n/**\n * Retain only items matching a predicate\n * stream:                           -12345678-\n * filter(x => x % 2 === 0, stream): --2-4-6-8-\n * @param {function(x:*):boolean} p filtering predicate called for each item\n * @returns {Stream} stream containing only items for which predicate returns truthy\n */\nStream.prototype.filter = function(p) {\n\treturn filter.filter(p, this);\n};\n\n/**\n * Skip repeated events, using === to compare items\n * stream:           -abbcd-\n * distinct(stream): -ab-cd-\n * @returns {Stream} stream with no repeated events\n */\nStream.prototype.skipRepeats = function() {\n\treturn filter.skipRepeats(this);\n};\n\n/**\n * Skip repeated events, using supplied equals function to compare items\n * @param {function(a:*, b:*):boolean} equals function to compare items\n * @returns {Stream} stream with no repeated events\n */\nStream.prototype.skipRepeatsWith = function(equals) {\n\treturn filter.skipRepeatsWith(equals, this);\n};\n\n//-----------------------------------------------------------------------\n// Slicing\n\nvar slice = require('./lib/combinator/slice');\n\nexports.take      = slice.take;\nexports.skip      = slice.skip;\nexports.slice     = slice.slice;\nexports.takeWhile = slice.takeWhile;\nexports.skipWhile = slice.skipWhile;\n\n/**\n * stream:          -abcd-\n * take(2, stream): -ab|\n * @param {Number} n take up to this many events\n * @returns {Stream} stream containing at most the first n items from this stream\n */\nStream.prototype.take = function(n) {\n\treturn slice.take(n, this);\n};\n\n/**\n * stream:          -abcd->\n * skip(2, stream): ---cd->\n * @param {Number} n skip this many events\n * @returns {Stream} stream not containing the first n events\n */\nStream.prototype.skip = function(n) {\n\treturn slice.skip(n, this);\n};\n\n/**\n * Slice a stream by event index. Equivalent to, but more efficient than\n * stream.take(end).skip(start);\n * NOTE: Negative start and end are not supported\n * @param {Number} start skip all events before the start index\n * @param {Number} end allow all events from the start index to the end index\n * @returns {Stream} stream containing items where start <= index < end\n */\nStream.prototype.slice = function(start, end) {\n\treturn slice.slice(start, end, this);\n};\n\n/**\n * stream:                        -123451234->\n * takeWhile(x => x < 5, stream): -1234|\n * @param {function(x:*):boolean} p predicate\n * @returns {Stream} stream containing items up to, but not including, the\n * first item for which p returns falsy.\n */\nStream.prototype.takeWhile = function(p) {\n\treturn slice.takeWhile(p, this);\n};\n\n/**\n * stream:                        -123451234->\n * skipWhile(x => x < 5, stream): -----51234->\n * @param {function(x:*):boolean} p predicate\n * @returns {Stream} stream containing items following *and including* the\n * first item for which p returns falsy.\n */\nStream.prototype.skipWhile = function(p) {\n\treturn slice.skipWhile(p, this);\n};\n\n//-----------------------------------------------------------------------\n// Time slicing\n\nvar timeslice = require('./lib/combinator/timeslice');\n\nexports.until  = exports.takeUntil = timeslice.takeUntil;\nexports.since  = exports.skipUntil = timeslice.skipUntil;\nexports.during = timeslice.during;\n\n/**\n * stream:                    -a-b-c-d-e-f-g->\n * signal:                    -------x\n * takeUntil(signal, stream): -a-b-c-|\n * @param {Stream} signal retain only events in stream before the first\n * event in signal\n * @returns {Stream} new stream containing only events that occur before\n * the first event in signal.\n */\nStream.prototype.until = Stream.prototype.takeUntil = function(signal) {\n\treturn timeslice.takeUntil(signal, this);\n};\n\n/**\n * stream:                    -a-b-c-d-e-f-g->\n * signal:                    -------x\n * takeUntil(signal, stream): -------d-e-f-g->\n * @param {Stream} signal retain only events in stream at or after the first\n * event in signal\n * @returns {Stream} new stream containing only events that occur after\n * the first event in signal.\n */\nStream.prototype.since = Stream.prototype.skipUntil = function(signal) {\n\treturn timeslice.skipUntil(signal, this);\n};\n\n/**\n * stream:                    -a-b-c-d-e-f-g->\n * timeWindow:                -----s\n * s:                               -----t\n * stream.during(timeWindow): -----c-d-e-|\n * @param {Stream<Stream>} timeWindow a stream whose first event (s) represents\n *  the window start time.  That event (s) is itself a stream whose first event (t)\n *  represents the window end time\n * @returns {Stream} new stream containing only events within the provided timespan\n */\nStream.prototype.during = function(timeWindow) {\n\treturn timeslice.during(timeWindow, this);\n};\n\n//-----------------------------------------------------------------------\n// Delaying\n\nvar delay = require('./lib/combinator/delay').delay;\n\nexports.delay = delay;\n\n/**\n * @param {Number} delayTime milliseconds to delay each item\n * @returns {Stream} new stream containing the same items, but delayed by ms\n */\nStream.prototype.delay = function(delayTime) {\n\treturn delay(delayTime, this);\n};\n\n//-----------------------------------------------------------------------\n// Getting event timestamp\n\nvar timestamp = require('./lib/combinator/timestamp').timestamp;\n\nexports.timestamp = timestamp;\n\n/**\n * Expose event timestamps into the stream. Turns a Stream<X> into\n * Stream<{time:t, value:X}>\n * @returns {Stream<{time:number, value:*}>}\n */\nStream.prototype.timestamp = function() {\n\treturn timestamp(this);\n};\n\n//-----------------------------------------------------------------------\n// Rate limiting\n\nvar limit = require('./lib/combinator/limit');\n\nexports.throttle = limit.throttle;\nexports.debounce = limit.debounce;\n\n/**\n * Limit the rate of events\n * stream:              abcd----abcd----\n * throttle(2, stream): a-c-----a-c-----\n * @param {Number} period time to suppress events\n * @returns {Stream} new stream that skips events for throttle period\n */\nStream.prototype.throttle = function(period) {\n\treturn limit.throttle(period, this);\n};\n\n/**\n * Wait for a burst of events to subside and emit only the last event in the burst\n * stream:              abcd----abcd----\n * debounce(2, stream): -----d-------d--\n * @param {Number} period events occuring more frequently than this\n *  on the provided scheduler will be suppressed\n * @returns {Stream} new debounced stream\n */\nStream.prototype.debounce = function(period) {\n\treturn limit.debounce(period, this);\n};\n\n//-----------------------------------------------------------------------\n// Awaiting Promises\n\nvar promises = require('./lib/combinator/promises');\n\nexports.fromPromise = promises.fromPromise;\nexports.await       = promises.awaitPromises;\n\n/**\n * Await promises, turning a Stream<Promise<X>> into Stream<X>.  Preserves\n * event order, but timeshifts events based on promise resolution time.\n * @returns {Stream<X>} stream containing non-promise values\n */\nStream.prototype.await = function() {\n\treturn promises.awaitPromises(this);\n};\n\n//-----------------------------------------------------------------------\n// Error handling\n\nvar errors = require('./lib/combinator/errors');\n\nexports.recoverWith  = errors.flatMapError;\nexports.flatMapError = errors.flatMapError;\nexports.throwError   = errors.throwError;\n\n/**\n * If this stream encounters an error, recover and continue with items from stream\n * returned by f.\n * stream:                  -a-b-c-X-\n * f(X):                           d-e-f-g-\n * flatMapError(f, stream): -a-b-c-d-e-f-g-\n * @param {function(error:*):Stream} f function which returns a new stream\n * @returns {Stream} new stream which will recover from an error by calling f\n */\nStream.prototype.recoverWith = Stream.prototype.flatMapError = function(f) {\n\treturn errors.flatMapError(f, this);\n};\n\n//-----------------------------------------------------------------------\n// Multicasting\n\nvar multicast = require('@most/multicast').default;\n\nexports.multicast = multicast;\n\n/**\n * Transform the stream into multicast stream.  That means that many subscribers\n * to the stream will not cause multiple invocations of the internal machinery.\n * @returns {Stream} new stream which will multicast events to all observers.\n */\nStream.prototype.multicast = function() {\n\treturn multicast(this);\n};\n"]}
const most = require('most');


const stream = most.just(Array(170000));

const dest = [];

stream.forEach(bigArray =>
  dest.push.apply(dest, bigArray)
);

console.log(dest);

;}, 0)

package.json

{
  "name": "requirebin-sketch",
  "version": "1.0.0",
  "dependencies": {
    "most": "0.19.6"
  }
}

page-body.html

<!-- contents of this file will be placed inside the <body> -->

page-head.html

<!-- contents of this file will be placed inside the <head> -->

requirebin.md

made with requirebin