uneventful 0.0.1

package/dist/mod.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.cjs","sources":["../src/defer.ts","../src/results.ts","../src/ambient.ts","../src/internals.ts","../src/chains.ts","../src/tracking.ts","../src/async.ts","../src/scheduling.ts","../src/streams.ts","../src/utils.ts","../src/cells.ts","../src/signals.ts","../src/jobutils.ts","../src/sources.ts","../src/sinks.ts","../src/operators.ts"],"sourcesContent":["/**\n * Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()\n *\n * @category Scheduling\n */\nexport let defer: (cb: () => any) => void =\n    typeof queueMicrotask === \"function\" ?\n        queueMicrotask :\n        (p => (cb: () => any) => p.then(cb))(Promise.resolve());\n\n/**\n * @internal For testing use only!\n *\n */\nexport function setDefer(fn: typeof defer) {\n    defer = fn;\n}","import { Job, Request } from \"./types.ts\";\n\n/**\n * Resolve a {@link Request} with a value.\n *\n * (For a curried version, see {@link resolver}.)\n *\n * @category Requests and Results\n */\nexport function resolve<T>(request: Request<T>, val: T) { request(\"next\", val); }\n\n/**\n * Reject a {@link Request} with a reason.\n *\n * (For a curried version, see {@link rejecter}.)\n *\n * @category Requests and Results\n */\nexport function reject(request: Request<any>, reason: any) { request(\"throw\", undefined, reason); }\n\n/**\n * Create a callback that will resolve the given {@link Request} with a value.\n *\n * @category Requests and Results\n */\nexport function resolver<T>(request: Request<T>): (val: T) => void { return request.bind(null, \"next\"); }\n\n/**\n * Create a callback that will reject the given {@link Request} with a reason.\n *\n * @category Requests and Results\n */\nexport function rejecter(request: Request<any>): (err: any) => void { return request.bind(null, \"throw\", undefined); }\n\n\n/**\n * A function that does nothing and returns void.\n *\n * @category Stream Consumers\n */\nexport function noop() {}\n\n/**\n * A {@link JobResult} that indicates the job was ended via a return() value.\n *\n * @category Types and Interfaces\n */\nexport type ValueResult<T> = {op: \"next\",    val: T,         err: undefined};\n\n/**\n * A {@link JobResult} that indicates the job was ended via a throw() or other\n * error.\n *\n * @category Types and Interfaces\n */\nexport type ErrorResult    = UnhandledError | HandledError;\n\n/**\n * An {@link ErrorResult} that hasn't yet been \"handled\" (by being passed to an\n * error-specific handler, converted to a promise, given to {@link markHandled},\n * etc.)\n *\n * @category Types and Interfaces\n */\nexport type UnhandledError = {op: \"throw\",   val: undefined, err: any};\n\n/**\n * An {@link ErrorResult} that has been marked \"handled\" (by being passed to an\n * error-specific handler, converted to a promise, given to {@link markHandled},\n * etc.)\n *\n * @category Types and Interfaces\n */\nexport type HandledError   = {op: \"throw\",   val: null,      err: any};\n\n/**\n * A {@link JobResult} that indicates the job was canceled by its creator (via\n * end() or restart()).\n *\n * @category Types and Interfaces\n */\nexport type CancelResult   = {op: \"cancel\",  val: undefined, err: undefined};\n\n/**\n * A result passed to a job's cleanup callbacks, or supplied by its\n * .{@link Job.result result}() method.\n *\n * You can inspect a JobResult using functions like {@link isCancel}(),\n * {@link isError}(), and {@link isValue}().  {@link getResult}() can be used to\n * unwrap the value or throw the error.\n *\n * @category Types and Interfaces\n */\nexport type JobResult<T> = ValueResult<T> | ErrorResult | CancelResult ;\n\nfunction mkResult<T>(op: \"next\", val?: T): ValueResult<T>;\nfunction mkResult(op: \"throw\", val: undefined|null, err: any): ErrorResult;\nfunction mkResult(op: \"cancel\"): CancelResult;\nfunction mkResult<T>(op: string, val?: T, err?: any): JobResult<T> {\n    return {op, val, err} as JobResult<T>\n}\n\n/**\n * The {@link JobResult} used to indicate a canceled job.\n *\n * @category Requests and Results\n */\nexport const CancelResult = Object.freeze(mkResult(\"cancel\"));\n\n/**\n * Create a {@link ValueResult} from a value\n *\n * @category Requests and Results\n */\nexport function ValueResult<T>(val: T): ValueResult<T> { return mkResult(\"next\", val); }\n\n/**\n * Create an {@link ErrorResult} from an error\n *\n * @category Requests and Results\n */\nexport function ErrorResult(err: any): UnhandledError { return mkResult(\"throw\", undefined, err); }\n\n/**\n * Returns true if the given result is a {@link CancelResult}.\n *\n * @category Requests and Results\n */\nexport function isCancel(res: JobResult<any> | undefined): res is CancelResult {\n    return res === CancelResult;\n}\n\n/**\n * Returns true if the given result is a {@link ValueResult}.\n *\n * @category Requests and Results\n */\nexport function isValue<T>(res: JobResult<T> | undefined): res is ValueResult<T> {\n    return res ? res.op === \"next\" : false;\n}\n\n/**\n * Returns true if the given result is a {@link ErrorResult}.\n *\n * @category Requests and Results\n */\nexport function isError(res: JobResult<any> | undefined): res is ErrorResult {\n    return res ? res.op === \"throw\" : false;\n}\n\n/**\n * Returns true if the given result is an {@link UnhandledError}.\n *\n * @category Requests and Results\n */\nexport function isUnhandled(res: JobResult<any> | undefined): res is UnhandledError {\n    return isError(res) && res.val === undefined;\n}\n\n/**\n * Returns true if the given result is a {@link HandledError} (an\n * {@link ErrorResult} that has been touched by {@link markHandled}).\n *\n * @category Requests and Results\n */\nexport function isHandled(res: JobResult<any> | undefined): res is HandledError {\n    return isError(res) && res.val === null;\n}\n\n/**\n * Return the error of an {@link ErrorResult} and mark it as handled. The\n * {@link ErrorResult} is mutated in-place to become a {@link HandledError}.\n *\n * @category Requests and Results\n */\nexport function markHandled(res: ErrorResult): any {\n    res.val = null;\n    return res.err;\n}\n\n/**\n * Get the return value from a {@link JobResult}, throwing an appropriate error\n * if the result isn't a {@link ValueResult}.\n *\n * @param res The job result you want to unwrap.  Must not be undefined!\n *\n * @returns The value if the result is a {@link ValueResult}, or a thrown error\n * if it's an {@link ErrorResult}.  A {@link CancelError} is thrown if the job\n * was canceled, or the error in the result is thrown.\n *\n * If the result is an error, it is marked as handled.\n *\n * @category Jobs\n */\nexport function getResult<T>(res: JobResult<T>): T {\n    if (isValue(res)) return res.val;\n    res.op; // throw if not defined\n    fulfillPromise(noop, e => { throw e; }, res);\n}\n\n/**\n * Fulfill a Promise from a {@link JobResult}\n *\n * If the result is a {@link CancelResult}, the promise is rejected with a\n * {@link CancelError}.  Otherwise it is resolved or rejected according to the\n * state of the result.\n *\n * @param resolve A value-taking function (first arg to `new Promise` callback)\n *\n * @param reject An error-taking function (second arg to `new Promise` callback)\n *\n * @param res The job result you want to settle the promise with.  An error will\n * be thrown if it's undefined.\n *\n * If the result is an error, it is marked as handled.\n *\n * @category Requests and Results\n */\nexport function fulfillPromise<T>(resolve: (v: T) => void, reject: (e: any) => void, res: JobResult<T>) {\n    if (isError(res)) reject(markHandled(res));\n    else if (isCancel(res)) reject(new CancelError(\"Job canceled\"));\n    else resolve(res.val);\n}\n\n/**\n * Propagate a {@link JobResult} to another job\n *\n * If the result is a {@link CancelResult}, the job will throw with a\n * {@link CancelError}.  Otherwise it is resolved or rejected according to the\n * state of the result.\n *\n * @param job The job to terminate.  If it's already ended, nothing changes: the\n * result is not propagated and the error (if any) is not marked as handled.\n *\n * @param res The job result you want to settle the job with.  An error will be\n * thrown if it's undefined.  If the result is an error, it is marked as\n * handled.\n *\n * @category Requests and Results\n */\nexport function propagateResult<T>(job: Job<T>, res: JobResult<T>) {\n    if (!job.result()) fulfillPromise(job.return.bind(job), job.throw.bind(job), res);\n}\n\n/**\n * Error thrown when waiting for a result from a job that is canceled.\n *\n * If you `await`, `yield *`, `.then()`, `.catch()`, {@link getResult}() or\n * otherwise wait on the result of a job that is canceled, this is the type\n * of error you'll get.\n *\n * @category Errors\n */\nexport class CancelError extends Error {}\n","/**\n * Ambient execution context (for job, resource, and dependency tracking)\n *\n * @internal\n * @module\n */\n\nimport type { Job } from \"./types.ts\";\nimport type { Cell } from \"./cells.ts\";\n\ntype Opt<X> = X | undefined | null;\n\nexport type Context = {\n    job: Opt<Job<unknown>>\n    cell: Opt<Cell>\n}\n\n/** The current context */\nexport var current: Context = makeCtx();\n\n\n/** Set a new current context, returning the old one */\nexport function swapCtx(future: Context): Context {\n    const now = current;\n    current = future;\n    return now\n}\n\nvar freelist = [] as Context[];\n\n/** Get a fresh context object (either by creation or recycling) */\nexport function makeCtx(\n    job?:  Context[\"job\"],\n    cell?: Context[\"cell\"],\n): Context {\n    if (freelist && freelist.length) {\n        const s = freelist.pop()!;\n        s.job = job;\n        s.cell = cell;\n        return s;\n    }\n    return {job, cell};\n}\n\n/** Put a no-longer-needed context object on the recycling heap */\nexport function freeCtx(s: Context) {\n    s.job = s.cell = null;\n    freelist.push(s);\n}\n\n","/**\n * Provide access to certain internals (for testing use only)\n *\n * @module\n */\n\nimport { Job } from \"./types.ts\";\n\nexport const\n    /** Jobs' asyncCatch handlers: in a map because few jobs will have them */\n    catchers = new WeakMap<Job, (this: Job, err: any) => unknown>(),\n\n    /** Default error handler for the `detached` job */\n    defaultCatch = (e: any) => { Promise.reject(e); }\n;\n","import { DisposeFn } from \"./types.ts\";\n\n/**\n * A counted, double-ended queue with the ability to undo insertions (even out\n * of order).\n *\n * @category Chains\n */\nexport type Chain<T, U=any> = Node<T, number, U>;\n\n/**\n * Create a new Chain\n *\n * @category Chains\n */\nexport function chain<T, U=DisposeFn>(): Chain<T, U> { return link<number, U>(0, undefined, undefined); }\n\n/**\n * Recycle a chain entirely - only safe if no references to it remain anywhere!\n */\nexport function recycle(c: Chain<any>) {\n    while (c.v) unlink(c, c.n);\n    c.u = undefined;\n    unlink(c, c);\n}\n\n/**\n * Unshift a value onto the front of the chain\n *\n * @category Chains\n */\nexport function unshift<T>(c: Chain<T>, v: T)   { ++c.v; link(v, c.n, c); }\n\n/**\n * Unshift a value onto the front of the chain, returning an undo callback.  The\n * callback can be invoked to remove the value from the chain at any time, even\n * after other values have been added or removed.  There is no effect if the\n * callback is run more than once, or if the value has already been removed.\n *\n * @category Chains\n */\nexport function unshiftCB<T>(c: Chain<T>, v: T) { ++c.v; return unlinker(c, link(v, c.n, c)); }\n\n/**\n * Push a value onto the end of the chain\n *\n * @category Chains\n */\nexport function push<T>(c: Chain<T>, v: T) { ++c.v; link(v, c, c.p); }\n\n/**\n * Push a value onto the end of the chain, returning an undo callback.  The\n * callback can be invoked to remove the value from the chain at any time, even\n * after other values have been added or removed.  There is no effect if the\n * callback is run more than once, or if the value has already been removed.\n *\n * @category Chains\n */\nexport function pushCB<T>(c: Chain<T>, v: T) { ++c.v; return unlinker(c, link(v, c, c.p)); }\n\n/**\n * Return true if the chain is empty, or is null/undefined\n *\n * @category Chains\n */\nexport function isEmpty(c: Chain<any> | null | undefined) { return !c || c.v === 0; }\n\n/**\n * Return the number of items in the chain, or 0 if it's null/undefined\n *\n * @category Chains\n */\nexport function qlen(c: Chain<any>  | null | undefined) { return c ? c.v : 0; }\n\n/**\n * Remove a value from the end of the chain, returning it\n *\n * @category Chains\n */\nexport function pop<T>(c: Chain<T>) { if (qlen(c)) return unlink(c, c.p); }\n\n/**\n * Remove a value from the front of the chain, returning it\n *\n * @category Chains\n */\nexport function shift<T>(c: Chain<T>) { if (qlen(c)) return unlink(c, c.n); }\n\n/** A node in a chain */\nclass Node<T, V=T, U=DisposeFn> {\n    /** The next node (or the start node if this is a chain head) */\n    n: Node<T> = this as Node<T, any>;\n    /** The previous node (or the end node if this is a chain head) */\n    p: Node<T> = this as Node<T, any>;\n    /** The value held by the node (or the chain length if this is a chain head) */\n    v: V = 0 as any;\n    /** The most recently created undo callback for this node */\n    u: U = undefined;\n}\n\n/** Recycling list for chain nodes, to reduce constructor/alloc overhead */\nvar free: Node<any,any,any>;\n\n/** Create (or reuse) a node with a given value, inserting it between two nodes in a chain */\nfunction link<T,U=DisposeFn>(v: T, n: Node<T, any, any>, p: Node<T, any, any>): Node<T,T,U> {\n    let node: Node<T, T, any> = free;\n    if (node) {\n        free = node.n;\n        node.n = n || node;\n        node.p = p || node;\n    } else {\n        node = new Node<T, T, U>;\n        if (n) node.n = n;\n        if (p) node.p = p;\n    }\n    node.v = v;\n    node.n.p = node;\n    node.p.n = node;\n    return node;\n}\n\n/** Unlink a node from a chain and recycle it, returning the value it held */\nfunction unlink<T>(c: Chain<any>, node: Node<T>) {\n    --c.v;\n    var v = node.v, u = node.u;\n    node.n && (node.n.p = node.p);\n    node.p && (node.p.n = node.n);\n    node.u = node.v = node.p = undefined;\n    node.n = free; free = node;\n    if (u) u();  // drop refs to node+chain\n    return v;\n}\n\n/**\n * Return an undo/remove callback that will run at most once and is a no-op if the\n * node was already removed.  If called more than once on the same node while\n * it's in the same chain, it returns the same callback.  ()\n */\nfunction unlinker(chain: Chain<any>, node: Node<any>) {\n    let u = (node.u ||= () => {\n        if (u) {\n            // If the node's undo callback is this callback, then it's safe to remove;\n            // otherwise, the node has already been removed and/or recycled for use in\n            // a different chain (or a different value in this one!)\n            if (u === node.u) unlink(chain, node);\n            u = chain = node = undefined;\n        }\n    })\n    return u;\n}\n","import { makeCtx, current, freeCtx, swapCtx } from \"./ambient.ts\";\nimport { catchers, defaultCatch } from \"./internals.ts\";\nimport { CleanupFn, Job, Request, Yielding, Suspend, PlainFunction, StartFn, OptionalCleanup, JobIterator, RecalcSource, StartObj } from \"./types.ts\";\nimport { defer } from \"./defer.ts\";\nimport { JobResult, ErrorResult, CancelResult, isCancel, ValueResult, isError, isValue, noop, markHandled, isUnhandled, propagateResult } from \"./results.ts\";\nimport { rejecter, resolver, getResult, fulfillPromise } from \"./results.ts\";\nimport { Chain, chain, isEmpty, pop, push, pushCB, qlen, recycle, unshift } from \"./chains.ts\";\nimport { Source, Sink, Inlet, Connection } from \"./streams.ts\";\n\n/**\n * Is the given value a function?\n *\n * @category Types and Interfaces\n */\nexport function isFunction(f: any): f is Function {\n    return typeof f === \"function\";\n}\n\n/**\n * Return the currently-active Job, or throw an error if none is active.\n *\n * (You can check if a job is active first using {@link isJobActive}().)\n *\n * @category Jobs\n */\nexport function getJob<T=unknown>() {\n    const {job} = current;\n    if (job) return job as Job<T>;\n    throw new Error(\"No job is currently active\");\n}\n\n/** A null context (no job/observer) for cleanups to run in */\nconst nullCtx = makeCtx();\n\n/** RecalcSource factory for jobs (so you can wait on a job result in a signal or rule) */\nfunction recalcJob(job: Job<any>): RecalcSource { return (cb => { current.job.must(job.release(cb)); }); }\n\n/** Jobs' owners (parents) - uses a map so child jobs can't directly access them */\nconst owners = new WeakMap<Job, Job>();\n\nfunction runChain<T>(res: JobResult<T>, cbs: Chain<CleanupFn<T>>): undefined {\n    while (qlen(cbs)) try { pop(cbs)(res); } catch (e) { detached.asyncThrow(e); }\n    cbs && recycle(cbs);\n    return undefined;\n}\n\n// The set of jobs whose callbacks need running during an end() sweep\nvar inProcess = new Set<_Job<any>>;\n\nclass _Job<T> implements Job<T> {\n    /** @internal */\n    static create<T,R>(parent?: Job<R>, stop?: CleanupFn<R>): Job<T> {\n        const job = new _Job<T>;\n        if (parent || stop) {\n            job.must((parent ||= getJob() as Job<R>).release(stop || job.end));\n            owners.set(job, parent);\n        }\n        return job;\n    }\n\n    do(cleanup: CleanupFn<T>): this {\n        unshift(this._chain(), cleanup);\n        return this;\n    }\n\n    onError(cb: (err: any) => unknown): this {\n        return this.do(r => { if (isError(r)) cb(markHandled(r)); });\n    }\n\n    onValue(cb: (val: T) => unknown): this {\n        return this.do(r => { if (isValue(r)) cb(r.val); });\n    }\n\n    onCancel(cb: () => unknown): this {\n        return this.do(r => { if (isCancel(r)) cb(); });\n    }\n\n    result(): JobResult<T> | undefined {\n        // If we're done, we're done; otherwise make signals/rules reading this\n        // recalc when we're done (handy for rendering \"loading\" states).\n        return this._done || current.cell?.recalcWhen(this, recalcJob) || undefined;\n    }\n\n    get [Symbol.toStringTag]() { return \"Job\"; }\n\n    end = () => {\n        const res = (this._done ||= CancelResult), cbs = this._cbs;\n        // if we have an unhandled error, fall through to queued mode for later\n        // re-throw; otherwise, if there aren't any callbacks we're done here\n        if (!cbs && !isUnhandled(res)) return;\n\n        const ct = inProcess.size, old = swapCtx(nullCtx);;\n        // Put a placeholder on the queue if it's empty\n        if (!ct) inProcess.add(null);\n\n        // Give priority to the release() chain so we get breadth-first flagging\n        // of all child jobs as canceled immediately\n        if (cbs && cbs.u) cbs.u = runChain(res, cbs.u);\n\n        // Put ourselves on the queue *after* our children, so their cleanups run first\n        inProcess.add(this);\n\n        // if the queue wasn't empty, there's a loop above us that will run our must/do()s\n        if (ct) { swapCtx(old); return; }\n\n        // don't need the placeholder any more\n        inProcess.delete(null);\n\n        // Queue was empty, so it's up to us to run everybody's must/do()s\n        for (const item of inProcess) {\n            if (item._cbs) item._cbs = runChain(item._done, item._cbs);\n            inProcess.delete(item);\n            if (isUnhandled(item._done)) item.throw(markHandled(item._done));\n        }\n        swapCtx(old);\n    }\n\n    restart() {\n        if (!this._done && inProcess.size) {\n            // if a tree of jobs is ending right now, we need to start\n            // a new stack so that when we return, all our children's\n            // callbacks will have finished running first.\n            const old = inProcess;\n            inProcess = new Set;\n            this.end();\n            inProcess = old;\n        } else {\n            this._end(CancelResult);\n        }\n        this._done = undefined;\n        promises.delete(this);  // don't reuse any now-cancelled promise!\n        return this;\n    }\n\n    _end(res: JobResult<T>) {\n        if (this._done) throw new Error(\"Job already ended\");\n        if (this !== detached) this._done = res;\n        this.end();\n        return this;\n    }\n\n    throw(err: any) {\n        if (this._done) {\n            (owners.get(this) || detached).asyncThrow(err);\n            return this;\n        }\n        return this._end(ErrorResult(err));\n    }\n\n    return(val: T)  { return this._end(ValueResult(val)); }\n\n    then<T1=T, T2=never>(\n        onfulfilled?: (value: T) => T1 | PromiseLike<T1>,\n        onrejected?: (reason: any) => T2 | PromiseLike<T2>\n    ): Promise<T1 | T2> {\n        return nativePromise(this).then(onfulfilled, onrejected);\n    }\n\n    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult> {\n        return nativePromise(this).catch(onrejected);\n    }\n\n    finally(onfinally?: () => void): Promise<T> {\n        return nativePromise(this).finally(onfinally);\n    }\n\n    *[Symbol.iterator](): JobIterator<T> {\n        if (this._done) {\n            return getResult(this._done);\n        } else return yield (req: Request<T>) => {\n            // XXX should this be a release(), so if the waiter dies we\n            // don't bother? The downside is that it'd have to be mutual and\n            // the resume is a no-op anyway in that case.\n            this.do(res => fulfillPromise(resolver(req), rejecter(req), res));\n        }\n    }\n\n    start<T>(fn?: StartFn<T> | StartObj<T>): Job<T>;\n    start<T, This>(ctx: This, fn: StartFn<T, This>): Job<T>;\n    start<T, This>(fnOrCtx: StartFn<T> | StartObj<T>|This, fn?: StartFn<T, This>) {\n        if (!fnOrCtx) return makeJob(this);\n        let init: StartFn<T, This>, result: StartObj<T> | void;\n        if (isFunction(fn)) {\n            init = fn.bind(fnOrCtx as This);\n        } else if (isFunction(fnOrCtx)) {\n            init = fnOrCtx as StartFn<T, This>;\n        } else if (fnOrCtx instanceof _Job) {\n            return fnOrCtx;\n        } else {\n            result = fnOrCtx as StartObj<T>;\n        }\n        const job = makeJob<T>(this);\n        try {\n            if (init) result = job.run(init as StartFn<T>, job);\n            if (result != null) {\n                if (result instanceof _Job) {\n                    if (result !== job) result.do(res => propagateResult(job, res));\n                } else if (isFunction((result as Promise<T>).then)) {\n                    (result as Promise<T>).then(\n                        v => { job.result() || job.return(v); },\n                        e => { job.result() || job.throw(e); }\n                    );\n                    return job;\n                } else if (\n                    isFunction((result as Yielding<T>)[Symbol.iterator]) &&\n                    typeof result !== \"string\"\n                ) {\n                    job.run(runGen<T>, result as Yielding<T>, job);\n                } else {\n                    throw new TypeError(\"Invalid value/return for start()\");\n                }\n            }\n            return job;\n        } catch(e) {\n            job.end();\n            throw e;\n        }\n    }\n\n    connect<T>(src: Source<T>, sink: Sink<T>, inlet?: Inlet): Connection {\n        return this.start(job => void src(sink, job, inlet));\n    }\n\n    protected constructor() {};\n\n    run<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F> {\n        const old = swapCtx(makeCtx(this));\n        try { return fn.apply(null, args); } finally { freeCtx(swapCtx(old)); }\n    }\n\n    bind<F extends (...args: any[]) => any>(fn: F): F {\n        const job = this;\n        return <F> function (this: any) {\n            const old = swapCtx(makeCtx(job));\n            try { return fn.apply(this, arguments as any); } finally { freeCtx(swapCtx(old)); }\n        }\n    }\n\n    must(cleanup?: OptionalCleanup<T>) {\n        if (isFunction(cleanup)) push(this._chain(), cleanup);\n        return this;\n    }\n\n    release(cleanup: CleanupFn<T>): () => void {\n        if (this === detached) return noop;\n        let cbs = this._chain();\n        if (!this._done || cbs.u) cbs = cbs.u ||= chain();\n        return pushCB(cbs, cleanup);\n    }\n\n    asyncThrow(err: any) {\n        try {\n            (catchers.get(this) || this.throw).call(this, err);\n        } catch (e) {\n            // Don't allow a broken handler to stay on the job\n            if (this === detached) catchers.set(this, defaultCatch); else catchers.delete(this);\n            const catcher = catchers.get(this) || this.throw;\n            catcher.call(this, err);\n            catcher.call(this, e);   // also report the broken handler\n        }\n        return this;\n    }\n\n    asyncCatch(handler: ((this: Job, err: any) => unknown) | null): this {\n        if (isFunction(handler)) catchers.set(this, handler);\n        else if (handler === null) catchers.delete(this);\n        return this;\n    }\n\n    protected _done: JobResult<T> = undefined;\n\n    // Chain whose .u stores a second chain for `release()` callbacks\n    protected _cbs: Chain<CleanupFn<T>, Chain<CleanupFn<T>>> = undefined;\n    protected _chain() {\n        if (this === detached) this.end()\n        if (this._done && isEmpty(this._cbs)) defer(this.end);\n        return this._cbs ||= chain();\n    }\n}\n\nconst promises = new WeakMap<Job<any>, Promise<any>>();\n\n/**\n * Obtain a native promise for a job\n *\n * While jobs have the same interface as native promises, there are occasionally\n * reasons to just use one directly.  (Like when Uneventful uses this function\n * to implement jobs' promise methods!)\n *\n * @param job Optional: the job to get a native promise for.  If none is given,\n * the active job is used.\n *\n * @returns A {@link Promise} that resolves or rejects according to whether the\n * job returns or throws.  If the job is canceled, the promise is rejected with\n * a {@link CancelError}.\n *\n * @category Jobs\n */\nexport function nativePromise<T>(job = getJob<T>()): Promise<T> {\n    if (!promises.has(job)) {\n        promises.set(job, new Promise((res, rej) => {\n            const toPromise = (fulfillPromise<T>).bind(null, res, rej);\n            if (job.result()) toPromise(job.result()); else job.do(toPromise);\n        }));\n    }\n    return promises.get(job);\n}\n\n/**\n * Return a new {@link Job}.  If *either* a parent parameter or stop function\n * are given, the new job is linked to the parent.\n *\n * @param parent The parent job to which the new job should be attached.\n * Defaults to the currently-active job if none given (assuming a stop\n * parameter is provided).\n *\n * @param stop The function to call to destroy the nested job.  Defaults to the\n * {@link Job.end} method of the new job if none is given (assuming a parent\n * parameter is provided).\n *\n * @returns A new job.  The job is linked/nested if any arguments are given,\n * or a detached (parentless) job otherwise.\n *\n * @category Jobs\n */\nexport const makeJob: <T,R=unknown>(parent?: Job<R>, stop?: CleanupFn<R>) => Job<T> = _Job.create;\n\n/**\n * A special {@link Job} with no parents, that can be used to create standalone\n * jobs.  detached.start() returns a new detached job, detached.run() can be\n * used to run code that expects to create a child job, and detached.bind() can\n * wrap a function to work without a parent job.\n *\n * (Note that in all cases, a child job of `detached` *must* be stopped\n * explicitly, or it may \"run\" forever, never running its cleanup callbacks.)\n *\n * The detached job has a few special features and limitations:\n *\n * - It can't be ended, thrown, return()ed, etc. -- you'll get an error\n *\n * - It can't have any cleanup functions added: no do, must, onError, etc., and\n *   thus also can't have any native promise, abort signal, etc. used.  You can\n *   call its release() method, but nothing will actually be registered and the\n *   returned callback is a no-op.\n *\n * - Unhandled errors from jobs without parents (and errors from *any* job's\n *   cleanup functions) are sent to the detached job for handling.  This means\n *   whatever you set as the detached job's .{@link Job.asyncCatch asyncCatch}()\n *   handler will receive them.  (Its default is Promise.reject, causing an\n *   unhandled promise rejection.)\n *\n * @category Jobs\n */\nexport const detached = makeJob();\n(detached as any).end = () => { throw new Error(\"Can't do that with the detached job\"); }\ndetached.asyncCatch(defaultCatch);\n\nfunction runGen<R>(g: Yielding<R>, job: Job<R>) {\n    let it = g[Symbol.iterator](), running = true, ctx = makeCtx(job), ct = 0;\n    let done = ctx.job.release(() => {\n        job = undefined;\n        ++ct; // disable any outstanding request(s)\n        // XXX this should be deferred to cleanup phase, or must() instead of release\n        // (release only makes sense here if you can run more than one generator in a job)\n        step(\"return\", undefined);\n    });\n    // Start asynchronously\n    defer(() => { running = false; step(\"next\", undefined); });\n\n    function step(method: \"next\" | \"throw\" | \"return\", arg: any): void {\n        if (!it) return;\n        // Don't resume a job while it's running\n        if (running) {\n            return defer(step.bind(null, method, arg));\n        }\n        const old = swapCtx(ctx);\n        try {\n            running = true;\n            try {\n                for(;;) {\n                    ++ct;\n                    const {done, value} = it[method](arg);\n                    if (done) {\n                        job && job.return(value);\n                        job = undefined;\n                        break;\n                    } else if (!isFunction(value)) {\n                        method = \"throw\";\n                        arg = new TypeError(\"Jobs must yield functions (or yield* Yielding<T>s)\");\n                        continue;\n                    } else {\n                        let called = false, returned = false, count = ct;\n                        (value as Suspend<any>)((op, val, err) => {\n                            if (called) return; else called = true;\n                            method = op; arg = op === \"next\" ? val : err;\n                            if (returned && count === ct) step(op, arg);\n                        });\n                        returned = true;\n                        if (!called) return;\n                    }\n                }\n            } catch(e) {\n                it = job = undefined;\n                ctx.job.throw(e);\n            }\n            // Iteration is finished; disconnect from job\n            it = undefined;\n            done?.();\n            done = undefined;\n        } finally {\n            swapCtx(old);\n            running = false;\n        }\n    }\n}\n","import { Request, Yielding } from \"./types.ts\";\nimport { rejecter, resolve, resolver } from \"./results.ts\"\n\n/**\n * Convert a promise to something you can `yield *to()` in a job\n *\n * Much like `await valueOrPromiseLike` in an async function, using `yield\n * *to(valueOrPromiseLike)` in a {@link Job}'s generator function will return\n * the value or the result of the promise/promise-like object.\n *\n * @category Scheduling\n */\nexport function *to<T>(p: Promise<T> | PromiseLike<T> | T): Yielding<T> {\n    return yield (res: Request<T>) => Promise.resolve(p).then(resolver(res), rejecter(res));\n}\n\n/**\n * Pause the job for the specified time in ms, e.g. `yield *sleep(1000)` to wait\n * one second.\n *\n * @category Scheduling\n */\nexport function *sleep(ms: number): Yielding<void> {\n    try {\n        var id: ReturnType<typeof setTimeout>;\n        yield r => {\n            id = setTimeout(() => { id = undefined; resolve(r, void 0); },  ms);\n        }\n    } finally {\n        if (id) clearTimeout(id);\n    }\n}\n","import { defer } from \"./defer.ts\";\n\n/** Scheduler state flags */\nconst enum Is {\n    Unset = 0,\n    _ = 1,\n    Running   = _ << 0,\n    Scheduled = _ << 1,\n}\n\n/**\n * A generic queue for things that need to be run at-most-once per item\n * per timeframe.\n *\n * @category Jobs and Scheduling\n */\nexport class RunQueue<K> {\n    protected _flags: Is = Is.Unset;\n    protected readonly q = new Set<K>();\n\n    constructor(\n        /**\n         * A single-argument scheduling function (like requestAnimationFrame,\n         * setImmediate, or queueMicrotask).  The scheduler will call it from\n         * time to time with a single callback.  The scheduling function should\n         * then arrange for that callback to be invoked *once* at some future\n         * point, when it is the desired time for all pending items on this\n         * queue to run.\n         */\n        protected readonly sched: (cb: () => unknown) => unknown,\n        /**\n         * A callback to loop over the queue, removing items and performing any\n         * necessary operations\n         */\n        protected readonly reap: (queue: Set<K>) => void\n    ) {}\n\n    /** Is this queue currently running? */\n    isRunning() { return !!(this._flags & Is.Running); }\n\n    /** Is this queue currently empty? */\n    isEmpty() { return !this.q.size; }\n\n    add(subject: K) {\n        this.q.size || this._flags & (Is.Running|Is.Scheduled) || this._sched();\n        this.q.add(subject);\n    }\n\n    delete(subject: any) {\n        this.q.delete(subject);\n    }\n\n    protected _sched() {\n        this._flags |= Is.Scheduled;\n        this.sched(this._run);\n    }\n\n    protected _run = () => {\n        this._flags &= ~Is.Scheduled;\n        this.flush();\n    }\n\n    /** Run all pending items */\n    flush = () => {\n        // already running? skip it\n        if (this._flags & Is.Running) return;\n        const {q: queue} = this;\n        // nothing to do? skip it\n        if (!queue.size) return;\n        this._flags |= Is.Running;\n        try {\n            this.reap(queue);\n        } finally {\n            this._flags &= ~Is.Running;\n            // schedule again if we're stopping early due to error\n            !queue.size || (this._flags & Is.Scheduled) || this._sched();\n        }\n    }\n}\n\n/** @internal */\nexport const pulls = new RunQueue<{doPull(): void}>(defer, pulls => {\n    for (const conn of pulls) { pulls.delete(conn); conn.doPull(); }\n})\n\n/** @internal For testing only */\nexport const runPulls  = pulls.flush;","import { pulls } from \"./scheduling.ts\";\nimport { DisposeFn, Job } from \"./types.ts\";\nimport { getJob } from \"./tracking.ts\";\nimport { current } from \"./ambient.ts\";\nimport { Signal, Writable } from \"./signals.ts\";\n\n/**\n * A backpressure controller: returns true if downstream is ready to accept\n * data.\n *\n * @param cb (optional) - a callback to run when the downstream consumer wishes\n * to resume event production (i.e., when a sink calls\n * {@link Throttle.resume}()).  The callback is automatically unregistered when\n * invoked, so the producer must re-register it after each call if it wishes to\n * keep being called.\n *\n * @category Types and Interfaces\n */\nexport type Backpressure = (cb?: () => any) => boolean\n\n\n/**\n * Create a backpressure control function for the given connection\n *\n * @category Stream Producers\n */\nexport function backpressure(inlet: Inlet = defaultInlet): Backpressure {\n    const job = getJob();\n    return (cb?: Flush) => {\n        if (!job.result() && inlet.isOpen()) {\n            if (cb) inlet.onReady(cb, job);\n            return inlet.isReady();\n        }\n        return false;\n    }\n}\n\n/**\n * Control backpressure for listening streams.  This interface is the API\n * internal to the implementation of {@link backpressure}().  Unless you're\n * implementing a backpressurable stream yourself, see the {@link Throttle}\n * interface instead.\n *\n * @category Types and Interfaces\n */\nexport interface Inlet {\n    /** Is the main connection open?  (i.e. is the creating job not closed yet?) */\n    isOpen(): boolean\n\n    /** Is the conduit currently ready to receive data? */\n    isReady(): boolean\n\n    /**\n     * Register a callback to produce more data when the inlet is resumed\n     * (The callback is unregistered if the supplied job ends.)\n     */\n    onReady(cb: () => any, job: Job): this;\n}\n\n/**\n * Control backpressure for listening streams\n *\n * Obtain instances via {@link throttle}(), then pass them into the appropriate\n * stream-consuming API.  (e.g. {@link connect}).\n *\n * @category Types and Interfaces\n */\nexport interface Throttle extends Inlet {\n    /** Set inlet status to \"paused\". */\n    pause(): void;\n\n    /**\n     * Un-pause, and iterate backpressure-able sources' onReady callbacks to\n     * resume sending immediately.  (i.e., synchronously!)\n     */\n    resume(): void;\n}\n\n/**\n * A Connection is a job that returns void when the connected stream ends\n * itself.  If the stream doesn't end itself (e.g. it's an event listener), the\n * job will never return, and only end with a cancel or throw.\n *\n * @category Types and Interfaces\n */\nexport type Connection = Job<void>;\n\n/**\n * A Producer is a function that can be called to arrange for data to be\n * produced and sent to a {@link Sink} function for consumption, until the\n * associated {@link Connection} is closed (either by the source or the sink,\n * e.g. if the sink doesn't want more data or the source has no more to send).\n *\n * If the source is a backpressurable stream, it can use the (optional) supplied\n * inlet (usually a {@link throttle}()) to rate-limit its output.\n *\n * A producer function *must* return the special {@link IsStream} value, so\n * TypeScript can tell what functions are usable as sources.  (Otherwise any\n * void function with no arguments would appear to be usable as a source!)\n *\n * @category Types and Interfaces\n */\nexport type Producer<T> = (sink: Sink<T>, conn?: Connection, inlet?: Throttle | Inlet) => typeof IsStream;\n\n/**\n * A Source is either a {@link Producer} or a {@link Signal}.  (Signals actually\n * implement the {@link Producer} interface as an overload, but TypeScript gets\n * confused about that sometimes, so we generally declare our stream *inputs* as\n * `Source<T>` and our stream *outputs* as {@link Producer}, so that TypeScript\n * knows what's what.\n *\n * @category Types and Interfaces\n */\nexport type Source<T> = Producer<T> | Signal<T> | Writable<T>;\n\n/**\n * A specially-typed string used to verify that a function supports uneventful's\n * streaming protocol.  Return it from a function to implement the\n * {@link Source} type.\n *\n * @category Types and Interfaces\n */\nexport const IsStream = \"uneventful/is-stream\" as const;\n\n/**\n * A `Sink` is a function that receives data from a {@link Source}.\n *\n * @category Types and Interfaces\n */\nexport type Sink<T> = (val: T) => void;\n\n/**\n * A `Transformer` is a function that takes one source and returns another,\n * possibly one that produces data of a different type.  Most operator functions\n * return a transformer, allowing them to be combined via {@link pipe}().\n *\n * @category Types and Interfaces\n */\nexport type Transformer<T, V=T> = (input: Source<T>) => Producer<V>;\n\ntype Flush = () => any\n\n\n/**\n * Subscribe a sink to a source, returning a nested job. (Shorthand for\n * {@link getJob}().{@link Job.connect connect}(...).)\n *\n * @param src An event source or finite data stream\n * @param sink A callback that will receive the events\n * @param inlet Optional - a {@link throttle}() to control backpressure\n *\n * @returns A job that can be aborted to end the subscription, and which will\n * end naturally (with a void return or error) if the stream ends itself.\n *\n * @category Stream Consumers\n */\nexport function connect<T>(src: Source<T>, sink: Sink<T>, inlet?: Throttle | Inlet): Connection {\n    return getJob().connect(src, sink, inlet);\n}\n\n/**\n * Create a backpressure controller for a stream.  Pass it to one or more\n * sources you're connecting to, and if they support backpressure they'll\n * respond when you call its .pause() and .resume() methods.\n *\n * @param job - Optional: a job that controls readiness.  (The throttle will\n * pause indefinitely when the job ends.)  Defaults to the currently-active job,\n * but unlike most such defaults, it won't throw if no job is active.\n *\n * @category Stream Consumers\n */\nexport function throttle(job: Job = current.job): Throttle {\n    return new _Throttle(job);\n}\n\nclass _Throttle implements Throttle {\n    /** @internal */\n    protected _callbacks: Map<Flush, DisposeFn> = undefined;\n\n    /** @internal */\n    constructor(protected _job?: Job) {}\n\n    isOpen(): boolean { return !this._job?.result(); }\n\n    /** Is the conduit currently ready to receive data? */\n    isReady(): boolean { return this.isOpen() && this._isReady; }\n\n    _isReady = true;\n    _isPulling = false;\n\n    onReady(cb: Flush, job: Job) {\n        if (!this.isOpen()) return this;\n        const _callbacks = (this._callbacks ||= new Map);\n        const unlink = job.release(() => _callbacks.delete(cb));\n        if (this.isReady() && this && !_callbacks.size) {\n            pulls.add(this);\n        }\n        _callbacks.set(cb, unlink);\n        return this;\n    }\n\n    pause() { this._isReady = false; return this; }\n\n    doPull() {\n        if (this._isPulling) return;\n        const {_callbacks} = this;\n        if (!_callbacks?.size) return;\n        this._isPulling = true;\n        try {\n            for(let [cb, unlink] of _callbacks) {\n                if (!this.isReady()) break;  // we're done\n                unlink()\n                _callbacks.delete(cb);\n                cb() // XXX error handling?\n            }\n        } finally {\n            this._isPulling = false;\n        }\n    }\n\n    resume() {\n        if (this.isOpen()) {\n            this._isReady = true;\n            this.doPull();\n        }\n    }\n}\n\nconst defaultInlet: Inlet = throttle();\n\n/**\n * Pipe a stream (or anything else) through a series of single-argument\n * functions/operators\n *\n * e.g. the following creates a stream that outputs 4 and then 6:\n *\n * ```ts\n * pipe(fromIterable([1,2,3,4]), skip(1), take(2), map(x => x*2))\n * ```\n *\n * The first argument to pipe() can be any value, but all other arguments must\n * be functions.  The value is passed to the first function, and then the result\n * is passed to the next function in turn, until all provided functions have\n * been called with the result of the previous function.  The return value is\n * the last result, or the original value if no functions were given.\n *\n * The underlying implementation of pipe() works with any number of arguments,\n * but due to TypeScript limitations we only have typing defined for a max of 9\n * functions (10 arguments total).  If you need more than 9 functions, you can\n * stack some of them with {@link compose}(), e.g.:\n *\n * ```typescript\n * pipe(\n *     aStream,\n *     compose(op1, op2, ...),\n *     compose(op10, op11, ...),\n *     compose(op19, ...),\n *     ...\n * )\n * ```\n *\n * @category Stream Operators\n */\nexport function pipe<A,B,C,D,E,F,G,H,I,J>(input: A, ...fns: Chain9<A,J,B,C,D,E,F,G,H,I>): J\nexport function pipe<A,B,C,D,E,F,G,H,I>  (input: A, ...fns: Chain8<A,I,B,C,D,E,F,G,H>):   I\nexport function pipe<A,B,C,D,E,F,G,H>    (input: A, ...fns: Chain7<A,H,B,C,D,E,F,G>):     H\nexport function pipe<A,B,C,D,E,F,G>      (input: A, ...fns: Chain6<A,G,B,C,D,E,F>):       G\nexport function pipe<A,B,C,D,E,F>        (input: A, ...fns: Chain5<A,F,B,C,D,E>):         F\nexport function pipe<A,B,C,D,E>          (input: A, ...fns: Chain4<A,E,B,C,D>):           E\nexport function pipe<A,B,C,D>            (input: A, ...fns: Chain3<A,D,B,C>):             D\nexport function pipe<A,B,C>              (input: A, ...fns: Chain2<A,C,B>):               C\nexport function pipe<A,B>                (input: A, ...fns: Chain1<A,B>):                 B\nexport function pipe<A>                  (input: A): A\nexport function pipe(input: any, ...fns: Array<(v: any) => any>): any;\nexport function pipe<A,X>(): X {\n    var v = arguments[0];\n    for (var i=1; i<arguments.length; i++) v = arguments[i](v);\n    return v;\n}\n\n/**\n * Compose a series of single-argument functions/operators in application order.\n * (This is basically a deferred version of {@link pipe}().)  For example:\n *\n * ```ts\n * const func = compose(skip(1), take(2), map(x => x*2));\n * const stream_4_6 = func(fromIterable([1,2,3,4])); // stream that outputs 4, 6\n * ```\n *\n * As with `pipe()`, the declared typings only support composing up to 9\n * functions at once; if you need more you'll need to nest calls to `compose()`\n * (i.e. passing the result of a `compose()` as an argument to another\n * `compose()` call.)\n *\n * @returns A function taking the same type as the first input function,\n * returning the same type as the last input function.\n *\n * @category Stream Operators\n */\nexport function compose<A,B,C,D,E,F,G,H,I,J>(...fns: Chain9<A,J,B,C,D,E,F,G,H,I>): (a: A) => J\nexport function compose<A,B,C,D,E,F,G,H,I>  (...fns: Chain8<A,I,B,C,D,E,F,G,H>):   (a: A) => I\nexport function compose<A,B,C,D,E,F,G,H>    (...fns: Chain7<A,H,B,C,D,E,F,G>):     (a: A) => H\nexport function compose<A,B,C,D,E,F,G>      (...fns: Chain6<A,G,B,C,D,E,F>):       (a: A) => G\nexport function compose<A,B,C,D,E,F>        (...fns: Chain5<A,F,B,C,D,E>):         (a: A) => F\nexport function compose<A,B,C,D,E>          (...fns: Chain4<A,E,B,C,D>):           (a: A) => E\nexport function compose<A,B,C,D>            (...fns: Chain3<A,D,B,C>):             (a: A) => D\nexport function compose<A,B,C>              (...fns: Chain2<A,C,B>):               (a: A) => C\nexport function compose<A,B>                (...fns: Chain1<A,B>):                 (a: A) => B\nexport function compose<A>                  (): (a: A) => A\nexport function compose(...fns: ((v:any)=>any)[]) {\n    return (val:any) => (pipe as any)(val, ...fns);\n}\n\ntype Chain1<A,R>                 = [(v: A) => R];\ntype Chain2<A,R,B>               = [...Chain1<A,B>, ...Chain1<B,R>];\ntype Chain3<A,R,B,C>             = [...Chain1<A,B>, ...Chain2<B,R,C>];\ntype Chain4<A,R,B,C,D>           = [...Chain1<A,B>, ...Chain3<B,R,C,D>];\ntype Chain5<A,R,B,C,D,E>         = [...Chain1<A,B>, ...Chain4<B,R,C,D,E>];\ntype Chain6<A,R,B,C,D,E,F>       = [...Chain1<A,B>, ...Chain5<B,R,C,D,E,F>];\ntype Chain7<A,R,B,C,D,E,F,G>     = [...Chain1<A,B>, ...Chain6<B,R,C,D,E,F,G>];\ntype Chain8<A,R,B,C,D,E,F,G,H>   = [...Chain1<A,B>, ...Chain7<B,R,C,D,E,F,G,H>];\ntype Chain9<A,R,B,C,D,E,F,G,H,I> = [...Chain1<A,B>, ...Chain8<B,R,C,D,E,F,G,H,I>];\n\n/**\n * Pass subscriber into a stream (or any arguments into any other function).\n *\n * This utility is mainly here for uses like:\n *\n * - `pipe(src, into(sink))`,\n * - `pipe(src, into(sink, conn))`,\n * - `pipe(src, into(restarting(sink)))`, etc.\n *\n * but can also be used for argument currying generally.\n *\n * @param args The arguments to pass to the stream (or other function)\n *\n * @returns a function that takes another function and calls it with the given args.\n *\n * @category Stream Consumers\n */\nexport function into<In extends any[], Out>(...args: In): (src: (...args: In) => Out) => Out {\n    return src => src(...args);\n}\n","export function setMap<K, V>(map: { set(key: K, val: V): void; }, key: K, val: V) {\n    map.set(key, val);\n    return val;\n}\n","import { Context, current, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { defer } from \"./defer.ts\";\nimport { RunQueue } from \"./scheduling.ts\";\nimport { DisposeFn, OptionalCleanup, RecalcSource } from \"./types.ts\"\nimport { detached, getJob, makeJob } from \"./tracking.ts\";\nimport { Connection, Inlet, IsStream, Sink, Producer, backpressure } from \"./streams.ts\";\nimport { setMap } from \"./utils.ts\";\nimport { isCancel } from \"./results.ts\";\n\n/**\n * Error indicating a rule has attempted to write a value it indirectly\n * depends on, or which has already been read by another rule in the current\n * batch. (Also thrown when a cached function attempts to write a value at all,\n * directly or inidirectly.)\n *\n * @category Errors\n */\nexport class WriteConflict extends Error {}\n\n/**\n * Error indicating a rule has attempted to write a value it directly depends\n * on, or a cached function has called itself, directly or indirectly.\n *\n * @category Errors\n */\nexport class CircularDependency extends Error {}\n\nvar timestamp = 1;\nvar currentRule: Cell;\nvar currentQueue: RuleScheduler;\n\n/**\n * A queue for rules to run during a particular kind of period, such as\n * microtasks or animation frames.  (Can only be obtained or created via\n * {@link RuleScheduler.for}().)\n *\n * @category Signals\n */\nexport class RuleScheduler {\n\n    /** @internal */\n    protected static cache = new WeakMap<Function, RuleScheduler>();\n\n    /** @internal */\n    protected readonly q: RunQueue<Cell>;\n\n    /**\n     * Run all pending rules on this scheduler.\n     *\n     * This is a bound method\n     *\n     * (Note: \"pending\" rules are ones with at least one changed ancestor\n     * dependency; this doesn't mean they will actually *do* anything,\n     * since intermediate cached() function results might end up unchanged.)\n     */\n    flush: () => void;\n\n    /**\n     * Create an {@link RuleScheduler} from a callback-taking function, that\n     * you can then use to make rules that run in a specific time frame.\n     *\n     * ```ts\n     * // frame.rule will now create rules that run during animation fames\n     * const animate = RuleScheduler.for(requestAnimationFrame).rule;\n     *\n     * animate(() => {\n     *     // ... do stuff in an animation frame when signals used here change\n     * })\n     * ```\n     *\n     * Returns the default scheduler if no arguments are given.  If called with\n     * the same function more than once, it returns the same scheduler instance.\n     *\n     * @param scheduleFn A single-argument scheduling function (like\n     * requestAnimationFrame, setImmediate, or queueMicrotask).  The scheduler\n     * will call it from time to time with a single callback.  The scheduling\n     * function should then arrange for that callback to be invoked *once* at\n     * some future point, when it is the desired time for all pending rules on\n     * that scheduler to run.\n     */\n    static for(scheduleFn: (cb: () => unknown) => unknown = defer) {\n        this.cache.has(scheduleFn) || this.cache.set(scheduleFn, new this(scheduleFn));\n        return this.cache.get(scheduleFn);\n    }\n\n    protected constructor(_scheduleFn: (cb: () => unknown) => unknown = defer) {\n        this.q = new RunQueue<Cell>(_scheduleFn, _queue => {\n            // another queue is running? reschedule for later\n            if (currentQueue) return;\n            currentQueue = this;\n            try {\n                // run rules marked dirty by value changes\n                for(currentRule of _queue) {\n                    currentRule.catchUp();\n                    _queue.delete(currentRule);\n                }\n            } finally {\n                currentQueue = currentRule = undefined;\n            }\n        });\n        this.flush = this.q.flush;\n    }\n\n    /**\n     * @inheritdoc rule tied to a specific scheduler.  See {@link rule} for\n     * more details.\n     *\n     * @remarks The rule will only run during its matching\n     * {@link RuleScheduler.flush}().\n     *\n     * This is a bound method, so you can use it independently of the scheduler\n     * it came from.\n     */\n    rule = (fn: (stop: DisposeFn) => OptionalCleanup): DisposeFn => {\n        return Cell.mkRule(fn, this.q);\n    };\n}\n\nconst defaultQueue = RuleScheduler.for(defer);\n\n/**\n * Subscribe a function to run every time certain values change.\n *\n * @remarks\n * The function is run asynchronously, first after being created, then again\n * after there are changes in any of the values or cached functions it read\n * during its previous run.\n *\n * The created subscription is tied to the currently-active job (which may be\n * another rule).  So when that job is ended or restarted, the rule will be\n * terminated automatically.  You can also terminate it early by calling the\n * \"stop\" function that is both passed to the rule function and returned by\n * `rule()`.\n *\n * Note: this function will throw an error if called without an active job. If\n * you need a standalone rule, use {@link detached}.run to wrap the\n * call to rule.\n *\n * @param fn The function that will be run each time its dependencies change.\n * The function will be run in a restarted job each time, with any resources\n * used by the previous run being cleaned up.  The function is passed a single\n * argument: a function that can be called to terminate the rule.   The function\n * should return a cleanup function or void.\n *\n * @returns A function that can be called to terminate the rule.\n *\n * @category Signals\n */\nexport const rule = defaultQueue.rule;\n\n/**\n * Synchronously run pending rules from the default scheduler.\n *\n * @remarks Equivalent to calling\n * {@link RuleScheduler.for}(defer).{@link RuleScheduler.flush flush}().\n *\n * Note that you should normally only need to call this when you need\n * side-effects to occur within a specific synchronous timeframe, e.g. if\n * rules need to be able to cancel a synchronous event or continue an\n * IndexedDB transaction.  (You can also define rules to run in a specific\n * timeframe by creating a {@link RuleScheduler} for them, via\n * {@link RuleScheduler.for}.)\n *\n * @category Signals\n */\nexport const runRules = defaultQueue.flush\n\n\n/** recalcWhen(fn): map fn -> signal */\nconst fntrackers = new WeakMap<Function, () => number>();\n\n/** recalcWhen(key, factory): map factory -> key -> signal */\nconst obtrackers = new WeakMap<Function, WeakMap<WeakKey, () => number>>();\n\nconst dirtyStack: Cell[] = [];\n\nfunction markDependentsDirty(cell: Cell) {\n    // We don't set validThrough here because that's how we tell the cell's been read/depended on\n    const latestSource = cell.lastChanged = cell.latestSource = timestamp;\n    for(; cell; cell = dirtyStack.pop()) {\n        for (let sub=cell.subscribers; sub; sub = sub.nT) {\n            const tgt = sub.tgt;\n            if (tgt.latestSource >= latestSource || tgt.latestSource === 0) continue;\n            tgt.latestSource = latestSource;\n            if (tgt.flags & Is.Rule) (tgt.value as RunQueue<Cell>).add(tgt);\n            if (tgt.subscribers) dirtyStack.push(tgt);\n        }\n    }\n}\n\n\nconst enum Is {\n    Rule = 1 << 0,\n    Lazy   = 1 << 2,\n    Dead   = 1 << 3,\n    Error  = 1 << 4,\n    Running = 1 << 5,\n    Stream  = 1 << 6,\n    Computed = Rule | Lazy,\n}\n\ntype Subscription = {\n    /** Source of the subscription */\n    src: Cell\n    nS: Subscription,\n    pS: Subscription,\n\n    /** Subscriber */\n    tgt: Cell\n    nT: Subscription,\n    pT: Subscription,\n\n    ts: number,\n\n    /* stack for active subscriptions on sources */\n    old: Subscription\n}\n\nvar freesubs: Subscription;\n\nfunction mksub(source: Cell, target: Cell) {\n    let sub: Subscription = freesubs;\n    if (sub) {\n        freesubs = sub.old;\n        sub.src = source; sub.nS = undefined; sub.pS = target.sources;\n        sub.tgt = target; sub.nT = sub.pT = undefined;\n        sub.ts = source.lastChanged; sub.old = source.adding;\n    } else sub = {\n        src: source, nS: undefined, pS: target.sources,\n        tgt: target, nT: undefined, pT: undefined,\n        ts: source.lastChanged, old: source.adding\n    }\n    // Add subscription to tail of target's sources\n    if (target.sources) target.sources.nS = sub;\n    target.sources = sub;\n    // track that this source has had a subscription added during this calculation\n    source.adding = sub;\n    // Set up reciprocal subscription if needed\n    (target.latestSource === 0) || source.subscribe(sub);  // XXX\n}\n\nfunction delsub(sub: Subscription) {\n    sub.src.unsubscribe(sub);\n    if (sub.nS) sub.nS.pS = sub.pS;\n    if (sub.pS) sub.pS.nS = sub.nS;\n    sub.src = sub.tgt = sub.nS = sub.pS = sub.nT = sub.pT = undefined;\n    sub.old = freesubs;\n    freesubs = sub;\n}\n\nconst sentinel = {}  // a unique value for uniqueness checking\n\n/** @internal */\nexport class Cell {\n    value: any = undefined // the value, or, for a rule, the scheduler\n    validThrough = 0; // timestamp of most recent validation or recalculation\n    lastChanged = 0;  // timestamp of last value change\n    latestSource = timestamp; // max lastChanged of this cell or any ancestor source (0 = Infinity)\n    flags = 0;\n    ctx: Context = undefined;\n    /** The subscription being added during the current calculation - used for uniqueness */\n    adding: Subscription = undefined;\n    /** Linked list of sources */\n    sources: Subscription = undefined;\n    /** Linked list of targets */\n    subscribers: Subscription = undefined;\n\n    compute: () => any = undefined;\n\n    stream<T>(sink: Sink<T>, conn?: Connection, inlet?: Inlet) {\n        let lastValue = sentinel;\n        (inlet ? RuleScheduler.for(backpressure(inlet)).rule : rule)(() => {\n            const val = this.getValue();\n            if (val !== lastValue) sink(lastValue = val);\n        });\n        return IsStream;\n    }\n\n    getValue() {\n        if (arguments.length) return this.stream.apply(this, arguments as any);\n        this.catchUp();\n        const dep = current.cell;\n        if (dep) {\n            if (this.flags & Is.Running) throw new CircularDependency(\"Cached function dependency cycle\");\n            // See if we've already got a subscription node for the dependent\n            let s = this.adding;\n            if (!s || s.tgt !== dep) {\n                // nope, it's new\n                mksub(this, dep);\n            } else {\n                // Yep, see if it's a hangover from last time\n                if (s.ts === -1) {\n                    // yep, mark it reused\n                    s.ts = this.lastChanged;\n                    if (s.nS) { // if not at end, move it\n                        s.nS.pS = s.pS;\n                        if (s.pS) s.pS.nS = s.nS;\n                        s.nS = undefined;\n                        s.pS = dep.sources;\n                        dep.sources.nS = s;\n                        dep.sources = s;\n                    }\n                }\n                // else it's already done, no need to do anything.\n            }\n        }\n        if (this.flags & Is.Error) throw this.value;\n        return this.value;\n    }\n\n    setValue(val: any) {\n        const cell = current.cell || currentRule;\n        if (cell) {\n            if (cell.flags & Is.Lazy) throw new WriteConflict(\"Side-effects not allowed in cached functions\");\n            if (this.adding && this.adding.tgt === cell) throw new CircularDependency(\"Can't update direct dependency\");\n            if (this.validThrough === timestamp) throw new WriteConflict(\"Value already used\");\n        } else {\n            // Skip update if unchanged\n            if (val === this.value) return;\n            // If we had readers this timestamp, bump it so they'll run again\n            if (this.validThrough === timestamp) ++timestamp;\n        }\n        // If we changed as of the current timestamp, we're already dirty\n        (this.lastChanged === timestamp) || markDependentsDirty(this);\n        this.value = val;\n    }\n\n    catchUp() {\n        const {validThrough} = this;\n        if (validThrough === timestamp) return;\n        this.validThrough = timestamp;\n        if ((this.latestSource !== 0 && this.latestSource <= validThrough) || !(this.flags & Is.Computed)) return;\n        if (this.sources) {\n            for(let sub=this.sources; sub; sub = sub.nS) {\n                const s = sub.src;\n                // if source is clean, skip it (most should be)\n                if (s.latestSource !== 0 && s.latestSource <= validThrough) continue;\n                // changed since our last compute? we're definitely dirty\n                if (sub.ts !== s.lastChanged) return this.doRecalc();\n                // not a simple yes or no -- \"it's complicated\" -- so recurse\n                s.catchUp();\n                if (s.lastChanged > validThrough) {\n                    return this.doRecalc();\n                }\n            }\n        } else return this.doRecalc();\n    }\n\n    doRecalc() {\n        const oldCtx = swapCtx(this.ctx);\n        for(let sub = this.sources; sub; sub = sub.nS) {\n            sub.ts = -1; // mark stale for possible reuse\n            // attach sub to its source, so we can look it up\n            sub.old = sub.src.adding;\n            sub.src.adding = sub;\n            this.sources = sub;\n        }\n        this.flags |= Is.Running;\n        try {\n            if (this.flags & Is.Lazy) {\n                this.flags &= ~Is.Error\n                try {\n                    const future = this.compute();\n                    if (future !== this.value || !this.lastChanged) {\n                        this.value = future;\n                        this.lastChanged = timestamp;\n                    }\n                } catch(e) {\n                    this.flags |= Is.Error\n                    this.value = e;\n                    this.lastChanged = timestamp;\n                }\n            } else {\n                const {job} = this.ctx;\n                job.restart();\n                try {\n                    job.must(this.compute());\n                    this.lastChanged = timestamp;\n                } catch (e) {\n                    job.end();\n                    this.disposeRule();\n                    throw e;\n                }\n            }\n        } finally {\n            this.flags &= ~Is.Running;\n            swapCtx(oldCtx);\n            // reset this.src to the head of the list, dropping stale subscriptions\n            let head: Subscription;\n            for(let sub = this.sources; sub; ) {\n                const pS = sub.pS;\n                sub.src.adding = sub.old;\n                sub.old = undefined;\n                if (sub.ts === -1) delsub(sub); else head = sub;\n                sub = pS;\n            }\n            this.sources = head;\n            if (this.flags & Is.Dead) this.disposeRule();\n        }\n    }\n\n    disposeRule() {\n        this.flags |= Is.Dead;\n        (this.value as RunQueue<Cell>).delete(this);\n        if (current !== this.ctx) {\n            for(let s=this.sources; s;) { let nS = s.nS; delsub(s); s = nS; }\n            this.sources = undefined;\n            this.ctx.job.end();\n        }\n    }\n\n    subscribe(sub: Subscription) {\n        if (!this.subscribers) {\n            if (this.flags & Is.Lazy) {\n                this.latestSource = timestamp;\n                for(let s=this.sources; s; s = s.nS) s.src.subscribe(s);\n            }\n            if (this.flags & Is.Stream) this.compute();  // subscribe to source\n        }\n        if (this.subscribers !== sub && !sub.pT) { // avoid adding already-added subs\n            sub.nT = this.subscribers;\n            if (this.subscribers) this.subscribers.pT = sub;\n            this.subscribers = sub;\n        }\n    }\n\n    unsubscribe(sub: Subscription) {\n        if (sub.nT) sub.nT.pT = sub.pT;\n        if (sub.pT) sub.pT.nT = sub.nT;\n        if (this.subscribers === sub) this.subscribers = sub.nT;\n        if (!this.subscribers) {\n            if (this.flags & Is.Lazy) {\n                this.latestSource = 0;\n                for(let s=this.sources; s; s = s.nS) s.src.unsubscribe(s);\n            }\n            if (this.flags & Is.Stream) this.ctx.job?.restart();  // unsubscribe from source\n        }\n    }\n\n    static mkValue<T>(val: T) {\n        const cell = new Cell;\n        cell.value = val;\n        cell.lastChanged = timestamp;\n        return cell;\n    }\n\n    static mkStream<T>(src: Producer<T>, val?: T): () => T {\n        const cell = this.mkValue(val);\n        cell.flags |= Is.Stream;\n        cell.ctx = makeCtx();\n        const write = cell.setValue.bind(cell);\n        cell.compute = () => {\n            cell.ctx.job ||= makeJob()\n                .asyncCatch(e => detached.asyncThrow(e))\n                .must(r => { cell.value = val; isCancel(r) || (cell.ctx.job = undefined); })\n            ;\n            const old = swapCtx(cell.ctx);\n            try {\n                src(write);\n            } catch(e) {\n                detached.asyncThrow(e);\n                cell.ctx.job.end();\n                cell.ctx.job = undefined;\n            } finally {\n                swapCtx(old);\n            }\n        }\n        return cell.getValue.bind(cell);\n    }\n\n    recalcWhen(src: RecalcSource): void;\n    recalcWhen<T extends WeakKey>(key: T, factory: (key: T) => RecalcSource): void;\n    recalcWhen<T extends WeakKey>(fnOrKey: T | RecalcSource, fn?: (key: T) => RecalcSource) {\n        let trackers: WeakMap<WeakKey, () => number> = fn ?\n            obtrackers.get(fn) || setMap(obtrackers, fn, new WeakMap) :\n            fntrackers\n        ;\n        let signal = trackers.get(fnOrKey);\n        if (!signal) {\n            const src = fn ? fn(<T>fnOrKey) : <RecalcSource> fnOrKey;\n            let ct = 0;\n            signal = Cell.mkStream(s => (src(() => s(++ct)), IsStream), ct);\n            trackers.set(fnOrKey, signal);\n        }\n        signal();  // Subscribe to the cell\n    }\n\n    static mkCached<T>(compute: () => T): () => T {\n        const cell = new Cell;\n        cell.compute = compute;\n        cell.ctx = makeCtx(null, cell);\n        cell.flags = Is.Lazy;\n        cell.latestSource = 0;\n        return cell.getValue.bind(cell);\n    }\n\n    static mkRule(fn: (stop: () => void) => OptionalCleanup, q: RunQueue<Cell>) {\n        var unlink = getJob().release(stop);\n        var cell = new Cell, f = makeJob();\n        cell.value = q;\n        cell.compute = fn.bind(null, stop);\n        cell.ctx = makeCtx(f, cell);\n        cell.flags = Is.Rule;\n        q.add(cell);\n        return stop;\n        function stop() {\n            unlink();\n            if (cell) {\n                cell.disposeRule();\n                cell = undefined;\n            }\n        }\n    }\n}\n","import { current, freeCtx, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { PlainFunction, Yielding, RecalcSource } from \"./types.ts\";\nimport { Cell, rule } from \"./cells.ts\";\nimport { reject, resolve } from \"./results.ts\";\nimport { UntilMethod } from \"./sinks.ts\";\nimport { Connection, Inlet, IsStream, Sink, Source, Producer } from \"./streams.ts\";\nexport { RuleScheduler, rule, runRules, WriteConflict, CircularDependency } from \"./cells.ts\";\n\nexport interface Signal<T> {\n    /**\n     * A signal object implements the {@link Producer} interface, even if it's\n     * not directly recognized as one by TypeScript.\n     */\n    (sink: Sink<T>, conn?: Connection, inlet?: Inlet): typeof IsStream\n\n    /** A signal object can be called to get its current value */\n    (): T\n}\n\n/**\n * An observable value, as a zero-argument callable with extra methods.\n *\n * Note: this class is not directly instantiable - use {@link cached}() or call\n * {@link readonly |.readonly()} on an existing signal instead.\n *\n * @category Types and Interfaces\n */\nexport class Signal<T> extends Function implements UntilMethod<T> {\n    /** The current value */\n    get value() { return this(); }\n    /** The current value */\n    valueOf()   { return this(); }\n    /** The current value, as a string */\n    toString()  { return \"\" + this(); }\n    /** The current value */\n    toJSON()    { return this(); }\n    /** Get the signal's current value, without adding the signal as a dependency */\n    peek()      { return noDeps(this as () => T); };\n\n    /** Get a read-only version of this signal */\n    readonly(): Signal<T> { return this; }\n\n    /** New writable signal with a custom setter */\n    withSet(set: (v: T) => unknown) {\n        const that = this;\n        return mkSignal( function () { return that.apply(null, arguments); }, set);\n    }\n\n    *\"uneventful.until\"(): Yielding<T> {\n        return yield (r => {\n            try {\n                let res: T = this.peek();\n                if (res) resolve(r, res); else rule(() => {\n                    try { (res = this()) && resolve(r, res); } catch(e) { reject(r,e); }\n                })\n            } catch(e) {\n                reject(r, e);\n            }\n        });\n    }\n\n    protected constructor() { super(); }\n}\n\nexport interface Writable<T> {\n    /** Set the current value.  (Note: this is a bound method so it can be used as a callback.) */\n    set(val: T): void;\n}\n\n/**\n * A {@link Signal} with a {@link Writable.set | .set()} method and writable\n * {@link Writable.value | .value} property.\n *\n * Note: this class is not directly instantiable - use {@link value}() or call\n * {@link Signal.withSet | .withSet()} on an existing signal instead.\n *\n * @category Types and Interfaces\n */\nexport class Writable<T> extends Signal<T>  {\n    get value() { return this(); }\n    set value(val: T) { this.set(val); }\n    readonly(): Signal<T> {\n        const that = this;\n        return mkSignal<T>( function () { return that.apply(null, arguments); });\n    }\n}\n\n/**\n * Create a {@link Writable} signal with the given inital value\n *\n * @category Signals\n */\nexport function value<T>(val?: T): Writable<T> {\n    const cell = Cell.mkValue(val);\n    return mkSignal(cell.getValue.bind(cell), cell.setValue.bind(cell));\n}\n\n/**\n * Create a cached version of a function.  The returned callable is also a\n * {@link Signal}.\n *\n * Note: If the supplied function has a non-zero `.length` (i.e., it explicitly\n * takes arguments), it is assumed to be a {@link Source}, and the second\n * calling signature below will apply, even if TypeScript doesn't see it that\n * way!)\n *\n * @category Signals\n */\nexport function cached<T>(compute: () => T): Signal<T>;\n\n/**\n * If the supplied function has a non-zero `.length` (i.e., it explicitly takes\n * arguments), it is assumed to be a {@link Source}, and the second argument is\n * a default value for the created signal to use as default value until the\n * source produces a value.\n *\n * The source will be subscribed *only* while the signal is subscribed as a\n * stream, or observed (directly or indirectly) by a rule.  While subscribed,\n * the signal will update itself with the most recent value produced by the\n * source, triggering rules or events as appropriate if the value changes. When\n * the signal is once again unobserved, it will revert to the supplied inital\n * value.\n *\n * @param source A {@link Source} providing data which will become this signal's value\n * @param initVal The value to use when the signal is unobserved or waiting for the\n * first item from the source.\n */\nexport function cached<T>(source: Source<T>, initVal?: T): Signal<T>;\nexport function cached<T extends Signal<any>>(signal: T): T\nexport function cached<T>(compute: Source<T> | (() => T), initVal?: T): Signal<T> {\n    if (compute instanceof Signal) return compute;\n    return mkSignal(\n        compute.length ? Cell.mkStream(compute as Producer<T>, initVal) : Cell.mkCached(compute as () => T)\n    );\n}\n\n/**\n * Call a function without creating a dependency on any signals it reads.  (Like\n * {@link Signal.peek}, but for any function with any arguments.)\n *\n * You can also pass in any arguments the function takes, and the function's\n * return value is returned.\n *\n * @returns The result of calling `fn(..args)`\n *\n * @category Signals\n */\nexport function noDeps<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F> {\n    if (!current.cell) return fn(...args);\n    const old = swapCtx(makeCtx(current.job));\n    try { return fn.apply(null, args); } finally { freeCtx(swapCtx(old)); }\n}\n\n/**\n * Arrange for the current signal or rule to recalculate on demand\n *\n * This lets you interop with systems that have a way to query a value and\n * subscribe to changes to it, but not directly produce a signal.  (Such as\n * querying the DOM state and using a MutationObserver.)\n *\n * By calling this with a {@link Source} or {@link RecalcSource}, you arrange\n * for it to be subscribed, if and when the call occurs in a rule or a cached\n * function that's in use by a rule (directly or indirectly).  When the source\n * emits a value, the signal machinery will invalidate the caching of the\n * function or rule, forcing a recalculation and subsequent rule reruns, if\n * applicable.\n *\n * Note: you should generally only call the 1-argument version of this function\n * with \"static\" sources - i.e. ones that won't change on every call. Otherwise,\n * you will end up creating new signals each time, subscribing and unsubscribing\n * on every call to recalcWhen().\n *\n * If the source needs to reference some object, it's best to use the 2-argument\n * version (i.e. `changesWhen(someObj, factory)`, where `factory` is a function\n * that takes `someObj` and returns a suitable {@link RecalcSource}.)\n *\n * @remarks\n * recalcWhen is specifically designed so that using it does not pull in any\n * part of Uneventful's signals framework, in the event a program doesn't\n * already use it.  This means you can use it in library code to provide signal\n * compatibility, without adding bundle bloat to code that doesn't use signals.\n *\n * @category Signals\n */\nexport function recalcWhen(src: RecalcSource): void;\n/**\n * Two-argument variant of recalcWhen\n *\n * In certain circumstances, you may wish to use recalcWhen with a source\n * related to some object.  You could call recalcWhen with a closure, but that\n * would create and discard signals on every call.  So this 2-argument version\n * lets you avoid that by allowing the use of an arbitrary object as a key,\n * along with a factory function to turn the key into a {@link RecalcSource}.\n *\n * @param key an object to be used as a key\n *\n * @param factory a function that will be called with the key to obtain a\n * {@link RecalcSource}.  Note that this factory function must also be a static\n * function, not a closure, or the same memory thrash issue will occur.\n */\nexport function recalcWhen<T extends WeakKey>(key: T, factory: (key: T) => RecalcSource): void;\nexport function recalcWhen<T extends WeakKey>(fnOrKey: T | RecalcSource, fn?: (key: T) => RecalcSource) {\n    current.cell?.recalcWhen<T>(fnOrKey as T, fn);\n}\n\nfunction mkSignal<T>(get: () => T): Signal<T>\nfunction mkSignal<T>(get: () => T, set: (v: T) => void): Writable<T>\nfunction mkSignal<T>(get: () => T, set?: (v: T) => void) {\n    if (set) (get as Writable<T>)[\"set\"] = set;\n    return Object.setPrototypeOf(get, (set ? Writable : Signal).prototype);\n}\n","import { current, freeCtx, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { getJob, makeJob } from \"./tracking.ts\";\nimport { AnyFunction, Job, OptionalCleanup, StartFn, StartObj, Yielding } from \"./types.ts\";\n\n/**\n * Add a cleanup function to the active job. Non-function values are ignored.\n * Equivalent to {@link getJob}().{@link Job.must must}() -- see\n * {@link Job.must}() for more details.\n *\n * @category Jobs\n */\nexport function must<T>(cleanup?: OptionalCleanup<T>): Job<T> {\n    return (getJob() as Job<T>).must(cleanup);\n}\n\n/**\n * Start a nested job within the currently-active job.  (Shorthand for\n * {@link getJob}().{@link Job.start start}(...).)\n *\n * This function can be called with zero, one, or two arguments:\n *\n * - When called with zero arguments, the new job is returned without any other\n *   initialization.\n *\n * - When called with one argument that's a function (either a {@link SyncStart}\n *   or {@link AsyncStart}): the function is run inside the new job and receives\n *   it as an argument.  It can return a {@link Yielding} iterator (such as a\n *   generator or job), a promise, or void.  A returned iterator or promise will\n *   be treated as if the method was called with that to begin with; a returned\n *   job will be awaited and its result transferred to the new job\n *   asynchronously.\n *\n * - When called with one argument that's a {@link Yielding} iterator (such as a\n *   generator or an existing job): it's attached to the new job and executed\n *   asynchronously. (Starting in the next available microtask.)\n *\n * - When called with one argument that's a Promise, it's converted to a job\n *   that will end when the promise settles.  The resulting job is returned.\n *\n * - When called with two arguments -- a \"this\" object and a function -- it\n *   works the same as one argument that's a function, except the function is\n *   bound to the supplied \"this\" before being called.\n *\n *   This last signature is needed because you can't make generator arrows in JS\n *   yet: if you want to start() a generator function bound to the current\n *   `this`, you'll want to use `.start(this, function*() { ...whatever  })`.\n *\n *   (Note, however, that TypeScript and/or VSCode may require that you give\n *   such a function an explicit `this` parameter (e.g. `.start(this, function\n *   *(this) {...}));`) in order to correctly infer types inside a generator\n *   function.)\n *\n * In any of the above cases, if a supplied function throws an error when\n * starting, the new job will be ended, and the error synchronously re-thrown.\n *\n * @returns the created {@link Job}\n *\n * @category Jobs\n */\nexport function start<T>(init?: StartFn<T> | StartObj<T>): Job<T>;\n\n/**\n * The two-argument variant of start() allows you to pass a \"this\" object that\n * will be bound to the initialization function.  (It's mostly useful for\n * generator functions, since generator arrows aren't a thing yet.)\n */\nexport function start<T, This>(thisArg: This, fn: StartFn<T, This>): Job<T>;\nexport function start<T, This>(init: StartFn<T>|StartObj<T>|This, fn?: StartFn<T, This>) {\n    return getJob().start(init as This, fn);\n}\n\n/**\n * Is there a currently active job? (i.e., can you safely use {@link must}(),\n * or {@link getJob}() right now?)\n *\n * @category Jobs\n */\nexport function isJobActive() { return !!current.job; }\n\n\nconst timers = new WeakMap<Job,\n    ReturnType<typeof setTimeout> |  // current timeout\n    undefined | // no timeout set since job was last restarted (if ever)\n    null  // current timeout is 0, aka explicit no-timeout\n>();\n\n/**\n * Set the cancellation timeout for a job.\n *\n * When the timeout is reached, the job is canceled (throwing\n * {@link CancelError} to any waiting promises or jobs), unless a new timeout\n * is set before then.  You may set a new timeout value for a job as many times\n * as desired.  A timeout value of zero disables the timeout. Timers are\n * disposed of if the job is canceled or restarted.\n *\n * @param ms Optional: Number of milliseconds after which the job will be\n * canceled. Defaults to zero if not given.\n *\n * @param job Optional: the job to apply the timeout to.  If none is given, the\n * active job is used.\n *\n * @returns the job to which the timeout was added or removed.\n *\n * @category Scheduling\n */\nexport function timeout<T>(ms: number, job?: Job<T>): Job<T>;\nexport function timeout(ms = 0, job: Job = getJob()) {\n    let timer = timers.get(job);\n    if (timer) {\n        clearTimeout(timer);\n    } else if (timer === undefined && !job.result()) {\n        // no timeout has been set since job was last restarted,\n        // so we need to arrange to clear it\n        job.must(timeout.bind(null, 0, job));\n    }\n    if (job.result()) {\n        // allow restarted timer to set a new must()\n        timers.delete(job);\n    } else if (ms) {\n        timers.set(job, setTimeout(() => { timers.set(job, null); job.end(); }, ms));\n    } else {\n        timers.set(job, null); // Zero = cancel timeout, but don't duplicate must() if called again\n    }\n    return job;\n}\n\nconst abortSignals = new WeakMap<Job, AbortSignal>();\n\n/**\n * Get an AbortSignal that aborts when the job ends or is restarted.\n *\n * @param job Optional: the job to get an AbortSignal for.  If none is given,\n * the active job is used.\n *\n * @returns the AbortSignal\n *\n * @category Jobs\n */\nexport function abortSignal(job: Job = getJob()) {\n    let signal = abortSignals.get(job);\n    if (!signal) {\n        const ctrl = new AbortController;\n        signal = ctrl.signal;\n        job.do(() => { abortSignals.set(job, null); ctrl.abort(); });\n        abortSignals.set(job, signal);\n        if (job.result()) ctrl.abort();\n    }\n    return signal;\n}\n\n/**\n * Wrap a function in a {@link Job} that restarts each time the resulting\n * function is called, thereby canceling any nested jobs and cleaning up any\n * resources used by previous calls. (This can be useful for such things as\n * canceling an in-progress search when the user types more text in a field.)\n *\n * The restarting job will be ended when the job that invoked `restarting()`\n * is finished, canceled, or restarted.  Calling the wrapped function after its\n * job has ended will result in an error.  You can wrap any function any number\n * of times: each call to `restarting()` creates a new, distinct \"restarting\n * job\" and function wrapper to go with it.\n *\n * @param task (Optional) The function to be wrapped. This can be any function:\n * the returned wrapper function will match its call signature exactly, including\n * overloads.  (So for example you could wrap the {@link start} API via\n * `restarting(start)`, to create a function you can pass job-start functions to.\n * When called, the function would cancel any outstanding job from a previous\n * call, and start the new one in its place.)\n *\n * @returns A function of identical type to the input function.  If no input\n * function was given, the returned function will just take one argument (a\n * zero-argument function optionally returning a {@link CleanupFn}).\n *\n * @category Jobs\n */\nexport function restarting<F extends AnyFunction>(task: F): F\nexport function restarting(): (task: () => OptionalCleanup<never>) => void\nexport function restarting<F extends AnyFunction>(task?: F): F {\n    const outer = getJob(), inner = makeJob<never>(outer), {end} = inner;\n    task ||= <F>((f: () => OptionalCleanup<never>) => { inner.must(f()); });\n    inner.asyncCatch(e => outer.asyncThrow(e));\n    return <F>function(this: any) {\n        inner.restart().must(outer.release(end));\n        const old = swapCtx(makeCtx(inner));\n        try { return task.apply(this, arguments as any); }\n        catch(e) { inner.restart(); throw e; }\n        finally { freeCtx(swapCtx(old)); }\n    };\n}\n","import { defer } from \"./defer.ts\";\nimport { type Source, IsStream, backpressure, Sink, Connection, Backpressure, throttle, Inlet, Producer } from \"./streams.ts\";\nimport { getJob, detached } from \"./tracking.ts\";\nimport { must, start } from \"./jobutils.ts\";\nimport { DisposeFn } from \"./types.ts\";\nimport { isCancel, isError, isUnhandled, markHandled, noop } from \"./results.ts\";\n\n/**\n * A function that emits events, with a .source they're emitted from\n *\n * Created using {@link emitter}.\n *\n * @category Types and Interfaces\n */\nexport interface Emitter<T> {\n    /** Call the emitter to emit events on its .source */\n    (val: T): void;\n    /** An event source that receives the events */\n    source: Producer<T>;\n    /** Close all current subscribers' connections */\n    end: () => void;\n    /** Close all current subscribers' connections with an error */\n    throw: (e: any) => void;\n};\n\n/**\n * Create an event source and a function to emit events on it\n *\n * (Note: you must specify the event type (e.g. `emitter<number>()`), since\n * there's nothing else to infer it from.)\n *\n * @returns A function that emits events, with a .source property they're\n * emitted on.\n *\n * @category Stream Producers\n */\nexport function emitter<T>(): Emitter<T> {\n    const emit = mockSource<T>();\n    emit.source = share(emit.source);\n    return emit;\n}\n\n/**\n * A stream that immediately closes\n *\n * @category Stream Producers\n */\nexport function empty(): Producer<never> {\n    return (_, conn) => (conn?.return(), IsStream);\n}\n\n/**\n * Convert an async iterable to an event source\n *\n * Each time the resulting source is subscribed to, it will emit an event for\n * each item output by the iterator, then end the stream.  Pause/resume is\n * supported.\n *\n * @category Stream Producers\n */\nexport function fromAsyncIterable<T>(iterable: AsyncIterable<T>): Producer<T> {\n    return (sink, conn=start(), inlet) => {\n        const ready = backpressure(inlet);\n        const iter = iterable[Symbol.asyncIterator]();\n        if (iter.return) must(() => iter.return());\n        return ready(next), IsStream;\n        function next() {\n            iter.next().then(({value, done}) => {\n                if (done) conn.return(); else ready(() => {\n                    if (sink(value), ready()) next(); else ready(next);\n                })\n            }, e => conn.throw(e));\n        }\n    }\n}\n\n/**\n * Create an event source from an element, window, or other event target\n *\n * You can manually override the expected event type using a type parameter,\n * e.g. `fromDomEvent<CustomEvent>(someTarget, \"custom-event\")`.\n *\n * @param target an HTMLElement, Window, Document, or other EventTarget.\n * @param type the name of the event to add a listener for\n * @param options a boolean capture option, or an object of event listener\n * options\n * @returns a source that can be subscribed or piped, issuing events from the\n * target of the specified type.\n *\n * @category Stream Producers\n */\nexport function fromDomEvent<T extends HTMLElement, K extends keyof HTMLElementEventMap>(\n    target: T, type: K, options?: boolean | AddEventListenerOptions\n): Producer<HTMLElementEventMap[K]>;\nexport function fromDomEvent<T extends Window, K extends keyof WindowEventMap>(\n    target: T, type: K, options?: boolean | AddEventListenerOptions\n): Producer<WindowEventMap[K]>;\nexport function fromDomEvent<T extends Document, K extends keyof DocumentEventMap>(\n    target: T, type: K, options?: boolean | AddEventListenerOptions\n): Producer<DocumentEventMap[K]>;\nexport function fromDomEvent<T extends Event>(\n    target: EventTarget, type: string, options?: boolean | AddEventListenerOptions\n): Producer<T>\nexport function fromDomEvent<T extends EventTarget, K extends string>(\n    target: T, type: K, options?: boolean | AddEventListenerOptions\n): Producer<Event> {\n    return (sink) => {\n        function push(v: Event) { sink(v); }\n        target.addEventListener(type, push, options);\n        must(() => target.removeEventListener(type, push, options));\n        return IsStream;\n    }\n}\n\n/**\n * Convert an iterable to a synchronous event source\n *\n * Each time the resulting source is subscribed to, it will emit an event for\n * each item in the iterator, then close the conduit.  Pause/resume is\n * supported.\n *\n * @category Stream Producers\n */\nexport function fromIterable<T>(iterable: Iterable<T>): Producer<T> {\n    return (sink, conn=start(), inlet) => {\n        const ready = backpressure(inlet);\n        const iter = iterable[Symbol.iterator]();\n        if (iter.return) must(() => iter.return());\n        return ready(loop), IsStream;\n        function loop() {\n            try {\n                for(;;) {\n                    const {value, done} = iter.next();\n                    if (done) return conn.return();\n                    if (sink(value), !ready()) return ready(loop);\n                }\n            } catch (e) {\n                conn.throw(e);\n            }\n        }\n    }\n}\n\n/**\n * Convert a Promise to an event source\n *\n * Each time the resulting source is subscribed to, it will emit an event for\n * the result of the promise, then close the conduit.  (Unless the promise is\n * rejected, in which case the conduit throws and closes each time the source is\n * subscribed.)  Non-native promises and non-promise values are converted using\n * Promise.resolve().\n *\n * @category Stream Producers\n */\nexport function fromPromise<T>(promise: Promise<T>|PromiseLike<T>|T): Producer<T> {\n    return (sink, conn) => {\n        const job = getJob();\n        Promise.resolve(promise).then(\n            v => void (job.result() || (sink(v), conn?.return())),\n            e => void (job.result() || conn?.throw(e))\n        )\n        return IsStream;\n    }\n}\n\n/**\n * Create an event source from an arbitrary subscribe/unsubscribe function\n *\n * The supplied \"subscribe\" function will be passed a 1-argument callback and\n * must return an unsubscribe function.  The callback should be called with\n * events of the appropriate type, and the unsubscribe function will be called\n * when the connection is closed.\n *\n * (Note: it's okay if the act of subscribing causes an immediate callback, as\n * the subscribe function will be called in a separate microtask.)\n *\n * @category Stream Producers\n */\nexport function fromSubscribe<T>(subscribe: (cb: (val: T) => void) => DisposeFn): Producer<T> {\n    return (sink) => {\n        const f = getJob().must(() => sink = noop);\n        return defer(() => f.must(subscribe(v => { sink(v); }))), IsStream;\n    }\n}\n\n/**\n * Create a source that emits a single given value\n *\n * @category Stream Producers\n */\nexport function fromValue<T>(val: T): Producer<T> {\n    return (sink, conn) => {\n        must(() => { sink = noop; conn = undefined; })\n        return defer(() => { sink(val); conn?.return(); }), IsStream;\n    }\n}\n\n/**\n * Create an event source that issues a number every `ms` milliseconds (starting\n * with 0 after the first interval passes).\n *\n * @category Stream Producers\n */\nexport function interval(ms: number): Producer<number> {\n    return (sink) => {\n        let idx = 0, id = setInterval(() => sink(idx++), ms);\n        return must(() => clearInterval(id)), IsStream;\n    }\n}\n\n/**\n * Create a dynamic source that is created each time it's subscribed\n *\n * @param factory A function returning a source of the desired type.  It will be\n * called whenever the lazy() stream is subscribed, and its result subscribed to.\n *\n * @returns A stream of the same type as the factory function returns\n *\n * @category Stream Producers\n */\nexport function lazy<T>(factory: () => Source<T>): Producer<T> {\n    return (sink, conn) => factory()(sink, conn)\n}\n\n/**\n * An {@link Emitter} with a ready() method, that only supports a single active\n * subscriber.  (Useful for testing stream operators and sinks.)\n *\n * Created using {@link mockSource}().\n *\n * @category Types and Interfaces\n */\nexport interface MockSource<T> extends Emitter<T> {\n    ready: Backpressure\n}\n\n/**\n * Like {@link emitter}, but with a ready() backpressure method.  It also only\n * supports a single active subscriber.  (Useful for testing stream operators\n * and sinks.)\n *\n * @category Stream Producers\n */\nexport function mockSource<T>(): MockSource<T> {\n    let write: Sink<T>, outlet: Connection, ready: Backpressure;\n    const emit: MockSource<T> = (val: T) => { if (write) write(val); };\n    emit.source = (sink, conn, inlet) => {\n        write = sink; outlet = conn; ready = backpressure(inlet);\n        must(() => write = outlet = ready = undefined);\n        return IsStream;\n    };\n    emit.end = () => outlet?.return();\n    emit.throw = (e: any) => outlet?.throw(e);\n    emit.ready = (cb?: () => any) => ready(cb);\n    return emit;\n}\n\n/**\n * A stream that never emits or closes\n *\n * @category Stream Producers\n */\nexport function never(): Producer<never> {\n    return () => IsStream;\n}\n\n/**\n * Wrap a source to allow multiple subscribers to the same underlying stream\n *\n * The input source will be susbcribed when the output has at least one\n * subscriber, and unsubscribed when the output has no subscribers.  The input\n * will be paused when any subscriber pauses, and will only be resumed when all\n * subscribers are unpaused.  All subscribers are closed or thrown if the input\n * source closes or throws.\n *\n * (Generally speaking, you should place the share call as late in your\n * pipelines as possible, if you use it at all.  It adds some overhead that is\n * wasted if the stream doesn't have multiple subscribers, and may be redundant\n * if an upstream source is already shared.  It's mainly useful if there is a\n * lot of mapping, filtering, or other complicated processing taking place\n * upstream of the share, and you know for a fact there will be enough\n * subscribers to make it a bottleneck.  You should probably also consider\n * putting some {@link slack}() either upstream or downstream of the share, if\n * the upstream supports backpressure.)\n *\n * @category Stream Operators\n */\nexport function share<T>(source: Source<T>): Producer<T> {\n    let uplink: Connection;\n    const\n        links = new Set<[sink: Sink<T>, conn: Connection]>,\n        inlets = new Map<Inlet, number>(),  // refcounts of incoming inlets\n        t = throttle(), // the actual onReady queue\n        multi: Inlet = {\n            // A multi-connection inlet that requires all downstreams to be ready\n            isOpen() { return !uplink?.result(); },\n            isReady() {\n                if (this.isOpen()) {\n                    for (const [i] of inlets) if (!i.isReady()) return (t.pause(), false);\n                    return true;\n                }\n                t.pause();\n                return false;\n            },\n            onReady(cb, job) {\n                if (this.isOpen()) {\n                    t.onReady(cb, job);\n                    for (const [i] of inlets) i.isReady() || i.onReady(produce, job);\n                }\n                return this;\n            }\n        }\n    ;\n    function produce() { multi.isReady() && t.resume(); }\n\n    return (sink, conn=start(), inlet) => {\n        const self: [Sink<T>, Connection] = [sink, conn];\n        links.add(self);\n        if (inlet) inlets.set(inlet, 1+(inlets.get(inlet) || 0));\n        conn.must(() => {\n            links.delete(self);\n            if (inlet) {\n                inlets.set(inlet, inlets.get(inlet)-1);\n                if (!inlets.get(inlet)) inlets.delete(inlet);\n            }\n            if (!links.size) uplink?.end();\n            else if (multi.isReady() && !t.isReady()) defer(produce);\n        });\n        if (links.size === 1) {\n            uplink = detached.connect(source, v => {\n                for(const [s, c] of links) try { s(v) } catch(e) { c.throw(e); };\n            }, multi).do(r => {\n                uplink = undefined;\n                if (isCancel(r)) return;\n                if (isUnhandled(r)) markHandled(r);\n                for(const [_, c] of links) isError(r) ? c.throw(r.err) : c.return();\n            })\n        }\n        return IsStream;\n    }\n}\n","import { Request, Suspend, Yielding} from \"./types.ts\"\nimport { to } from \"./async.ts\";\nimport { defer } from \"./defer.ts\";\nimport { Source, connect, throttle } from \"./streams.ts\";\nimport { reject, resolve, isError, markHandled } from \"./results.ts\";\nimport { start } from \"./jobutils.ts\";\nimport { getJob, isFunction } from \"./tracking.ts\";\n\n/**\n * The result type returned from calls to {@link Each}.next()\n *\n * @category Types and Interfaces\n */\nexport type EachResult<T> = {\n    /** The value provided by the source being iterated */\n    item: T;\n\n    /**\n     * A suspend callback that must be `yield`-ed before the next call to the\n     * iterator's .next() method. (That is, you must `yield next` it exactly once\n     * per loop pass.  See {@link each}() for more details.)\n     */\n    next: Suspend<void>;\n}\n\n/**\n * The iterable returned by `yield *` {@link each}()\n *\n * @category Types and Interfaces\n */\nexport type Each<T> = IterableIterator<EachResult<T>>\n\n/**\n * Asynchronously iterate over an event source\n *\n * Usage:\n *\n * ```ts\n * for (const {item: event, next} of yield *each(mouseMove)) {\n *     console.log(event.clientX, event.clientY);\n *     yield next;  // required exactly once per iteration, even/w continue!\n * }\n * ```\n *\n * each(eventSource) yield-returns an iterator of `{item, next}` pairs.  The\n * item is the data supplied by the event source, and `next` is a\n * {@link Suspend}\\<void\\> that advances the iterator to the next item.  It\n * *must* be yielded exactly once per loop iteration.  If you use `continue` to\n * shortcut the loop body, you must `yield next` *before* doing so.\n *\n * The for-loop will end if the source ends, errors, or is canceled.  The source\n * is paused while the loop body is running, and resumed when the `yield next`\n * happens.  If events arrive anyway (e.g. because the source doesn't support\n * pausing), they will be ignored unless you pipe the source through the\n * {@link slack}() operator to provide a buffer. If the for-loop is exited\n * early for any reason (or the iterator's `.return()` is called), the source is\n * unsubscribed and the iteration ended.\n *\n * @category Stream Consumers\n */\nexport function *each<T>(src: Source<T>): Yielding<Each<T>> {\n    let yielded = false, waiter: Request<void>;\n    const result: IteratorYieldResult<EachResult<T>> = {value: {item: undefined as T, next}, done: false};\n    const t = throttle(), conn = getJob().connect(src, v => {\n        t.pause();\n        if (!waiter || conn.result()) return;\n        result.value.item = v;\n        resolve(waiter, waiter = void 0);\n    }, t).do(r => {\n        // Prevent unhandled throws from here - it'll be seen by the next `yield\n        // next`, or in the next microtask if `yield next` is already running.\n        if (isError(r)) markHandled(r);\n        if (waiter) { defer(next.bind(null, waiter)); waiter = undefined; }\n    });\n\n    // Wait for first value to arrive (and get put in result) before returning the iterator\n    t.pause(); yield next;\n    return {\n        [Symbol.iterator]() { return this; },\n        next() {\n            if (!yielded) throw new Error(\"Must `yield next` in loop\");\n            yielded = false;\n            return result;\n        },\n        return() { conn.end(); return {value: undefined, done: true}; },\n    }\n    function next(r: Request<void>) {\n        if (waiter) throw new Error(\"Multiple `yield next` in loop\");\n        yielded = true;\n        if (conn.result()) {\n            result.value = undefined;\n            (result as IteratorResult<any>).done = true;\n            // We don't need to markHandled here - if it wasn't handled by the `do`,\n            // it's already too late.\n            isError(conn.result()) ? reject(r, conn.result().err) : resolve(r, void 0);\n        } else {\n            waiter = r;\n            t.resume();\n        }\n    }\n}\n\n/**\n * An object that can be waited on with `yield *until()`.\n *\n * @category Types and Interfaces\n */\nexport type Waitable<T> = UntilMethod<T> | Source<T> | Promise<T> | PromiseLike<T>;\n\n/**\n * An object that can be waited on with `yield *until()`, by calling its\n * \"uneventful.until\" method.\n *\n * @category Types and Interfaces\n */\nexport interface UntilMethod<T> {\n    \"uneventful.until\"(): Yielding<T>\n}\n\n/**\n * Wait for and return next value (or error) from a data source when processed\n * with `yield *` within a {@link Job}.\n *\n * @param source A {@link Waitable} data source, which can be any of:\n * - A {@link Signal} (in which case the job will resume when the value is\n *   truthy - perhaps immediately!)\n * - A {@link Source}\n * - A promise, or promise-like object with a `.then()` method\n * - An object with an `\"uneventful.until\"` method returning a {@link Yielding}\n *   (in which case the result will be the the result of that method)\n *\n * @returns a Yieldable that when processed with `yield *` in a job, will return\n * the triggered event, promise resolution, or signal value.  An error is thrown\n * if the promise rejects or the event stream throws or closes early, or the\n * signal throws.\n *\n * @category Scheduling\n */\nexport function until<T>(source: Waitable<T>): Yielding<T> {\n    if (isFunction((source as UntilMethod<T>)[\"uneventful.until\"])) {\n        return (source as UntilMethod<T>)[\"uneventful.until\"]();\n    }\n    if (isFunction((source as PromiseLike<T>)[\"then\"])) {\n        return to(source as PromiseLike<T>);\n    }\n    if (isFunction(source)) {\n        return start(job => {\n            connect(source, e => job.return(e))\n            .onError(e => job.throw(e))\n            .onValue(() => job.throw(new Error(\"Stream ended\")))\n        })\n    }\n    throw new TypeError(\"until(): must be signal, source, or then-able\");\n}\n","import { fromIterable } from \"./sources.ts\";\nimport { Connection, IsStream, Producer, Sink, Source, Transformer, backpressure, throttle } from \"./streams.ts\";\nimport { isValue, noop } from \"./results.ts\";\nimport { start } from \"./jobutils.ts\";\n\n/**\n * Output multiple streams' contents in order (from an array/iterable of stream\n * sources)\n *\n * Streams are concatenated in order -- note that this means they need to not be\n * infinite if any subsequent streams are to be processed!  The output is closed\n * when all sources are finished or if any source throws (in which case the\n * error propagates to the subscriber).\n *\n * Note: this function is just shorthand for {@link concatAll}({@link fromIterable}(*sources*)).\n *\n * @category Stream Operators\n */\nexport function concat<T>(sources: Source<T>[] | Iterable<Source<T>>): Producer<T> {\n    return concatAll(fromIterable(sources))\n}\n\n/**\n * Flatten a source of sources by emitting their contents in series\n *\n * Streams are concatenated in order -- note that this means they need to not be\n * infinite if any subsequent streams are to be processed!  The output is closed\n * when all sources are finished or if any source throws (in which case the\n * error propagates to the subscriber).\n *\n * If you want to switch to a new stream whenever a new source arrives from the\n * input stream, use {@link switchAll} instead.\n *\n * @category Stream Operators\n */\nexport function concatAll<T>(sources: Source<Source<T>>): Producer<T> {\n    return (sink, conn=start(), inlet) => {\n        let inner: Connection;\n        const inputs: Source<T>[] = [], t = throttle();\n        let outer = conn.connect(sources, s => {\n            inputs.push(s); startNext(); t.pause();\n        }, t).do(r => {\n            outer = undefined\n            inputs.length || inner || !isValue(r) || conn.return();\n        });\n        function startNext() {\n            inner ||= conn.connect(inputs.shift(), sink, inlet).do(r => {\n                inner = undefined;\n                inputs.length ? startNext() : (outer ? t.resume() : !isValue(r) || conn.return());\n            });\n        }\n        return IsStream;\n    }\n}\n\n/**\n * Map each value of a stream to a substream, then concatenate the resulting\n * substreams\n *\n * (This is just shorthand for `compose(map(mapper), concatAll)`.)\n *\n * If you want to switch to a new stream whenever a new event arrives on the\n * input stream, use {@link switchMap} instead.\n *\n * @category Stream Operators\n */\nexport function concatMap<T,R>(mapper: (v: T, idx: number) => Source<R>): Transformer<T,R> {\n    return src => concatAll(map(mapper)(src))\n}\n\n\n/**\n * Create a subset of a stream, based on a filter function (like Array.filter)\n *\n * The filter function receives the current index (zero-based) as well as the\n * current value.  If it returns truth, the value will be passed to the output,\n * otherwise it will be skipped.\n *\n * If the filter function is typed as a Typescript type guard (i.e. as returning\n * `v is SomeType`), then the resulting source will be typed as\n * Source<SomeType>.\n *\n * @category Stream Operators\n */\nexport function filter<T,R extends T>(filter: (v: T, idx: number) => v is R): Transformer<T,R>;\nexport function filter<T>(filter: (v: T, idx: number) => boolean): Transformer<T>;\nexport function filter<T>(filter: (v: T, idx: number) => boolean): Transformer<T> {\n    return src => (sink, conn, inlet) => {\n        let idx = 0; return src(v => filter(v, idx++) && sink(v), conn, inlet);\n    }\n}\n\n/**\n * Replace each value in a stream using a function (like Array.map)\n *\n * The mapping function receives the current index (zero-based) as well as the\n * current value.\n *\n * @category Stream Operators\n */\nexport function map<T,R>(mapper: (v: T, idx: number) => R): Transformer<T,R> {\n    return src => (sink, conn, inlet) => {\n        let idx = 0; return src(v => sink(mapper(v, idx++)), conn, inlet);\n    }\n}\n\n/**\n * Create an event source by merging an array or iterable of event sources.\n *\n * The resulting source issues events whenever any of the input sources do, and\n * closes once they all do (or throws if any of them do).\n *\n * @category Stream Operators\n */\nexport function merge<T>(sources: Source<T>[] | Iterable<Source<T>>): Producer<T> {\n    return mergeAll(fromIterable(sources));\n}\n\n/**\n * Create an event source by merging sources from a stream of event sources\n *\n * The resulting source issues events whenever any of the input sources do, and\n * closes once they all do (or throws if any of them do).\n *\n * @category Stream Operators\n */\nexport function mergeAll<T>(sources: Source<Source<T>>): Producer<T> {\n    return (sink, conn=start(), inlet) => {\n        const uplinks: Set<Connection> = new Set;\n        let outer = conn.connect(sources, (s) => {\n            const c = conn.connect(s, sink, inlet).do(r => {\n                uplinks.delete(c);\n                uplinks.size || outer || !isValue(r) || conn.return();\n            });\n            uplinks.add(c);\n        }).do(r => {\n            outer = undefined;\n            uplinks.size || !isValue(r) || conn.return();\n        });\n        return IsStream;\n    }\n}\n\n/**\n * Create an event source by merging sources created by mapping events to sources\n *\n * The resulting source issues events whenever any of the input sources do, and\n * closes once they all do (or throws if any of them do).\n *\n * (Note: this is just shorthand for `compose(map(mapper), mergeAll)`.)\n *\n * @category Stream Operators\n */\nexport function mergeMap<T,R>(mapper: (v: T, idx: number) => Source<R>): Transformer<T,R> {\n    return src => mergeAll(map(mapper)(src));\n}\n\n/**\n * Skip the first N items from a source\n *\n * (Equivalent to {@link skipWhile}() with a function that checks the index is < n.)\n *\n * @category Stream Operators\n */\nexport function skip<T>(n: number): Transformer<T> {\n    return skipWhile((_, i) => i<n);\n}\n\n/**\n * Skip items from a stream until another source produces a value.\n *\n * If the notifier closes without producing a value, the output will\n * be empty.  If the notifier throws, so will the output.\n *\n * @category Stream Operators\n */\nexport function skipUntil<T>(notifier: Source<any>): Transformer<T> {\n    return src => (sink, conn=start(), inlet) => {\n        let taking = false;\n        const c = conn.connect(notifier, () => { taking = true; c.end(); });\n        return src(v => taking && sink(v), conn, inlet);\n    }\n}\n\n/**\n * Skip items from a stream until a given condition is false, then output all\n * remaining items.  The condition function is not called again once it returns\n * false.\n *\n * @category Stream Operators\n */\nexport function skipWhile<T>(condition: (v: T, index: number) => boolean) : Transformer<T> {\n    return src => (sink, conn, inlet) => {\n        let idx = 0, met = false;\n        return src(v => (met ||= !condition(v, idx++)) && sink(v), conn, inlet);\n    };\n}\n\n/**\n * Add job control and buffering to a stream\n *\n * This lets you block events from a stream that can't be paused, or allow for\n * some slack for a source that can sometimes get ahead of its sink.\n *\n * @param size The number of items to buffer when the sink is busy (i.e., the\n * sink is running or the connection is paused).  If positive, the most recent N\n * items are kept (a \"sliding\" buffer), and if negative, the oldest N item are\n * kept (a \"dropping\" buffer). If zero, no items are buffered, and items are\n * dropped if received while the sink is busy.\n *\n * @param dropped Optional: a callback that will receive items when they are\n * dropped.  (Useful for testing, performance instrumentation, error logging,\n * etc.)\n *\n * @category Stream Operators\n */\nexport function slack<T>(size: number, dropped: Sink<T> = noop): Transformer<T> {\n    const max = Math.abs(size);\n    return src => (sink, conn=start(), inlet) => {\n        const buffer: T[] = [], ready = backpressure(inlet);\n        let paused = false, draining = false;\n        const t = throttle();\n        conn.connect(src, v => {\n            buffer.push(v);\n            if (!draining && ready()) return drain();\n            while (buffer.length > max) { dropped((size < 0) ? buffer.pop() : buffer.shift()); }\n            if (buffer.length === max) { t.pause(); paused = true; }\n            if (buffer.length) ready(drain);\n        }, t).do(r => {\n            if (isValue(r)) conn.return();\n        });\n\n        function drain() {\n            draining = true;\n            try {\n                while(buffer.length) {\n                    sink(buffer.shift());\n                    if (paused && ready()) {\n                        paused = false; t.resume();\n                    }\n                    if (buffer.length && !ready()) {\n                        return ready(drain);\n                    }\n                }\n            } finally {\n                draining = false;\n            }\n        }\n        return IsStream;\n    }\n}\n\n/**\n * Flatten a source of sources by emitting their contents until a new one\n * arrives.\n *\n * As each source arrives from the input stream, its values are sent to the\n * output, closing the previous one (if any).  The output is closed when both\n * the input stream and the most-recently-arrived stream are finished.  Errors\n * propagate to the output if any stream throws.\n *\n * (If you want to send *all* the values of each stream to the output without\n * stopping, input stream, use {@link concatAll} or {@link mergeAll} instead.)\n *\n * @category Stream Operators\n */\nexport function switchAll<T>(sources: Source<Source<T>>): Producer<T> {\n    return (sink, conn=start(), inlet) => {\n        let inner: Connection;\n        let outer = conn.connect(sources, s => {\n            inner?.end();\n            inner = conn.connect(s, sink, inlet).do(r => {\n                inner = undefined;\n                outer || !isValue(r) || conn.return();\n            });\n        }).do(r => {\n            outer = undefined;\n            inner || !isValue(r) || conn.return();\n        });\n        return IsStream;\n    }\n}\n\n/**\n * Map each value of a stream to a substream, then output the resulting\n * substreams until a new value arrives.\n *\n * (This is just shorthand for `compose(map(mapper),`{@link switchAll `switchAll)`}.)\n *\n * (If you want to send *all* the values of each stream to the output without\n * stopping, input stream, use {@link concatMap} or {@link mergeMap} instead.)\n *\n * @category Stream Operators\n */\nexport function switchMap<T,R>(mapper: (v: T, idx: number) => Source<R>): Transformer<T,R> {\n    return src => switchAll(map(mapper)(src))\n}\n\n/**\n * Take the first N items from a source\n *\n * (Equivalent to {@link takeWhile}() with a function that checks the index is < n.)\n *\n * @category Stream Operators\n */\nexport function take<T>(n: number): Transformer<T> {\n    return takeWhile((_, i) => i<n);\n}\n\n/**\n * Take items from a source until another source produces a value.\n *\n * If the notifier closes without producing a value, this will output all\n * elements of the input.  But if the notifier throws, so will the output.\n *\n * @category Stream Operators\n */\nexport function takeUntil<T>(notifier: Source<any>): Transformer<T> {\n    return src => (sink, conn=start(), inlet) => {\n        conn.connect(notifier, () => conn.return());\n        return src(sink, conn, inlet);\n    }\n}\n\n/**\n * Take items from a stream until a given condition is false, then close the\n * output.  The condition function is not called again after it returns false.\n *\n * If the condition function is typed as a Typescript type guard (i.e. as\n * returning `v is SomeType`), then the resulting source will be typed as\n * Source<SomeType>.\n *\n * @category Stream Operators\n */\nexport function takeWhile<T,R extends T>(condition: (v: T, idx: number) => v is R): Transformer<T,R>;\nexport function takeWhile<T>(condition: (v: T, idx: number) => boolean): Transformer<T>;\nexport function takeWhile<T>(condition: (v: T, index: number) => boolean) : Transformer<T> {\n    return src => (sink, conn, inlet) => {\n        let idx = 0;\n        return src(v => condition(v, idx++) ? sink(v) : conn?.return(), conn, inlet);\n    };\n}\n"],"names":[],"mappings":"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"}