@thi.ng/rstream 6.0.21 → 7.0.4

package/lib/index.js

@@ -1,1148 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var api = require('@thi.ng/api');
-var transducers = require('@thi.ng/transducers');
-var arrays = require('@thi.ng/arrays');
-var checks = require('@thi.ng/checks');
-var errors = require('@thi.ng/errors');
-var associative = require('@thi.ng/associative');
-var atom = require('@thi.ng/atom');
-
-exports.State = void 0;
-(function (State) {
-    State[State["IDLE"] = 0] = "IDLE";
-    State[State["ACTIVE"] = 1] = "ACTIVE";
-    State[State["DONE"] = 2] = "DONE";
-    State[State["UNSUBSCRIBED"] = 3] = "UNSUBSCRIBED";
-    State[State["ERROR"] = 4] = "ERROR";
-})(exports.State || (exports.State = {}));
-exports.CloseMode = void 0;
-(function (CloseMode) {
-    CloseMode[CloseMode["NEVER"] = 0] = "NEVER";
-    CloseMode[CloseMode["FIRST"] = 1] = "FIRST";
-    CloseMode[CloseMode["LAST"] = 2] = "LAST";
-})(exports.CloseMode || (exports.CloseMode = {}));
-exports.LOGGER = api.NULL_LOGGER;
-const setLogger = (logger) => (exports.LOGGER = logger);
-
-let NEXT_ID = 0;
-const nextID = () => NEXT_ID++;
-const optsWithID = (prefix, opts) => ((!opts || !opts.id ? Object.assign(Object.assign({}, opts), { id: prefix + "-" + nextID() }) : opts));
-
-const subscription = (sub, opts) => new Subscription(sub, opts);
-class Subscription {
-    constructor(wrapped, opts) {
-        this.wrapped = wrapped;
-        this.last = api.SEMAPHORE;
-        this.state = exports.State.IDLE;
-        this.subs = [];
-        opts = optsWithID(`sub`, Object.assign({ closeIn: exports.CloseMode.LAST, closeOut: exports.CloseMode.LAST, cache: true }, opts));
-        this.parent = opts.parent;
-        this.id = opts.id;
-        this.closeIn = opts.closeIn;
-        this.closeOut = opts.closeOut;
-        this.cacheLast = opts.cache;
-        opts.xform && (this.xform = opts.xform(transducers.push()));
-    }
-    deref() {
-        return this.last !== api.SEMAPHORE ? this.last : undefined;
-    }
-    getState() {
-        return this.state;
-    }
-    setState(state) {
-        this.state = state;
-    }
-    subscribe(sub, opts = {}) {
-        this.ensureState();
-        let $sub;
-        if (sub instanceof Subscription && !opts.xform) {
-            sub.ensureState();
-            api.assert(!sub.parent, `sub '${sub.id}' already has a parent`);
-            sub.parent = this;
-            $sub = sub;
-        }
-        else {
-            $sub = new Subscription(sub, Object.assign(Object.assign({}, opts), { parent: this }));
-        }
-        this.subs.push($sub);
-        this.setState(exports.State.ACTIVE);
-        $sub.setState(exports.State.ACTIVE);
-        this.last != api.SEMAPHORE && $sub.next(this.last);
-        return $sub;
-    }
-    transform(...args) {
-        let sub;
-        let opts;
-        if (checks.isPlainObject(arrays.peek(args))) {
-            opts = args.pop();
-            sub = { error: opts.error };
-        }
-        return this.subscribe(sub, optsWithID("xform", args.length > 0
-            ? Object.assign(Object.assign({}, opts), {
-                xform: transducers.comp(...args) }) : opts));
-    }
-    map(fn, opts) {
-        return this.transform(transducers.map(fn), opts || {});
-    }
-    unsubscribe(sub) {
-        return sub ? this.unsubscribeChild(sub) : this.unsubscribeSelf();
-    }
-    unsubscribeSelf() {
-        exports.LOGGER.debug(this.id, "unsub self");
-        this.parent && this.parent.unsubscribe(this);
-        this.state < exports.State.UNSUBSCRIBED && (this.state = exports.State.UNSUBSCRIBED);
-        this.release();
-        return true;
-    }
-    unsubscribeChild(sub) {
-        exports.LOGGER.debug(this.id, "unsub child", sub.id);
-        const idx = this.subs.indexOf(sub);
-        if (idx >= 0) {
-            this.subs.splice(idx, 1);
-            if (this.closeOut === exports.CloseMode.FIRST ||
-                (!this.subs.length && this.closeOut !== exports.CloseMode.NEVER)) {
-                this.unsubscribe();
-            }
-            return true;
-        }
-        return false;
-    }
-    next(x) {
-        if (this.state >= exports.State.DONE)
-            return;
-        this.xform ? this.dispatchXform(x) : this.dispatch(x);
-    }
-    done() {
-        exports.LOGGER.debug(this.id, "entering done()");
-        if (this.state >= exports.State.DONE)
-            return;
-        if (this.xform) {
-            if (!this.dispatchXformDone())
-                return;
-        }
-        this.state = exports.State.DONE;
-        if (this.dispatchTo("done")) {
-            this.state < exports.State.UNSUBSCRIBED && this.unsubscribe();
-        }
-        exports.LOGGER.debug(this.id, "exiting done()");
-    }
-    error(e) {
-        const sub = this.wrapped;
-        const hasErrorHandler = sub && sub.error;
-        hasErrorHandler &&
-            exports.LOGGER.debug(this.id, "attempting wrapped error handler");
-        return (hasErrorHandler && sub.error(e)) || this.unhandledError(e);
-    }
-    unhandledError(e) {
-        (exports.LOGGER !== api.NULL_LOGGER ? exports.LOGGER : console).warn(this.id, "unhandled error:", e);
-        this.unsubscribe();
-        this.state = exports.State.ERROR;
-        return false;
-    }
-    dispatchTo(type, x) {
-        let s = this.wrapped;
-        if (s) {
-            try {
-                s[type] && s[type](x);
-            }
-            catch (e) {
-                if (!this.error(e))
-                    return false;
-            }
-        }
-        const subs = type === "next" ? this.subs : [...this.subs];
-        for (let i = subs.length; --i >= 0;) {
-            s = subs[i];
-            try {
-                s[type] && s[type](x);
-            }
-            catch (e) {
-                if (type === "error" || !s.error || !s.error(e)) {
-                    return this.unhandledError(e);
-                }
-            }
-        }
-        return true;
-    }
-    dispatch(x) {
-        exports.LOGGER.debug(this.id, "dispatch", x);
-        this.cacheLast && (this.last = x);
-        this.dispatchTo("next", x);
-    }
-    dispatchXform(x) {
-        let acc;
-        try {
-            acc = this.xform[2]([], x);
-        }
-        catch (e) {
-            this.error(e);
-            return;
-        }
-        if (this.dispatchXformVals(acc)) {
-            transducers.isReduced(acc) && this.done();
-        }
-    }
-    dispatchXformDone() {
-        let acc;
-        try {
-            acc = this.xform[1]([]);
-        }
-        catch (e) {
-            return this.error(e);
-        }
-        return this.dispatchXformVals(acc);
-    }
-    dispatchXformVals(acc) {
-        const uacc = transducers.unreduced(acc);
-        for (let i = 0, n = uacc.length; i < n && this.state < exports.State.DONE; i++) {
-            this.dispatch(uacc[i]);
-        }
-        return this.state < exports.State.ERROR;
-    }
-    ensureState() {
-        if (this.state >= exports.State.DONE) {
-            errors.illegalState(`operation not allowed in state ${this.state}`);
-        }
-    }
-    release() {
-        this.subs.length = 0;
-        delete this.parent;
-        delete this.xform;
-        delete this.last;
-    }
-}
-
-const isFirstOrLastInput = (mode, num) => mode === exports.CloseMode.FIRST || (mode === exports.CloseMode.LAST && !num);
-
-const sync = (opts) => new StreamSync(opts);
-class StreamSync extends Subscription {
-    constructor(opts) {
-        const psync = transducers.partitionSync(new Set(), {
-            key: (x) => x[0],
-            mergeOnly: opts.mergeOnly === true,
-            reset: opts.reset === true,
-            all: opts.all !== false,
-            backPressure: opts.backPressure || 0,
-        });
-        const mapv = transducers.mapVals((x) => x[1]);
-        super(undefined, optsWithID("streamsync", Object.assign(Object.assign({}, opts), { xform: opts.xform
-                ? transducers.comp(psync, mapv, opts.xform)
-                : transducers.comp(psync, mapv) })));
-        this.sources = new Map();
-        this.realSourceIDs = new Map();
-        this.invRealSourceIDs = new Map();
-        this.idSources = new Map();
-        this.psync = psync;
-        this.clean = !!opts.clean;
-        opts.src && this.addAll(opts.src);
-    }
-    add(src, id) {
-        id || (id = src.id);
-        this.ensureState();
-        this.psync.add(id);
-        this.realSourceIDs.set(id, src.id);
-        this.invRealSourceIDs.set(src.id, id);
-        this.idSources.set(src.id, src);
-        this.sources.set(src, src.subscribe({
-            next: (x) =>
-            x[1] instanceof Subscription
-                ? this.add(x[1])
-                : this.next(x),
-            done: () => this.markDone(src),
-            __owner: this,
-        }, { xform: transducers.labeled(id), id: `in-${id}` }));
-    }
-    addAll(src) {
-        for (let id in src) {
-            this.psync.add(id);
-        }
-        for (let id in src) {
-            this.add(src[id], id);
-        }
-    }
-    remove(src) {
-        const sub = this.sources.get(src);
-        if (sub) {
-            const id = this.invRealSourceIDs.get(src.id);
-            exports.LOGGER.info(`removing src: ${src.id} (${id})`);
-            this.psync.delete(id, this.clean);
-            this.realSourceIDs.delete(id);
-            this.invRealSourceIDs.delete(src.id);
-            this.idSources.delete(src.id);
-            this.sources.delete(src);
-            sub.unsubscribe();
-            return true;
-        }
-        return false;
-    }
-    removeID(id) {
-        const src = this.getSourceForID(id);
-        return src ? this.remove(src) : false;
-    }
-    removeAll(src) {
-        for (let s of src) {
-            this.psync.delete(this.invRealSourceIDs.get(s.id));
-        }
-        let ok = true;
-        for (let s of src) {
-            ok = this.remove(s) && ok;
-        }
-        return ok;
-    }
-    removeAllIDs(ids) {
-        let ok = true;
-        for (let id of ids) {
-            ok = this.removeID(id) && ok;
-        }
-        return ok;
-    }
-    getSourceForID(id) {
-        return this.idSources.get(this.realSourceIDs.get(id));
-    }
-    getSources() {
-        const res = {};
-        for (let [id, src] of this.idSources) {
-            res[this.invRealSourceIDs.get(id)] = src;
-        }
-        return res;
-    }
-    unsubscribe(sub) {
-        if (!sub) {
-            exports.LOGGER.debug(this.id, "unsub sources");
-            for (let s of this.sources.values()) {
-                s.unsubscribe();
-            }
-            this.sources.clear();
-            this.psync.clear();
-            this.realSourceIDs.clear();
-            this.invRealSourceIDs.clear();
-            this.idSources.clear();
-        }
-        return super.unsubscribe(sub);
-    }
-    markDone(src) {
-        this.remove(src);
-        isFirstOrLastInput(this.closeIn, this.sources.size) && this.done();
-    }
-}
-
-const inlineWorker = (src) => makeWorker(new Blob([src], { type: "text/javascript" }));
-const makeWorker = (worker) => worker instanceof Worker
-    ? worker
-    : new Worker(worker instanceof Blob ? URL.createObjectURL(worker) : worker);
-
-const tunnel = (opts) => new Tunnel(opts);
-class Tunnel extends Subscription {
-    constructor(opts) {
-        super(undefined, { id: opts.id || `tunnel-${nextID()}` });
-        this.src = opts.src;
-        this.workers = new Array(opts.maxWorkers || 1);
-        this.transferables = opts.transferables;
-        this.terminate = opts.terminate || 1000;
-        this.interrupt = opts.interrupt || false;
-        this.index = 0;
-    }
-    next(x) {
-        if (this.state < exports.State.DONE) {
-            let tx;
-            if (this.transferables) {
-                tx = this.transferables(x);
-            }
-            let worker = this.workers[this.index];
-            if (this.interrupt && worker) {
-                worker.terminate();
-                worker = null;
-            }
-            if (!worker) {
-                this.workers[this.index++] = worker = makeWorker(this.src);
-                this.index %= this.workers.length;
-                worker.addEventListener("message", (e) => this.dispatch(e.data));
-                worker.addEventListener("error", (e) => this.error(e));
-            }
-            worker.postMessage(x, tx || []);
-        }
-    }
-    done() {
-        super.done();
-        if (this.terminate > 0) {
-            setTimeout(() => {
-                exports.LOGGER.info("terminating workers...");
-                this.workers.forEach((worker) => worker && worker.terminate());
-                delete this.workers;
-            }, this.terminate);
-        }
-    }
-}
-
-const forkJoin = (opts) => {
-    const numWorkers = opts.numWorkers || navigator.hardwareConcurrency || 4;
-    const workerIDs = transducers.range(numWorkers);
-    return sync({
-        src: transducers.transduce(transducers.map((id) => [
-            String(id),
-            opts.src
-                .transform(transducers.map((x) => opts.fork(id, numWorkers, x)))
-                .subscribe(tunnel({
-                src: opts.worker,
-                transferables: opts.transferables,
-                interrupt: opts.interrupt === true,
-                terminate: opts.terminate,
-                id: String(id),
-            })),
-        ]), transducers.assocObj(), workerIDs),
-        xform: transducers.comp(
-        transducers.map((results) => [...transducers.map((id) => results[id], workerIDs)]),
-        transducers.map(opts.join)),
-        reset: true,
-        backPressure: opts.backPressure,
-    });
-};
-const forkBuffer = (minChunkSize = 1) => (id, numWorkers, buf) => {
-    const chunkSize = Math.max(minChunkSize, (buf.length / numWorkers) | 0);
-    return id < numWorkers - 1
-        ? buf.slice(id * chunkSize, (id + 1) * chunkSize)
-        : buf.slice(id * chunkSize);
-};
-const joinBuffer = (fn) => fn
-    ? (parts) => [...transducers.mapcat(fn, parts)]
-    : (parts) => Array.prototype.concat.apply([], parts);
-
-const metaStream = (factory, opts) => new MetaStream(factory, opts);
-class MetaStream extends Subscription {
-    constructor(factory, opts = {}) {
-        super(undefined, optsWithID("metastram", opts));
-        this.factory = factory;
-        this.emitLast = opts.emitLast === true;
-        this.doneRequested = false;
-    }
-    next(x) {
-        if (this.state < exports.State.DONE) {
-            if (this.stream) {
-                this.stream.unsubscribe(this.sub);
-            }
-            let stream = this.factory(x);
-            if (stream) {
-                this.stream = stream;
-                this.sub = this.stream.subscribe({
-                    next: (x) => {
-                        stream === this.stream && super.dispatch(x);
-                        this.doneRequested && this.done();
-                    },
-                    done: () => {
-                        this.stream.unsubscribe(this.sub);
-                        if (stream === this.stream) {
-                            this.stream = undefined;
-                            this.sub = undefined;
-                        }
-                    },
-                    error: (e) => super.error(e),
-                    __owner: this,
-                });
-            }
-        }
-    }
-    done() {
-        if (this.emitLast && !this.doneRequested) {
-            this.doneRequested = true;
-        }
-        else {
-            if (this.stream) {
-                this.detach(true);
-            }
-            this.closeIn !== exports.CloseMode.NEVER && super.done();
-        }
-    }
-    unsubscribe(sub) {
-        if (this.stream && (!sub || this.subs.length === 1)) {
-            this.detach(!sub);
-        }
-        return super.unsubscribe(sub);
-    }
-    detach(force) {
-        if (force || this.closeOut !== exports.CloseMode.NEVER) {
-            api.assert(!!this.stream, "input stream already removed");
-            this.stream.unsubscribe(this.sub);
-            delete this.stream;
-            delete this.sub;
-        }
-    }
-}
-
-const pubsub = (opts) => new PubSub(opts);
-class PubSub extends Subscription {
-    constructor(opts) {
-        super(undefined, optsWithID("pubsub", {
-            xform: opts.xform,
-        }));
-        this.topicfn = opts.topic;
-        this.topics = new associative.EquivMap(undefined, {
-            equiv: opts.equiv,
-        });
-    }
-    subscribe() {
-        return errors.unsupported(`use subscribeTopic() instead`);
-    }
-    transform() {
-        return errors.unsupported(`use subscribeTopic() instead`);
-    }
-    subscribeTopic(topicID, sub, opts) {
-        let t = this.topics.get(topicID);
-        !t &&
-            this.topics.set(topicID, (t = subscription(undefined, optsWithID("topic", {
-                closeOut: exports.CloseMode.NEVER,
-            }))));
-        return t.subscribe(sub, opts);
-    }
-    transformTopic(topicID, xform, opts = {}) {
-        return this.subscribeTopic(topicID, { error: opts.error }, Object.assign(Object.assign({}, opts), { xform }));
-    }
-    unsubscribeTopic(topicID, sub) {
-        const t = this.topics.get(topicID);
-        return t ? t.unsubscribe(sub) : false;
-    }
-    unsubscribe(sub) {
-        if (!sub) {
-            for (let t of this.topics.values()) {
-                t.unsubscribe();
-            }
-            this.topics.clear();
-            return super.unsubscribe();
-        }
-        return errors.unsupported();
-    }
-    done() {
-        for (let t of this.topics.values()) {
-            t.done();
-        }
-        super.done();
-    }
-    dispatch(x) {
-        exports.LOGGER.debug(this.id, "dispatch", x);
-        this.cacheLast && (this.last = x);
-        const t = this.topicfn(x);
-        if (t !== undefined) {
-            const sub = this.topics.get(t);
-            if (sub) {
-                try {
-                    sub.next && sub.next(x);
-                }
-                catch (e) {
-                    if (!sub.error || !sub.error(e)) {
-                        return this.unhandledError(e);
-                    }
-                }
-            }
-        }
-    }
-}
-
-function stream(src, opts) {
-    return new Stream(src, opts);
-}
-const reactive = (val, opts) => {
-    const res = new Stream(opts);
-    res.next(val);
-    return res;
-};
-class Stream extends Subscription {
-    constructor(src, opts) {
-        const [_src, _opts] = checks.isFunction(src)
-            ? [src, opts || {}]
-            : [undefined, src || {}];
-        super(_opts.error ? { error: _opts.error } : undefined, optsWithID("stream", _opts));
-        this.src = _src;
-        this._inited = false;
-    }
-    subscribe(sub, opts = {}) {
-        const $sub = super.subscribe(sub, opts);
-        if (!this._inited) {
-            if (this.src) {
-                try {
-                    this._cancel = this.src(this) || (() => void 0);
-                }
-                catch (e) {
-                    let s = this.wrapped;
-                    if (!s || !s.error || !s.error(e)) {
-                        this.unhandledError(e);
-                    }
-                }
-            }
-            this._inited = true;
-        }
-        return $sub;
-    }
-    unsubscribe(sub) {
-        const res = super.unsubscribe(sub);
-        if (res &&
-            (!sub ||
-                ((!this.subs || !this.subs.length) &&
-                    this.closeOut !== exports.CloseMode.NEVER))) {
-            this.cancel();
-        }
-        return res;
-    }
-    done() {
-        this.cancel();
-        super.done();
-        delete this.src;
-        delete this._cancel;
-    }
-    error(e) {
-        if (super.error(e))
-            return true;
-        this.cancel();
-        return false;
-    }
-    cancel() {
-        if (this._cancel) {
-            exports.LOGGER.debug(this.id, "cancel");
-            const f = this._cancel;
-            delete this._cancel;
-            f();
-        }
-    }
-}
-
-const merge = (opts) => new StreamMerge(opts);
-class StreamMerge extends Subscription {
-    constructor(opts) {
-        opts = opts || {};
-        super(undefined, optsWithID("streammerge", opts));
-        this.sources = new Map();
-        opts.src && this.addAll(opts.src);
-    }
-    add(src) {
-        this.ensureState();
-        this.sources.set(src, src.subscribe({
-            next: (x) => x instanceof Subscription ? this.add(x) : this.next(x),
-            done: () => this.markDone(src),
-            __owner: this,
-        }, { id: `in-${src.id}` }));
-    }
-    addAll(src) {
-        for (let s of src) {
-            this.add(s);
-        }
-    }
-    remove(src) {
-        const sub = this.sources.get(src);
-        if (sub) {
-            this.sources.delete(src);
-            sub.unsubscribe();
-            return true;
-        }
-        return false;
-    }
-    removeID(id) {
-        for (let s of this.sources) {
-            if (s[0].id === id) {
-                return this.remove(s[0]);
-            }
-        }
-        return false;
-    }
-    removeAll(src) {
-        let ok = true;
-        for (let s of src) {
-            ok = this.remove(s) && ok;
-        }
-        return ok;
-    }
-    removeAllIDs(ids) {
-        let ok = true;
-        for (let id of ids) {
-            ok = this.removeID(id) && ok;
-        }
-        return ok;
-    }
-    unsubscribe(sub) {
-        if (!sub) {
-            for (let s of this.sources.values()) {
-                s.unsubscribe();
-            }
-            this.state = exports.State.DONE;
-            this.sources.clear();
-        }
-        return super.unsubscribe(sub);
-    }
-    markDone(src) {
-        this.remove(src);
-        isFirstOrLastInput(this.closeIn, this.sources.size) && this.done();
-    }
-}
-
-const fromIterable = (src, opts = {}) => new Stream((stream) => {
-    const iter = src[Symbol.iterator]();
-    const id = setInterval(() => {
-        let val;
-        if ((val = iter.next()).done) {
-            clearInterval(id);
-            stream.closeIn !== exports.CloseMode.NEVER && stream.done();
-        }
-        else {
-            stream.next(val.value);
-        }
-    }, opts.delay || 0);
-    return () => clearInterval(id);
-}, optsWithID("iterable", opts));
-const fromIterableSync = (src, opts) => new Stream((stream) => {
-    for (let s of src) {
-        stream.next(s);
-    }
-    stream.closeIn !== exports.CloseMode.NEVER && stream.done();
-}, optsWithID("iterable-sync", opts));
-
-function trigger(x = true, opts) {
-    return fromIterableSync([x], optsWithID("trigger", opts));
-}
-
-const fromInterval = (delay, opts) => {
-    opts = optsWithID("interval", Object.assign({ num: Infinity }, opts));
-    return new Stream((stream) => {
-        let i = 0;
-        let count = opts.num;
-        stream.next(i++);
-        let id = setInterval(() => {
-            stream.next(i++);
-            if (--count <= 0) {
-                clearInterval(id);
-                stream.closeIn !== exports.CloseMode.NEVER && stream.done();
-            }
-        }, delay);
-        return () => clearInterval(id);
-    }, opts);
-};
-
-const fromRAF = (opts) => checks.isNode()
-    ? fromInterval(16, opts)
-    : new Stream((stream) => {
-        let i = 0;
-        let isActive = true;
-        const loop = () => {
-            isActive && stream.next(i++);
-            isActive && (id = requestAnimationFrame(loop));
-        };
-        let id = requestAnimationFrame(loop);
-        return () => {
-            isActive = false;
-            cancelAnimationFrame(id);
-        };
-    }, optsWithID("raf", opts));
-
-const tween = (src, initial, mix, stop, clock) => sync({
-    src: {
-        src,
-        _: clock == null
-            ? fromRAF()
-            : checks.isNumber(clock)
-                ? fromInterval(clock)
-                : clock,
-    },
-    closeIn: exports.CloseMode.FIRST,
-}).transform(transducers.scan(transducers.reducer(() => initial, (acc, { src }) => mix(acc, src))), transducers.dedupe(stop || (() => false)));
-const tweenNumber = (src, init = 0, speed = 0.05, eps = 1e-3, clock) => tween(src, init, (a, b) => a + (b - a) * speed, (a, b) => Math.abs(a - b) < eps, clock);
-
-const fromAtom = (atom, opts) => {
-    opts = optsWithID("atom", Object.assign({ emitFirst: true, changed: (a, b) => a !== b }, opts));
-    return new Stream((stream) => {
-        atom.addWatch(stream.id, (_, prev, curr) => {
-            if (opts.changed(prev, curr)) {
-                stream.next(curr);
-            }
-        });
-        opts.emitFirst && stream.next(atom.deref());
-        return () => atom.removeWatch(stream.id);
-    }, opts);
-};
-
-const fromEvent = (src, name, listenerOpts = false, streamOpts) => new Stream((stream) => {
-    let listener = (e) => stream.next(e);
-    src.addEventListener(name, listener, listenerOpts);
-    return () => src.removeEventListener(name, listener, listenerOpts);
-}, optsWithID(`event-${name}`, streamOpts));
-const fromDOMEvent = (src, name, listenerOpts = false, streamOpts) => fromEvent(src, name, listenerOpts, streamOpts);
-
-const fromObject = (src, opts = {}) => {
-    const id = opts.id || `obj${nextID()}`;
-    const keys = opts.keys || Object.keys(src);
-    const _opts = opts.dedupe !== false
-        ? Object.assign({ xform: transducers.dedupe(opts.equiv || ((a, b) => a === b)) }, opts) : opts;
-    const streams = {};
-    for (let k of keys) {
-        streams[k] = subscription(undefined, Object.assign(Object.assign({}, _opts), { id: `${id}-${k}` }));
-    }
-    const res = {
-        streams,
-        next(state) {
-            for (let k of keys) {
-                const val = state[k];
-                streams[k].next(opts.defaults && val === undefined ? opts.defaults[k] : val);
-            }
-        },
-        done() {
-            for (let k of keys) {
-                streams[k].done();
-            }
-        },
-    };
-    opts.initial !== false && res.next(src);
-    return res;
-};
-
-const fromPromise = (src, opts) => {
-    let canceled = false;
-    let isError = false;
-    let err = {};
-    src.catch((e) => {
-        err = e;
-        isError = true;
-    });
-    return new Stream((stream) => {
-        src.then((x) => {
-            if (!canceled && stream.getState() < exports.State.DONE) {
-                if (isError) {
-                    stream.error(err);
-                    err = null;
-                }
-                else {
-                    stream.next(x);
-                    stream.closeIn !== exports.CloseMode.NEVER && stream.done();
-                }
-            }
-        }, (e) => stream.error(e));
-        return () => {
-            canceled = true;
-        };
-    }, optsWithID("promise", opts));
-};
-
-const fromPromises = (promises, opts) => fromPromise(Promise.all(promises), optsWithID("promises", opts)).transform(transducers.mapcat((x) => x));
-
-const fromViewUnsafe = (atom, opts) => fromView(atom, opts);
-function fromView(atom$1, opts) {
-    opts = optsWithID("view", opts);
-    return new Stream((stream) => {
-        let isActive = true;
-        const tx = opts.tx;
-        const view = new atom.View(atom$1, opts.path, tx
-            ? (x) => isActive && ((x = tx(x)), stream.next(x), x)
-            : (x) => isActive && (stream.next(x), x), false, opts.equiv);
-        return () => {
-            isActive = false;
-            view.release();
-        };
-    });
-}
-
-const fromWorker = (worker, opts) => {
-    const _worker = makeWorker(worker);
-    opts = optsWithID("worker", opts);
-    return new Stream((stream) => {
-        const msgListener = (e) => {
-            stream.next(e.data);
-        };
-        const errListener = (e) => {
-            stream.error(e.data);
-        };
-        _worker.addEventListener("message", msgListener);
-        _worker.addEventListener("error", errListener);
-        return () => {
-            _worker.removeEventListener("message", msgListener);
-            _worker.removeEventListener("error", errListener);
-            if (opts.terminate !== false) {
-                exports.LOGGER.info("terminating worker", _worker);
-                _worker.terminate();
-            }
-        };
-    }, opts);
-};
-
-class ASidechain extends Subscription {
-    constructor(opts) {
-        super(undefined, opts);
-    }
-    unsubscribe(sub) {
-        const res = super.unsubscribe(sub);
-        if (!sub || !this.subs.length) {
-            this.sideSub.unsubscribe();
-        }
-        return res;
-    }
-    done() {
-        this.sideSub.unsubscribe();
-        super.done();
-    }
-}
-
-const bisect = (pred, truthy, falsy) => {
-    const sub = new PubSub({ topic: pred, id: `bisect-${nextID()}` });
-    truthy && sub.subscribeTopic(true, truthy);
-    falsy && sub.subscribeTopic(false, falsy);
-    return sub;
-};
-
-const debounce = (delay, opts) => metaStream((x) => fromIterable([x], { delay }), optsWithID("debounce", Object.assign({ emitLast: true }, opts)));
-
-const postWorker = (worker, transfer = false, terminate = 0) => {
-    const _worker = makeWorker(worker);
-    return {
-        next(x) {
-            if (x instanceof Promise) {
-                x.then((y) => this.next(y));
-                return;
-            }
-            let tx;
-            if (transfer) {
-                const ta = checks.isTypedArray(x);
-                if (ta || checks.isTransferable(x)) {
-                    tx = [ta ? x.buffer : x];
-                }
-            }
-            _worker.postMessage(x, tx || []);
-        },
-        done() {
-            if (terminate > 0) {
-                setTimeout(() => {
-                    exports.LOGGER.info("terminating worker...");
-                    _worker.terminate();
-                }, terminate);
-            }
-        },
-    };
-};
-
-const resolve = (opts) => new Resolver(opts);
-class Resolver extends Subscription {
-    constructor(opts = {}) {
-        super(undefined, optsWithID("resolve"));
-        this.outstanding = 0;
-        this.fail = opts.fail;
-    }
-    next(x) {
-        this.outstanding++;
-        x.then((y) => {
-            if (this.state < exports.State.DONE) {
-                this.dispatch(y);
-                if (--this.outstanding === 0) {
-                    this.done();
-                }
-            }
-            else {
-                exports.LOGGER.warn(`resolved value in state ${this.state} (${x})`);
-            }
-        }, (e) => {
-            if (this.fail) {
-                this.fail(e);
-            }
-            else {
-                this.error(e);
-            }
-        });
-    }
-    done() {
-        if (this.parent &&
-            this.parent.getState() === exports.State.DONE &&
-            this.outstanding === 0) {
-            super.done();
-        }
-    }
-}
-
-const sidechainPartition = (side, opts) => new SidechainPartition(side, opts);
-const sidechainPartitionRAF = (src) => src
-    .subscribe(sidechainPartition(fromRAF()))
-    .transform(transducers.map(arrays.peek));
-class SidechainPartition extends ASidechain {
-    constructor(side, opts) {
-        opts = optsWithID("sidepart", opts);
-        super(opts);
-        this.buf = [];
-        const pred = opts.pred || (() => true);
-        const $this = this;
-        this.sideSub = side.subscribe({
-            next(x) {
-                if ($this.buf.length && pred(x)) {
-                    $this.dispatch($this.buf);
-                    $this.buf = [];
-                }
-            },
-            done() {
-                if ($this.buf.length) {
-                    $this.dispatch($this.buf);
-                }
-                $this.done();
-                delete $this.buf;
-            },
-        });
-    }
-    next(x) {
-        if (this.state < exports.State.DONE) {
-            this.buf.push(x);
-        }
-    }
-}
-
-const sidechainToggle = (side, opts) => new SidechainToggle(side, opts);
-class SidechainToggle extends ASidechain {
-    constructor(side, opts) {
-        opts = optsWithID("sidetoggle", opts);
-        super(opts);
-        this.isActive = !!opts.initial;
-        const pred = opts.pred || (() => true);
-        const $this = this;
-        this.sideSub = side.subscribe({
-            next(x) {
-                if (pred(x)) {
-                    $this.isActive = !$this.isActive;
-                }
-            },
-            done() {
-                $this.done();
-            },
-        });
-    }
-    next(x) {
-        if (this.isActive && this.state < exports.State.DONE) {
-            super.next(x);
-        }
-    }
-}
-
-const timeout = (timeoutMs, opts) => new Timeout(timeoutMs, opts);
-class Timeout extends Subscription {
-    constructor(timeoutMs, opts) {
-        opts = optsWithID("timeout", opts);
-        super(undefined, opts);
-        this.timeoutMs = timeoutMs;
-        this.errorObj = opts.error;
-        this.resetTimeout = opts.reset === true;
-        this.reset();
-    }
-    next(x) {
-        if (this.resetTimeout) {
-            clearTimeout(this.timeoutId);
-            this.reset();
-        }
-        super.next(x);
-    }
-    reset() {
-        this.timeoutId = setTimeout(() => {
-            if (this.state < exports.State.DONE) {
-                this.dispatchTo("error", this.errorObj ||
-                    new Error(`Timeout '${this.id}' after ${this.timeoutMs} ms`));
-            }
-        }, this.timeoutMs);
-    }
-    release() {
-        clearTimeout(this.timeoutId);
-        super.release();
-    }
-}
-
-const trace = (prefix) => ({
-    next(x) {
-        prefix ? console.log(prefix, x) : console.log(x);
-    },
-    done() {
-        prefix ? console.log(prefix, "done") : console.log("done");
-    },
-    error(e) {
-        prefix ? console.log(prefix, "error", e) : console.log("error", e);
-        return false;
-    },
-});
-
-const transduce = (src, xform, rfn, init) => {
-    let acc = init !== undefined ? init : rfn[0]();
-    let sub;
-    return new Promise((resolve, reject) => {
-        sub = src.subscribe({
-            next(x) {
-                let _acc;
-                try {
-                    _acc = rfn[2](acc, x);
-                }
-                catch (e) {
-                    reject(e);
-                    return;
-                }
-                if (transducers.isReduced(_acc)) {
-                    resolve(_acc.deref());
-                }
-                else {
-                    acc = _acc;
-                }
-            },
-            done() {
-                resolve(acc);
-            },
-            error(e) {
-                reject(e);
-                return false;
-            },
-        }, { xform });
-    }).then((fulfilled) => {
-        sub.unsubscribe();
-        return fulfilled;
-    }, (rejected) => {
-        sub.unsubscribe();
-        throw rejected;
-    });
-};
-
-exports.ASidechain = ASidechain;
-exports.MetaStream = MetaStream;
-exports.PubSub = PubSub;
-exports.Resolver = Resolver;
-exports.SidechainPartition = SidechainPartition;
-exports.SidechainToggle = SidechainToggle;
-exports.Stream = Stream;
-exports.StreamMerge = StreamMerge;
-exports.StreamSync = StreamSync;
-exports.Subscription = Subscription;
-exports.Tunnel = Tunnel;
-exports.bisect = bisect;
-exports.debounce = debounce;
-exports.forkBuffer = forkBuffer;
-exports.forkJoin = forkJoin;
-exports.fromAtom = fromAtom;
-exports.fromDOMEvent = fromDOMEvent;
-exports.fromEvent = fromEvent;
-exports.fromInterval = fromInterval;
-exports.fromIterable = fromIterable;
-exports.fromIterableSync = fromIterableSync;
-exports.fromObject = fromObject;
-exports.fromPromise = fromPromise;
-exports.fromPromises = fromPromises;
-exports.fromRAF = fromRAF;
-exports.fromView = fromView;
-exports.fromViewUnsafe = fromViewUnsafe;
-exports.fromWorker = fromWorker;
-exports.inlineWorker = inlineWorker;
-exports.joinBuffer = joinBuffer;
-exports.makeWorker = makeWorker;
-exports.merge = merge;
-exports.metaStream = metaStream;
-exports.nextID = nextID;
-exports.optsWithID = optsWithID;
-exports.postWorker = postWorker;
-exports.pubsub = pubsub;
-exports.reactive = reactive;
-exports.resolve = resolve;
-exports.setLogger = setLogger;
-exports.sidechainPartition = sidechainPartition;
-exports.sidechainPartitionRAF = sidechainPartitionRAF;
-exports.sidechainToggle = sidechainToggle;
-exports.stream = stream;
-exports.subscription = subscription;
-exports.sync = sync;
-exports.timeout = timeout;
-exports.trace = trace;
-exports.transduce = transduce;
-exports.trigger = trigger;
-exports.tunnel = tunnel;
-exports.tween = tween;
-exports.tweenNumber = tweenNumber;