uneventful 0.0.6 → 0.0.8

package/README.md

@@ -146,7 +146,7 @@ Second, you can also *turn streams into signals*, by passing them to `cached()`.
 But wait, there's more: Unlike most libraries' "effects", Uneventful's rules *start asynchronously* and can be *independently scheduled*.  This means, for example, that it's easy to make rules that run only in, say, animation frames:
 
 ```ts
-import { rule } from "uneventful";
+import { rule } from "uneventful/signals";
 
 /**
  * An alternate version of rule() that runs in animation frames
@@ -185,7 +185,7 @@ So far, we've highlighted just a handful of Uneventful's coolest and most impact
 - Play well with state charts, or ignore the charts and just express interactivity directly in code!
 - Easily control the *timing* of operations, building advanced debouncing and sampling with basic async operators like `sleep()` or by defining rules tied to a scheduler
 
-And at the same time, this has actually been a pretty superficial tour: we haven't gotten into a lot of things like how to actually *use* signals or abort jobs or any other details, really.  For those, you'll currently have to dig through the [API Reference](https://uneventful.js.org/modules.html), but there should be more tutorials and guides as time goes on.
+And at the same time, this has actually been a pretty superficial tour: we haven't gotten into a lot of things like how to actually *use* signals or abort jobs or any other details, really.  For those, you'll currently have to dig through the [API Reference](https://uneventful.js.org/modules/uneventful.html), but there should be more tutorials and guides as time goes on.
 
 (Also, at some point you'll be able to use the "Calibre Connect" Obsidian plugin I'm working on as an example of how to use these things to create responsive search and tame Electron WebFrames while keeping track of whether a connection to a remote server is available, handling logins and background processes and integrating a plugin to a larger application, not to mention controlling lots of features via settings.)
 

package/dist/{call-or-wait-DHkBd_bM.mjs → call-or-wait-COAmx32w.mjs}

@@ -1,6 +1,4 @@
-import { isFunction, apply } from './utils.mjs';
-
-let defer = typeof queueMicrotask === "function" ? queueMicrotask : /* @__PURE__ */ ((p) => (cb) => p.then(cb))(Promise.resolve());
+import { b as batch, d as defer, i as isFunction, G as GeneratorBase, c as apply } from './utils-P0JEpWXG.mjs';
 
 function resolve(request, val) {
   request("next", val);
@@ -94,6 +92,12 @@ const catchers = /* @__PURE__ */ new WeakMap(), defaultCatch = (e) => {
 };
 const nullCtx = makeCtx();
 const owners = /* @__PURE__ */ new WeakMap();
+const pulls = /* @__PURE__ */ batch((pulls2) => {
+  for (const conn of pulls2) {
+    pulls2.delete(conn);
+    conn.doPull();
+  }
+}, defer);
 
 function chain() {
   return link(0, void 0, void 0);
@@ -181,7 +185,7 @@ function unlinker(chain2, node) {
 }
 
 function getJob() {
-  const { job } = current;
+  const job = current.job || current.cell?.getJob();
   if (job)
     return job;
   throw new Error("No job is currently active");
@@ -335,9 +339,22 @@ class _Job {
       if (init)
         result = job.run(init, job);
       if (result != null) {
-        if (result instanceof _Job) {
+        if (isFunction(result)) {
+          job.must(result);
+        } else if (result instanceof GeneratorBase) {
+          job.run(runGen, result, job);
+        } else if (result instanceof _Job) {
           if (result !== job)
             result.do((res) => propagateResult(job, res));
+        } else if (result instanceof Promise) {
+          result.then(
+            (v) => {
+              job.result() || job.return(v);
+            },
+            (e) => {
+              job.result() || job.throw(e);
+            }
+          );
         } else if (isFunction(result.then)) {
           result.then(
             (v) => {
@@ -347,11 +364,8 @@ class _Job {
               job.result() || job.throw(e);
             }
           );
-          return job;
         } else if (isFunction(result[Symbol.iterator]) && typeof result !== "string") {
           job.run(runGen, result, job);
-        } else if (isFunction(result)) {
-          job.must(result);
         } else {
           throw new TypeError("Invalid value/return for start()");
         }
@@ -508,88 +522,6 @@ function runGen(g, job) {
   }
 }
 
-class RunQueue {
-  constructor(sched, reap) {
-    this.sched = sched;
-    this.reap = reap;
-    this._flags = 0 /* Unset */;
-    this.q = /* @__PURE__ */ new Set();
-    this._run = () => {
-      this._flags &= ~2 /* Scheduled */;
-      this.flush();
-    };
-    /** Run all pending items */
-    this.flush = () => {
-      if (this._flags & 1 /* Running */)
-        return;
-      const { q: queue } = this;
-      if (!queue.size)
-        return;
-      this._flags |= 1 /* Running */;
-      try {
-        this.reap(queue);
-      } finally {
-        this._flags &= ~1 /* Running */;
-        !queue.size || this._flags & 2 /* Scheduled */ || this._sched();
-      }
-    };
-  }
-  /** Is this queue currently running? */
-  isRunning() {
-    return !!(this._flags & 1 /* Running */);
-  }
-  /** Is this queue currently empty? */
-  isEmpty() {
-    return !this.q.size;
-  }
-  add(subject) {
-    this.q.size || this._flags & (1 /* Running */ | 2 /* Scheduled */) || this._sched();
-    this.q.add(subject);
-  }
-  delete(subject) {
-    this.q.delete(subject);
-  }
-  has(subject) {
-    return this.q.has(subject);
-  }
-  _sched() {
-    this._flags |= 2 /* Scheduled */;
-    this.sched(this._run);
-  }
-}
-var currentRule;
-var currentQueue;
-const ruleQueues = /* @__PURE__ */ new WeakMap();
-const ruleStops = /* @__PURE__ */ new WeakMap();
-class RuleQueue extends RunQueue {
-  constructor(sched) {
-    super(sched, function(q) {
-      if (currentQueue)
-        return;
-      currentQueue = this;
-      try {
-        for (currentRule of q) {
-          currentRule.catchUp();
-          q.delete(currentRule);
-        }
-      } finally {
-        currentQueue = currentRule = void 0;
-      }
-    });
-  }
-}
-function ruleQueue(scheduleFn = defer) {
-  ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, new RuleQueue(scheduleFn));
-  return ruleQueues.get(scheduleFn);
-}
-const defaultQ = /* @__PURE__ */ ruleQueue(defer);
-const pulls = /* @__PURE__ */ new RunQueue(defer, (pulls2) => {
-  for (const conn of pulls2) {
-    pulls2.delete(conn);
-    conn.doPull();
-  }
-});
-
 function backpressure(inlet = defaultInlet) {
   const job = getJob();
   return (cb) => {
@@ -769,5 +701,5 @@ function mustBeSourceOrSignal() {
   throw new TypeError("not a source or signal");
 }
 
-export { CancelError as A, nativePromise as B, CancelResult as C, makeJob as D, ErrorResult as E, pipe as F, compose as G, into as H, IsStream as I, isJobActive as J, timeout as K, abortSignal as L, task as M, swapCtx as N, nullCtx as O, ruleQueue as P, defaultQ as Q, currentRule as R, makeCtx as S, ruleStops as T, freeCtx as U, ValueResult as V, rejecter as a, resolve as b, backpressure as c, defer as d, detached as e, isUnhandled as f, getJob as g, markHandled as h, isCancel as i, isError as j, connect as k, fulfillPromise as l, must as m, noop as n, callOrWait as o, restarting as p, current as q, resolver as r, start as s, throttle as t, mustBeSourceOrSignal as u, isValue as v, reject as w, isHandled as x, getResult as y, propagateResult as z };
-//# sourceMappingURL=call-or-wait-DHkBd_bM.mjs.map
+export { nativePromise as A, makeJob as B, CancelResult as C, pipe as D, ErrorResult as E, compose as F, into as G, isJobActive as H, IsStream as I, timeout as J, abortSignal as K, task as L, swapCtx as M, nullCtx as N, makeCtx as O, freeCtx as P, ValueResult as V, rejecter as a, resolve as b, backpressure as c, detached as d, isUnhandled as e, markHandled as f, getJob as g, isError as h, isCancel as i, connect as j, fulfillPromise as k, callOrWait as l, must as m, noop as n, restarting as o, current as p, mustBeSourceOrSignal as q, resolver as r, start as s, throttle as t, isValue as u, reject as v, isHandled as w, getResult as x, propagateResult as y, CancelError as z };
+//# sourceMappingURL=call-or-wait-COAmx32w.mjs.map

package/dist/call-or-wait-COAmx32w.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-or-wait-COAmx32w.mjs","sources":["../src/results.ts","../src/ambient.ts","../src/internals.ts","../src/chains.ts","../src/tracking.ts","../src/streams.ts","../src/jobutils.ts","../src/call-or-wait.ts"],"sourcesContent":["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 { makeCtx } from \"./ambient.ts\";\nimport { batch } from \"./scheduling.ts\";\nimport { defer } from \"./defer.ts\";\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\n/** A null context (no job/observer) for cleanups to run in */\nexport const nullCtx = makeCtx();\n\n/** Jobs' owners (parents) - uses a map so child jobs can't directly access them */\nexport const owners = new WeakMap<Job, Job>();\n\n/** Streams that need resuming  */\nexport const pulls = /* @__PURE__ */ batch<{ doPull(): void; }>(pulls => {\n    for (const conn of pulls) { pulls.delete(conn); conn.doPull(); }\n}, defer);\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 = undefined;\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, nullCtx, owners } 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 { Stream, Sink, Inlet, Connection } from \"./streams.ts\";\nimport { GeneratorBase, apply } from \"./utils.ts\";\nimport { isFunction } from \"./utils.ts\";\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.job || current.cell?.getJob();\n    if (job) return job as Job<T>;\n    throw new Error(\"No job is currently active\");\n}\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\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>(parent?: Job, stop?: CleanupFn): Job<T> {\n        const job = new _Job<T>;\n        if (parent || stop) {\n            job.must((parent ||= getJob()).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> | OptionalCleanup;\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 (isFunction(result)) {\n                    job.must(result);\n                } else if (result instanceof GeneratorBase) {\n                    job.run(runGen<T>, result as Yielding<T>, job);\n                } else if (result instanceof _Job) {\n                    if (result !== job) result.do(res => propagateResult(job, res));\n                } else if (result instanceof Promise) {\n                    // Duplicated because this will be monomorphic or low-poly,\n                    // but next branch will always be megamorphic\n                    (result as Promise<T>).then(\n                        v => { job.result() || job.return(v); },\n                        e => { job.result() || job.throw(e); }\n                    );\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                } 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: Stream<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(...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 apply(fn, this, arguments); } finally { freeCtx(swapCtx(old)); }\n        }\n    }\n\n    must(cleanup?: OptionalCleanup) {\n        if (isFunction(cleanup)) push(this._chain(), cleanup);\n        return this;\n    }\n\n    release(cleanup: CleanupFn): () => 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 The job to get a native promise for.\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: Job<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>(parent?: Job, stop?: CleanupFn) => 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 such `detached` child jobs *must* exit themselves or be stopped\n * explicitly from outside, or else they may \"run\" forever, never running their\n * cleanup callbacks.  Unlike other jobs, they don't end when their parent does\n * because the `detached` job never \"ends\".)\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 { pulls } from \"./internals.ts\";\nimport { DisposeFn, Job } from \"./types.ts\";\nimport { getJob } from \"./tracking.ts\";\nimport { current } from \"./ambient.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 connection 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 Source 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 interface Source<T> {\n    /** Subscribe sink to receive values */\n    (sink: Sink<T>, conn?: Connection, inlet?: Throttle | Inlet): typeof IsStream;\n}\n\n/**\n * An uneventful stream is either a {@link Source} or a {@link SignalSource}.\n * (Signals actually implement the {@link Source} interface as an overload, but\n * TypeScript gets confused about that sometimes, so we generally declare our\n * stream *inputs* as `Stream<T>` and our stream *outputs* as {@link Source}, so\n * that TypeScript knows what's what.\n *\n * @category Types and Interfaces\n */\nexport type Stream<T> = Source<T> | SignalSource<T>;\n\n/**\n * The call signatures implemented by signals.  (They can be used as sources, or\n * called with no arguments to return a value.)\n *\n * This type is needed because TypeScript won't infer the overloads of\n * {@link Signal} correctly otherwise. (Specifically, it won't allow it to be\n * used as a zero-agument function.)\n *\n * @category Types and Interfaces\n*/\nexport type SignalSource<T> = Source<T> & {\n    /** A signal object can be called to get its current value */\n    (): T\n}\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 Stream}.\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 stream 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: Stream<T>) => Source<V>;\n\ntype Flush = () => any\n\n\n/**\n * Subscribe a sink to a stream, returning a nested job. (Shorthand for\n * .{@link Job.connect connect}(...) on the active job.)\n *\n * @param src An event source or signal\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: Stream<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 connection 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","import { current, freeCtx, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { getJob, makeJob } from \"./tracking.ts\";\nimport { AnyFunction, CleanupFn, Job, OptionalCleanup, StartFn, StartObj, Yielding } from \"./types.ts\";\nimport { apply } from \"./utils.ts\";\n\n/**\n * Add a cleanup function to the active job. Non-function values are ignored.\n * Equivalent to calling .{@link Job.must must}() on the current job.  (See\n * {@link Job.must}() for more details.)\n *\n * @category Jobs\n */\nexport function must(cleanup?: OptionalCleanup): void {\n    getJob().must(cleanup);\n}\n\n/**\n * Start a nested job within the currently-active job.  (Shorthand for\n * calling .{@link Job.start start}(...) on the active job.)\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.  A returned function will be added to the job via `must()`.\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 while\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.must(() => { 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) => 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) => { inner.must(f()); });\n    inner.asyncCatch(e => outer.asyncThrow(e));\n    return <F>function(this: ThisParameterType<F>) {\n        inner.restart().must(outer.release(end));\n        const old = swapCtx(makeCtx(inner));\n        try { return apply(task, this, arguments); }\n        catch(e) { inner.restart(); throw e; }\n        finally { freeCtx(swapCtx(old)); }\n    };\n}\n\n/**\n * Wrap an argument-taking function so it will run in (and returns) a new Job\n * when called.\n *\n * This lets you avoid the common pattern of needing to write your functions or\n * methods like this:\n *\n * ```ts\n * function outer(arg1, arg2) {\n *     return start(function*() {\n *         // ...\n *     })\n * }\n * ```\n * and instead write them like this:\n * ```ts\n * const outer = task(function *(arg1, arg2) {\n *     // ...\n * });\n * ```\n * or this:\n * ```ts\n * class Something {\n *     ⁣⁣@task  // auto-detects TC39 or legacy decorators\n *     *someMethod(arg1): Yielding<SomeResultType> {\n *         // ...\n *     }\n * }\n * ```\n *\n * Important: if the wrapped function or method has overloads, the resulting\n * function type will be based on the **last** overload, because TypeScript (at\n * least as of 5.x) is still not very good at dealing with higher order\n * generics, especially if overloads are involved.\n *\n * Also note that TypeScript doesn't allow decorators to change the calling\n * signature or return type of a method, so even though the above method will\n * return a {@link Job}, TypeScript will only see it as a {@link Yielding}.\n *\n * This is fine if all you're going to do is `yield *` it to wait for the\n * result, but if you need to use any job-specific methods on it, you'll have to\n * pass it through {@link start} to have TypeScript treat it as an actual job.\n * (Luckily, start() has a fast path to return the original job if it's passed a\n * job, so you won't actually create a new job by doing this.)\n *\n * @param fn The function to wrap. A function returning a generator or\n * promise-like object (i.e., a {@link StartObj}).\n *\n * @returns A wrapped version of the function that passes through its arguments\n * to the original function, while running it in a new job.  (The wrapper also\n * returns the job.)\n *\n * @category Jobs\n */\nexport function task<T, A extends any[], C>(fn: (this: C, ...args: A) => StartObj<T>): (this: C, ...args: A) => Job<T>;\n\n/** @hidden TC39 Decorator protocol */\nexport function task<T, A extends any[], C>(\n    fn: (this: C, ...args: A) => StartObj<T>, ctx: {kind: \"method\"}\n): (this: C, ...args: A) => Job<T>;\n\n/** @hidden Legacy Decorator protocol */\nexport function task<T, A extends any[], C, D extends {value?: (this:C, ...args: A) => StartObj<T>}>(\n    clsOrProto: any, name: string|symbol, desc: D\n): D\n\nexport function task<T, A extends any[], C, D extends {value?: (this:C, ...args: A) => StartObj<T>}>(\n    fn: (this: C, ...args: A) => StartObj<T>, _ctx?: any, desc?: D\n): D | ((this: C, ...args: A) => Job<T>) {\n    if (desc) return {...desc, value: task(desc.value)};\n    return function (this: C, ...args: A) {\n        return start<T>(fn.bind(this, ...args as any[]));\n    }\n}\n","import { Job, Yielding } from \"./types.ts\";\nimport { start } from \"./jobutils.ts\";\nimport { isValue, isError, markHandled } from \"./results.ts\";\nimport { isFunction } from \"./utils.ts\";\nimport { connect, Source } from \"./streams.ts\";\n\nexport function callOrWait<T>(\n    source: any, method: string, handler: (job: Job<T>, val: T) => void, noArgs: (f?: any) => Yielding<T> | void\n) {\n    if (source && isFunction(source[method])) return source[method]() as Yielding<T>;\n    if (isFunction(source)) return (\n        source.length === 0 ? noArgs(source) : false\n    ) || start<T>(job => {\n        connect(source as Source<T>, v => handler(job, v)).do(r => {\n            if (isValue(r)) job.throw(new Error(\"Stream ended\"));\n            else if (isError(r)) job.throw(markHandled(r));\n        });\n    });\n    mustBeSourceOrSignal();\n}\n\nexport function mustBeSourceOrSignal() { throw new TypeError(\"not a source or signal\"); }\n"],"names":[],"mappings":";;AAAO,SAAS,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE;AACtC,EAAE,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AACvB,CAAC;AACM,SAAS,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE;AACxC,EAAE,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;AACnC,CAAC;AACM,SAAS,QAAQ,CAAC,OAAO,EAAE;AAClC,EAAE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AACpC,CAAC;AACM,SAAS,QAAQ,CAAC,OAAO,EAAE;AAClC,EAAE,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;AAC7C,CAAC;AACM,SAAS,IAAI,GAAG;AACvB,CAAC;AACD,SAAS,QAAQ,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE;AAChC,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAC1B,CAAC;AACW,MAAC,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;AACvD,SAAS,WAAW,CAAC,GAAG,EAAE;AACjC,EAAE,OAAO,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAC/B,CAAC;AACM,SAAS,WAAW,CAAC,GAAG,EAAE;AACjC,EAAE,OAAO,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC;AACxC,CAAC;AACM,SAAS,QAAQ,CAAC,GAAG,EAAE;AAC9B,EAAE,OAAO,GAAG,KAAK,YAAY,CAAC;AAC9B,CAAC;AACM,SAAS,OAAO,CAAC,GAAG,EAAE;AAC7B,EAAE,OAAO,GAAG,GAAG,GAAG,CAAC,EAAE,KAAK,MAAM,GAAG,KAAK,CAAC;AACzC,CAAC;AACM,SAAS,OAAO,CAAC,GAAG,EAAE;AAC7B,EAAE,OAAO,GAAG,GAAG,GAAG,CAAC,EAAE,KAAK,OAAO,GAAG,KAAK,CAAC;AAC1C,CAAC;AACM,SAAS,WAAW,CAAC,GAAG,EAAE;AACjC,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC;AAC5C,CAAC;AACM,SAAS,SAAS,CAAC,GAAG,EAAE;AAC/B,EAAE,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,GAAG,KAAK,IAAI,CAAC;AAC1C,CAAC;AACM,SAAS,WAAW,CAAC,GAAG,EAAE;AACjC,EAAE,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC;AACjB,EAAE,OAAO,GAAG,CAAC,GAAG,CAAC;AACjB,CAAC;AACM,SAAS,SAAS,CAAC,GAAG,EAAE;AAC/B,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC;AAClB,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC;AACnB,EAAE,GAAG,CAAC,EAAE,CAAC;AACT,EAAE,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK;AAC9B,IAAI,MAAM,CAAC,CAAC;AACZ,GAAG,EAAE,GAAG,CAAC,CAAC;AACV,CAAC;AACM,SAAS,cAAc,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE;AACvD,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC;AAClB,IAAI,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9B,OAAO,IAAI,QAAQ,CAAC,GAAG,CAAC;AACxB,IAAI,OAAO,CAAC,IAAI,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC;AAC7C;AACA,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACtB,CAAC;AACM,SAAS,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE;AAC1C,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;AACnB,IAAI,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;AACnE,CAAC;AACM,MAAM,WAAW,SAAS,KAAK,CAAC;AACvC;;AChEU,IAAC,OAAO,GAAG,OAAO,GAAG;AACxB,SAAS,OAAO,CAAC,MAAM,EAAE;AAChC,EAAE,MAAM,GAAG,GAAG,OAAO,CAAC;AACtB,EAAE,OAAO,GAAG,MAAM,CAAC;AACnB,EAAE,OAAO,GAAG,CAAC;AACb,CAAC;AACD,IAAI,QAAQ,GAAG,EAAE,CAAC;AACX,SAAS,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE;AACnC,EAAE,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,EAAE;AACnC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC;AAC7B,IAAI,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;AAChB,IAAI,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;AAClB,IAAI,OAAO,CAAC,CAAC;AACb,GAAG;AACH,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;AACvB,CAAC;AACM,SAAS,OAAO,CAAC,CAAC,EAAE;AAC3B,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;AACxB,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACnB;;AChBO,MAAM,QAAQ,mBAAmB,IAAI,OAAO,EAAE,EAAE,YAAY,GAAG,CAAC,CAAC,KAAK;AAC7E,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC,CAAC;AACU,MAAC,OAAO,GAAG,OAAO,GAAG;AAC1B,MAAM,MAAM,mBAAmB,IAAI,OAAO,EAAE,CAAC;AAC7C,MAAM,KAAK,mBAAmB,KAAK,CAAC,CAAC,MAAM,KAAK;AACvD,EAAE,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE;AAC7B,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACxB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;AAClB,GAAG;AACH,CAAC,EAAE,KAAK,CAAC;;ACbF,SAAS,KAAK,GAAG;AACxB,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AACjC,CAAC;AACM,SAAS,OAAO,CAAC,CAAC,EAAE;AAC3B,EAAE,OAAO,CAAC,CAAC,CAAC;AACZ,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AACnB,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;AACf,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACf,CAAC;AACM,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE;AAC9B,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACR,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAClB,CAAC;AAKM,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE;AAC3B,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACR,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AACM,SAAS,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE;AAC7B,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACR,EAAE,OAAO,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC;AACM,SAAS,OAAO,CAAC,CAAC,EAAE;AAC3B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACzB,CAAC;AACM,SAAS,IAAI,CAAC,CAAC,EAAE;AACxB,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACrB,CAAC;AACM,SAAS,GAAG,CAAC,CAAC,EAAE;AACvB,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC;AACb,IAAI,OAAO,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1B,CAAC;AAKD,MAAM,IAAI,CAAC;AACX,EAAE,WAAW,GAAG;AAChB;AACA,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;AAClB;AACA,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;AAClB;AACA,IAAI,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;AACpB;AACA,IAAI,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;AACpB,GAAG;AACH,CAAC;AACD,IAAI,IAAI,CAAC;AACT,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;AACvB,EAAE,IAAI,IAAI,GAAG,IAAI,CAAC;AAClB,EAAE,IAAI,IAAI,EAAE;AACZ,IAAI,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC;AAClB,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;AACvB,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;AACvB,GAAG,MAAM;AACT,IAAI,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;AACtB,IAAI,IAAI,CAAC;AACT,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AACjB,IAAI,IAAI,CAAC;AACT,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AACjB,GAAG;AACH,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;AACb,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAClB,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;AAClB,EAAE,OAAO,IAAI,CAAC;AACd,CAAC;AACD,SAAS,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE;AACzB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACR,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;AAC7B,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAChC,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAChC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;AACpC,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC;AAChB,EAAE,IAAI,GAAG,IAAI,CAAC;AACd,EAAE,IAAI,CAAC;AACP,IAAI,CAAC,EAAE,CAAC;AACR,EAAE,OAAO,CAAC,CAAC;AACX,CAAC;AACD,SAAS,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE;AAChC,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,KAAK,MAAM;AAC3B,IAAI,IAAI,CAAC,EAAE;AACX,MAAM,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;AACtB,QAAQ,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC7B,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC;AACjC,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,OAAO,CAAC,CAAC;AACX;;ACnFO,SAAS,MAAM,GAAG;AACzB,EAAE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;AACpD,EAAE,IAAI,GAAG;AACT,IAAI,OAAO,GAAG,CAAC;AACf,EAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;AAChD,CAAC;AACD,SAAS,SAAS,CAAC,GAAG,EAAE;AACxB,EAAE,OAAO,CAAC,EAAE,KAAK;AACjB,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC;AACtC,GAAG,CAAC;AACJ,CAAC;AACD,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE;AAC5B,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC;AAClB,IAAI,IAAI;AACR,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,KAAK,CAAC,OAAO,CAAC,EAAE;AAChB,MAAM,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAC7B,KAAK;AACL,EAAE,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;AACtB,EAAE,OAAO,KAAK,CAAC,CAAC;AAChB,CAAC;AACD,IAAI,SAAS,mBAAmB,IAAI,GAAG,EAAE,CAAC;AAC1C,MAAM,IAAI,CAAC;AACX,EAAE,WAAW,GAAG;AAChB,IAAI,IAAI,CAAC,GAAG,GAAG,MAAM;AACrB,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,KAAK,YAAY,EAAE,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC;AAC/D,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;AACnC,QAAQ,OAAO;AACf,MAAM,MAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAExD,MAAM,IAAI,CAAC,EAAE;AACb,QAAQ,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC5B,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC;AACtB,QAAQ,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AACrC,MAAM,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC1B,MAAM,IAAI,EAAE,EAAE;AACd,QAAQ,OAAO,CAAC,GAAG,CAAC,CAAC;AACrB,QAAQ,OAAO;AACf,OAAO;AACP,MAAM,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC7B,MAAM,KAAK,MAAM,IAAI,IAAI,SAAS,EAAE;AACpC,QAAQ,IAAI,IAAI,CAAC,IAAI;AACrB,UAAU,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACtD,QAAQ,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC/B,QAAQ,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;AACnC,UAAU,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAC9C,OAAO;AACP,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,KAAK,CAAC;AACN,IAAI,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;AACxB;AACA,IAAI,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC;AACvB,GAAG;AACH;AACA,EAAE,OAAO,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE;AAC9B,IAAI,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;AAC3B,IAAI,IAAI,MAAM,IAAI,IAAI,EAAE;AACxB,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,EAAE,EAAE,OAAO,CAAC,IAAI,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAC9B,KAAK;AACL,IAAI,OAAO,GAAG,CAAC;AACf,GAAG;AACH,EAAE,EAAE,CAAC,OAAO,EAAE;AACd,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC,CAAC;AACpC,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,OAAO,CAAC,EAAE,EAAE;AACd,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK;AAC1B,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC;AACpB,QAAQ,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3B,KAAK,CAAC,CAAC;AACP,GAAG;AACH,EAAE,OAAO,CAAC,EAAE,EAAE;AACd,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK;AAC1B,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC;AACpB,QAAQ,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAClB,KAAK,CAAC,CAAC;AACP,GAAG;AACH,EAAE,QAAQ,CAAC,EAAE,EAAE;AACf,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK;AAC1B,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC;AACrB,QAAQ,EAAE,EAAE,CAAC;AACb,KAAK,CAAC,CAAC;AACP,GAAG;AACH,EAAE,MAAM,GAAG;AACX,IAAI,OAAO,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,KAAK,CAAC,CAAC;AAC7E,GAAG;AACH,EAAE,KAAK,MAAM,CAAC,WAAW,CAAC,GAAG;AAC7B,IAAI,OAAO,KAAK,CAAC;AACjB,GAAG;AACH,EAAE,OAAO,GAAG;AACZ,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,SAAS,CAAC,IAAI,EAAE;AACvC,MAAM,MAAM,GAAG,GAAG,SAAS,CAAC;AAC5B,MAAM,SAAS,mBAAmB,IAAI,GAAG,EAAE,CAAC;AAC5C,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;AACjB,MAAM,SAAS,GAAG,GAAG,CAAC;AACtB,KAAK,MAAM;AACX,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;AAC9B,KAAK;AACL,IAAI,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;AACxB,IAAI,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC1B,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,IAAI,CAAC,GAAG,EAAE;AACZ,IAAI,IAAI,IAAI,CAAC,KAAK;AAClB,MAAM,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;AAC3C,IAAI,IAAI,IAAI,KAAK,QAAQ;AACzB,MAAM,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC;AACvB,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;AACf,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,KAAK,CAAC,GAAG,EAAE;AACb,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;AACpB,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,QAAQ,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;AACrD,MAAM,OAAO,IAAI,CAAC;AAClB,KAAK;AACL,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;AACvC,GAAG;AACH,EAAE,MAAM,CAAC,GAAG,EAAE;AACd,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;AACvC,GAAG;AACH,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,EAAE;AAChC,IAAI,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;AAC7D,GAAG;AACH,EAAE,KAAK,CAAC,UAAU,EAAE;AACpB,IAAI,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;AACjD,GAAG;AACH,EAAE,OAAO,CAAC,SAAS,EAAE;AACrB,IAAI,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAClD,GAAG;AACH,EAAE,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG;AACvB,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;AACpB,MAAM,OAAO,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,KAAK;AACL,MAAM,OAAO,MAAM,CAAC,GAAG,KAAK;AAC5B,QAAQ,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AAC5E,OAAO,CAAC;AACR,GAAG;AACH,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE;AACrB,IAAI,IAAI,CAAC,OAAO;AAChB,MAAM,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC;AAC3B,IAAI,IAAI,IAAI,EAAE,MAAM,CAAC;AACrB,IAAI,IAAI,UAAU,CAAC,EAAE,CAAC,EAAE;AACxB,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC9B,KAAK,MAAM,IAAI,UAAU,CAAC,OAAO,CAAC,EAAE;AACpC,MAAM,IAAI,GAAG,OAAO,CAAC;AACrB,KAAK,MAAM,IAAI,OAAO,YAAY,IAAI,EAAE;AACxC,MAAM,OAAO,OAAO,CAAC;AACrB,KAAK,MAAM;AACX,MAAM,MAAM,GAAG,OAAO,CAAC;AACvB,KAAK;AACL,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAC9B,IAAI,IAAI;AACR,MAAM,IAAI,IAAI;AACd,QAAQ,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AACpC,MAAM,IAAI,MAAM,IAAI,IAAI,EAAE;AAC1B,QAAQ,IAAI,UAAU,CAAC,MAAM,CAAC,EAAE;AAChC,UAAU,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC3B,SAAS,MAAM,IAAI,MAAM,YAAY,aAAa,EAAE;AACpD,UAAU,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AACvC,SAAS,MAAM,IAAI,MAAM,YAAY,IAAI,EAAE;AAC3C,UAAU,IAAI,MAAM,KAAK,GAAG;AAC5B,YAAY,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,eAAe,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAC1D,SAAS,MAAM,IAAI,MAAM,YAAY,OAAO,EAAE;AAC9C,UAAU,MAAM,CAAC,IAAI;AACrB,YAAY,CAAC,CAAC,KAAK;AACnB,cAAc,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC5C,aAAa;AACb,YAAY,CAAC,CAAC,KAAK;AACnB,cAAc,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAC3C,aAAa;AACb,WAAW,CAAC;AACZ,SAAS,MAAM,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;AAC5C,UAAU,MAAM,CAAC,IAAI;AACrB,YAAY,CAAC,CAAC,KAAK;AACnB,cAAc,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAC5C,aAAa;AACb,YAAY,CAAC,CAAC,KAAK;AACnB,cAAc,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAC3C,aAAa;AACb,WAAW,CAAC;AACZ,SAAS,MAAM,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AACtF,UAAU,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;AACvC,SAAS,MAAM;AACf,UAAU,MAAM,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAAC;AAClE,SAAS;AACT,OAAO;AACP,MAAM,OAAO,GAAG,CAAC;AACjB,KAAK,CAAC,OAAO,CAAC,EAAE;AAChB,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC;AAChB,MAAM,MAAM,CAAC,CAAC;AACd,KAAK;AACL,GAAG;AACH,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE;AAC5B,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,KAAK,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;AAC3D,GAAG;AACH,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,IAAI,EAAE;AACnB,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AACvC,IAAI,IAAI;AACR,MAAM,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AACzB,KAAK,SAAS;AACd,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC5B,KAAK;AACL,GAAG;AACH,EAAE,IAAI,CAAC,EAAE,EAAE;AACX,IAAI,MAAM,GAAG,GAAG,IAAI,CAAC;AACrB,IAAI,OAAO,WAAW;AACtB,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,MAAM,IAAI;AACV,QAAQ,OAAO,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAC1C,OAAO,SAAS;AAChB,QAAQ,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9B,OAAO;AACP,KAAK,CAAC;AACN,GAAG;AACH,EAAE,IAAI,CAAC,OAAO,EAAE;AAChB,IAAI,IAAI,UAAU,CAAC,OAAO,CAAC;AAC3B,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,OAAO,CAAC,CAAC;AACnC,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,OAAO,CAAC,OAAO,EAAE;AACnB,IAAI,IAAI,IAAI,KAAK,QAAQ;AACzB,MAAM,OAAO,IAAI,CAAC;AAClB,IAAI,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;AAC5B,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC;AAC5B,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;AAC9B,IAAI,OAAO,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAChC,GAAG;AACH,EAAE,UAAU,CAAC,GAAG,EAAE;AAClB,IAAI,IAAI;AACR,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AACzD,KAAK,CAAC,OAAO,CAAC,EAAE;AAChB,MAAM,IAAI,IAAI,KAAK,QAAQ;AAC3B,QAAQ,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AACzC;AACA,QAAQ,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC9B,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC;AACvD,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAC9B,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAC5B,KAAK;AACL,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,UAAU,CAAC,OAAO,EAAE;AACtB,IAAI,IAAI,UAAU,CAAC,OAAO,CAAC;AAC3B,MAAM,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAClC,SAAS,IAAI,OAAO,KAAK,IAAI;AAC7B,MAAM,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAC5B,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,MAAM,GAAG;AACX,IAAI,IAAI,IAAI,KAAK,QAAQ;AACzB,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;AACjB,IAAI,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;AACxC,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACtB,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;AACjC,GAAG;AACH,CAAC;AACD,MAAM,QAAQ,mBAAmB,IAAI,OAAO,EAAE,CAAC;AACxC,SAAS,aAAa,CAAC,GAAG,EAAE;AACnC,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AAC1B,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK;AAChD,MAAM,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC5D,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE;AACtB,QAAQ,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;AAChC;AACA,QAAQ,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AAC1B,KAAK,CAAC,CAAC,CAAC;AACR,GAAG;AACH,EAAE,OAAO,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC3B,CAAC;AACW,MAAC,OAAO,GAAG,IAAI,CAAC,OAAO;AACvB,MAAC,QAAQ,GAAG,OAAO,GAAG;AAClC,QAAQ,CAAC,GAAG,GAAG,MAAM;AACrB,EAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;AACzD,CAAC,CAAC;AACF,QAAQ,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAClC,SAAS,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE;AACxB,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAC5E,EAAE,IAAI,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM;AACnC,IAAI,GAAG,GAAG,KAAK,CAAC,CAAC;AACjB,IAAI,EAAE,EAAE,CAAC;AACT,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC;AAC3B,GAAG,CAAC,CAAC;AACL,EAAE,KAAK,CAAC,MAAM;AACd,IAAI,OAAO,GAAG,KAAK,CAAC;AACpB,IAAI,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AACzB,GAAG,CAAC,CAAC;AACL,EAAE,SAAS,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE;AAC7B,IAAI,IAAI,CAAC,EAAE;AACX,MAAM,OAAO;AACb,IAAI,IAAI,OAAO,EAAE;AACjB,MAAM,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;AACjD,KAAK;AACL,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAC7B,IAAI,IAAI;AACR,MAAM,OAAO,GAAG,IAAI,CAAC;AACrB,MAAM,IAAI;AACV,QAAQ,WAAW;AACnB,UAAU,EAAE,EAAE,CAAC;AACf,UAAU,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;AACzD,UAAU,IAAI,KAAK,EAAE;AACrB,YAAY,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACrC,YAAY,GAAG,GAAG,KAAK,CAAC,CAAC;AACzB,YAAY,MAAM;AAClB,WAAW,MAAM,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;AACzC,YAAY,MAAM,GAAG,OAAO,CAAC;AAC7B,YAAY,GAAG,GAAG,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAC;AACtF,YAAY,SAAS;AACrB,WAAW,MAAM;AACjB,YAAY,IAAI,MAAM,GAAG,KAAK,EAAE,QAAQ,GAAG,KAAK,EAAE,KAAK,GAAG,EAAE,CAAC;AAC7D,YAAY,KAAK,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,KAAK;AACpC,cAAc,IAAI,MAAM;AACxB,gBAAgB,OAAO;AACvB;AACA,gBAAgB,MAAM,GAAG,IAAI,CAAC;AAC9B,cAAc,MAAM,GAAG,EAAE,CAAC;AAC1B,cAAc,GAAG,GAAG,EAAE,KAAK,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC;AAC9C,cAAc,IAAI,QAAQ,IAAI,KAAK,KAAK,EAAE;AAC1C,gBAAgB,IAAI,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAC9B,aAAa,CAAC,CAAC;AACf,YAAY,QAAQ,GAAG,IAAI,CAAC;AAC5B,YAAY,IAAI,CAAC,MAAM;AACvB,cAAc,OAAO;AACrB,WAAW;AACX,SAAS;AACT,OAAO,CAAC,OAAO,CAAC,EAAE;AAClB,QAAQ,EAAE,GAAG,GAAG,GAAG,KAAK,CAAC,CAAC;AAC1B,QAAQ,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACzB,OAAO;AACP,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC;AAClB,MAAM,IAAI,IAAI,CAAC;AACf,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC;AACpB,KAAK,SAAS;AACd,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;AACnB,MAAM,OAAO,GAAG,KAAK,CAAC;AACtB,KAAK;AACL,GAAG;AACH;;ACtVO,SAAS,YAAY,CAAC,KAAK,GAAG,YAAY,EAAE;AACnD,EAAE,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;AACvB,EAAE,OAAO,CAAC,EAAE,KAAK;AACjB,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE;AACzC,MAAM,IAAI,EAAE;AACZ,QAAQ,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;AAC/B,MAAM,OAAO,KAAK,CAAC,OAAO,EAAE,CAAC;AAC7B,KAAK;AACL,IAAI,OAAO,KAAK,CAAC;AACjB,GAAG,CAAC;AACJ,CAAC;AACW,MAAC,QAAQ,GAAG,uBAAuB;AACxC,SAAS,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE;AAC1C,EAAE,OAAO,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;AAC5C,CAAC;AACM,SAAS,QAAQ,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE;AAC5C,EAAE,OAAO,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC;AACD,MAAM,SAAS,CAAC;AAChB;AACA,EAAE,WAAW,CAAC,IAAI,EAAE;AACpB,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACrB;AACA,IAAI,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC;AAC7B,IAAI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;AACzB,IAAI,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;AAC5B,GAAG;AACH,EAAE,MAAM,GAAG;AACX,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;AAChC,GAAG;AACH;AACA,EAAE,OAAO,GAAG;AACZ,IAAI,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,QAAQ,CAAC;AAC1C,GAAG;AACH,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE;AACnB,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;AACtB,MAAM,OAAO,IAAI,CAAC;AAClB,IAAI,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,qBAAqB,IAAI,GAAG,EAAE,CAAC;AACrE,IAAI,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5D,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE;AACpD,MAAM,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACtB,KAAK;AACL,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AAC/B,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,KAAK,GAAG;AACV,IAAI,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;AAC1B,IAAI,OAAO,IAAI,CAAC;AAChB,GAAG;AACH,EAAE,MAAM,GAAG;AACX,IAAI,IAAI,IAAI,CAAC,UAAU;AACvB,MAAM,OAAO;AACb,IAAI,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;AAChC,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI;AACzB,MAAM,OAAO;AACb,IAAI,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;AAC3B,IAAI,IAAI;AACR,MAAM,KAAK,IAAI,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,UAAU,EAAE;AAC3C,QAAQ,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;AAC3B,UAAU,MAAM;AAChB,QAAQ,MAAM,EAAE,CAAC;AACjB,QAAQ,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC9B,QAAQ,EAAE,EAAE,CAAC;AACb,OAAO;AACP,KAAK,SAAS;AACd,MAAM,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;AAC9B,KAAK;AACL,GAAG;AACH,EAAE,MAAM,GAAG;AACX,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE;AACvB,MAAM,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;AAC3B,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;AACpB,KAAK;AACL,GAAG;AACH,CAAC;AACD,MAAM,YAAY,GAAG,QAAQ,EAAE,CAAC;AACzB,SAAS,IAAI,GAAG;AACvB,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AACvB,EAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE;AAC3C,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxB,EAAE,OAAO,CAAC,CAAC;AACX,CAAC;AACM,SAAS,OAAO,CAAC,GAAG,GAAG,EAAE;AAChC,EAAE,OAAO,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC;AACpC,CAAC;AACM,SAAS,IAAI,CAAC,GAAG,IAAI,EAAE;AAC9B,EAAE,OAAO,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;AAC/B;;ACvFO,SAAS,IAAI,CAAC,OAAO,EAAE;AAC9B,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACzB,CAAC;AACM,SAAS,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE;AAChC,EAAE,OAAO,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAClC,CAAC;AACM,SAAS,WAAW,GAAG;AAC9B,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;AACvB,CAAC;AACD,MAAM,MAAM,mBAAmB,IAAI,OAAO,EAAE,CAAC;AACtC,SAAS,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE;AAChD,EAAE,IAAI,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC9B,EAAE,IAAI,KAAK,EAAE;AACb,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;AACxB,GAAG,MAAM,IAAI,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE;AAChD,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AACzC,GAAG;AACH,EAAE,IAAI,GAAG,CAAC,MAAM,EAAE,EAAE;AACpB,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACvB,GAAG,MAAM,IAAI,EAAE,EAAE;AACjB,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,MAAM;AACrC,MAAM,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAC5B,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC;AAChB,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;AACZ,GAAG,MAAM;AACT,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAC1B,GAAG;AACH,EAAE,OAAO,GAAG,CAAC;AACb,CAAC;AACD,MAAM,YAAY,mBAAmB,IAAI,OAAO,EAAE,CAAC;AAC5C,SAAS,WAAW,CAAC,GAAG,GAAG,MAAM,EAAE,EAAE;AAC5C,EAAE,IAAI,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACrC,EAAE,IAAI,CAAC,MAAM,EAAE;AACf,IAAI,MAAM,IAAI,GAAG,IAAI,eAAe,EAAE,CAAC;AACvC,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;AACzB,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM;AACnB,MAAM,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAClC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;AACnB,KAAK,CAAC,CAAC;AACP,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAClC,IAAI,IAAI,GAAG,CAAC,MAAM,EAAE;AACpB,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;AACnB,GAAG;AACH,EAAE,OAAO,MAAM,CAAC;AAChB,CAAC;AACM,SAAS,UAAU,CAAC,KAAK,EAAE;AAClC,EAAE,MAAM,KAAK,GAAG,MAAM,EAAE,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;AAClE,EAAE,KAAK,KAAK,CAAC,CAAC,KAAK;AACnB,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;AACpB,GAAG,CAAC;AACJ,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/C,EAAE,OAAO,WAAW;AACpB,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7C,IAAI,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AACxC,IAAI,IAAI;AACR,MAAM,OAAO,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;AAC3C,KAAK,CAAC,OAAO,CAAC,EAAE;AAChB,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;AACtB,MAAM,MAAM,CAAC,CAAC;AACd,KAAK,SAAS;AACd,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;AAC5B,KAAK;AACL,GAAG,CAAC;AACJ,CAAC;AACM,SAAS,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE;AACrC,EAAE,IAAI,IAAI;AACV,IAAI,OAAO,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;AAChD,EAAE,OAAO,SAAS,GAAG,IAAI,EAAE;AAC3B,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;AACzC,GAAG,CAAC;AACJ;;ACrEO,SAAS,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE;AAC5D,EAAE,IAAI,MAAM,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAC1C,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;AAC5B,EAAE,IAAI,UAAU,CAAC,MAAM,CAAC;AACxB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,KAAK,KAAK,KAAK,CAAC,CAAC,GAAG,KAAK;AAC5E,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK;AACxD,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC;AACtB,UAAU,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;AAC/C,aAAa,IAAI,OAAO,CAAC,CAAC,CAAC;AAC3B,UAAU,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AACpC,OAAO,CAAC,CAAC;AACT,KAAK,CAAC,CAAC;AACP,EAAE,oBAAoB,EAAE,CAAC;AACzB,CAAC;AACM,SAAS,oBAAoB,GAAG;AACvC,EAAE,MAAM,IAAI,SAAS,CAAC,wBAAwB,CAAC,CAAC;AAChD;;;;"}

package/dist/mod.d.ts

@@ -1,6 +1,6 @@
 import { J as Job, C as CleanupFn, Y as Yielding, S as Source, D as DisposeFn, a as Stream, B as Backpressure, T as Transformer, b as Sink, O as OptionalCleanup, c as StartFn, d as StartObj, A as AnyFunction } from './types-N2ua11te.js';
 export { e as AsyncStart, z as CancelError, m as CancelResult, K as Connection, E as ErrorResult, H as HandledError, I as Inlet, M as IsStream, g as JobIterator, o as JobResult, N as Nothing, P as PlainFunction, i as RecalcSource, R as Request, L as SignalSource, h as Suspend, f as SyncStart, G as Throttle, U as UnhandledError, V as ValueResult, F as backpressure, Z as compose, Q as connect, x as fulfillPromise, w as getResult, _ as into, p as isCancel, s as isError, u as isHandled, t as isUnhandled, q as isValue, v as markHandled, n as noop, X as pipe, y as propagateResult, j as reject, l as rejecter, r as resolve, k as resolver, W as throttle } from './types-N2ua11te.js';
-export { a as Each, E as EachResult, N as NextMethod, U as UntilMethod, e as each, f as forEach, n as next, r as recalcWhen } from './sinks-kEzJo6Hc.js';
+export { a as Each, E as EachResult, N as NextMethod, U as UntilMethod, e as each, f as forEach, i as isObserved, n as next, r as recalcWhen } from './sinks-5TuxCRtX.js';
 
 /**
  * Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()

package/dist/mod.mjs

@@ -1,6 +1,6 @@
-import { r as resolver, a as rejecter, b as resolve, I as IsStream, c as backpressure, m as must, s as start, g as getJob, n as noop, d as defer, t as throttle, e as detached, i as isCancel, f as isUnhandled, h as markHandled, j as isError, k as connect, l as fulfillPromise, o as callOrWait, p as restarting, q as current, u as mustBeSourceOrSignal, v as isValue } from './call-or-wait-DHkBd_bM.mjs';
-export { A as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, L as abortSignal, G as compose, y as getResult, H as into, x as isHandled, J as isJobActive, D as makeJob, B as nativePromise, F as pipe, z as propagateResult, w as reject, M as task, K as timeout } from './call-or-wait-DHkBd_bM.mjs';
-import { isFunction } from './utils.mjs';
+import { d as defer, i as isFunction } from './utils-P0JEpWXG.mjs';
+import { r as resolver, a as rejecter, b as resolve, I as IsStream, c as backpressure, m as must, s as start, g as getJob, n as noop, t as throttle, d as detached, i as isCancel, e as isUnhandled, f as markHandled, h as isError, j as connect, k as fulfillPromise, l as callOrWait, o as restarting, p as current, q as mustBeSourceOrSignal, u as isValue } from './call-or-wait-COAmx32w.mjs';
+export { z as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, K as abortSignal, F as compose, x as getResult, G as into, w as isHandled, H as isJobActive, B as makeJob, A as nativePromise, D as pipe, y as propagateResult, v as reject, L as task, J as timeout } from './call-or-wait-COAmx32w.mjs';
 
 function* to(p) {
   return yield (res) => Promise.resolve(p).then(resolver(res), rejecter(res));
@@ -276,6 +276,9 @@ function forEach(src, sink, inlet) {
 function recalcWhen(fnOrKey, fn) {
   current.cell?.recalcWhen(fnOrKey, fn);
 }
+function isObserved() {
+  return current.cell?.isObserved();
+}
 
 function concat(sources) {
   return concatAll(fromIterable(sources));
@@ -435,5 +438,5 @@ function takeWhile(condition) {
   };
 }
 
-export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, interval, isCancel, isError, isUnhandled, isValue, lazy, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, never, next, noop, recalcWhen, rejecter, resolve, resolver, restarting, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };
+export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, interval, isCancel, isError, isObserved, isUnhandled, isValue, lazy, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, never, next, noop, recalcWhen, rejecter, resolve, resolver, restarting, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };
 //# sourceMappingURL=mod.mjs.map