uneventful 0.0.10 → 0.0.11

package/README.md

@@ -67,12 +67,12 @@ function supportDragDrop(parentNode: HTMLElement) {
     return start(function*(job) {
         const mouseDown = fromDomEvent(parentNode, "mousedown");
         for (const {item: event, next} of yield *each(mouseDown)) {
-            if (event.target.matches(".drag-handle") {
+            if (event.target.matches(".drag-handle")) {
                 const dropTarget = yield *drag(event.target.closest(".draggable"));
                 // do something with the dropTarget here
             }
             yield next;  // wait for next mousedown
-        });
+        }
     });
 }
 ```

package/dist/{call-or-wait-DORP7nkp.mjs → call-or-wait-EzXJX5Dq.mjs}

@@ -1,5 +1,5 @@
-import { g as getJob, k as current, J as pulls, s as start, l as isValue, f as isError, e as markHandled } from './jobutils-CmHay7sf.mjs';
-import { i as isFunction } from './utils-DnMz1K-o.mjs';
+import { g as getJob, H as currentJob, I as pulls, s as start, l as isValue, f as isError, e as markHandled } from './jobutils-Dvu-e99o.mjs';
+import { i as isFunction } from './utils-cyEhnyp7.mjs';
 
 function backpressure(inlet = defaultInlet) {
   const job = getJob();
@@ -16,7 +16,7 @@ const IsStream = "uneventful/is-stream";
 function connect(src, sink, inlet) {
   return getJob().connect(src, sink, inlet);
 }
-function throttle(job = current.job) {
+function throttle(job = currentJob) {
   return new _Throttle(job);
 }
 class _Throttle {
@@ -93,20 +93,19 @@ function into(...args) {
 function callOrWait(source, method, handler, noArgs) {
   if (source && isFunction(source[method]))
     return source[method]();
-  if (isFunction(source))
-    return (source.length === 0 ? noArgs(source) : false) || start((job) => {
-      connect(source, (v) => handler(job, v)).do((r) => {
-        if (isValue(r))
-          job.throw(new Error("Stream ended"));
-        else if (isError(r))
-          job.throw(markHandled(r));
-      });
+  if (!isFunction(source))
+    mustBeSourceOrSignal();
+  return (source.length === 0 ? noArgs(source) : false) || start((job) => {
+    connect(source, (v) => handler(job, v)).do((r) => {
+      if (isValue(r))
+        job.throw(new Error("Stream ended"));
+      else if (isError(r))
+        job.throw(markHandled(r));
     });
-  mustBeSourceOrSignal();
+  });
 }
 function mustBeSourceOrSignal() {
   throw new TypeError("not a source or signal");
 }
 
 export { IsStream as I, callOrWait as a, backpressure as b, connect as c, compose as d, into as i, mustBeSourceOrSignal as m, pipe as p, throttle as t };
-//# sourceMappingURL=call-or-wait-DORP7nkp.mjs.map

package/dist/ext.d.ts

@@ -0,0 +1,260 @@
+import { P as PlainFunction } from './types-N2ua11te.js';
+
+/**
+ * This module provides helpers for creating *extensions*: a way of extending
+ * objects with additional (possibly private) data or methods via a WeakMap.
+ *
+ * An extension property links a type of object (known as the "target") with a
+ * specific type of extension, via a factory function or class.  When you use an
+ * extension property for a specific target, the extension is automatically
+ * created (via the factory) if it doesn't already exist.
+ *
+ * Extension properties and methods are created either by inheriting from the
+ * {@link Ext} class, or by wrapping factory functions with {@link ext}() or
+ * {@link method}().
+ *
+ * @module uneventful/ext
+ *
+ * @experimental
+ *
+ * @summary Tools for extending objects with extra state and behavior, without
+ * directly modifying them.
+ */
+
+/**
+ * Create an extension accessor function that returns a memoized
+ * value for a given target object or function.
+ *
+ * (Memoization is done via WeakMap, so the cached extensions will be freed
+ * automatically once the target is garbage-collected.)
+ *
+ * @template Target The type of target object that will be extended.  Both the
+ * passed-in factory function and the returned accessor function will take a
+ * parameter of this type, which must be an object or function type.  (So it's
+ * suitable for weak referencing.)
+ *
+ * @template ExtType The type of extension that will be cached.  Both the
+ * passed-in factory function and the returned accessor will return a value of
+ * this type.
+ *
+ * @param factory Function called with a target object or function and a weakmap
+ * to create a new extension for that target.  The result is cached in the
+ * weakmap so the factory is called at most once per target (unless you alter
+ * the weakmap contents directly).
+ *
+ * @param map Optional: the weakmap to use to store the extensions.  This allows
+ * you to manipulate the map contents (e.g. remove items or clear it) from
+ * outside the factory function.  If no map is provided, one is created
+ * automatically, but then it's only accessible via the factory function's
+ * second parameter.
+ *
+ * @returns A function that always returns the same extension for a given target
+ * (assuming you don't alter the WeakMap), calling the factory function if an
+ * extension doesn't exist yet for that target.
+ */
+declare function ext<Target extends WeakKey, ExtType extends Object>(factory: (tgt: Target, map: WeakMap<Target, ExtType>) => ExtType, map?: WeakMap<Target, ExtType>): (tgt: Target) => ExtType;
+/**
+ * Create an extension *method*: a function that invokes a memoized closure for
+ * a given target object or function.
+ *
+ * This function is almost identical to {@link ext}(), except that instead of an
+ * accessor function, this returns a function that will *call* the extension
+ * (method closure) corresponding to the target, passing along any extra
+ * arguments.
+ *
+ * This is useful when you want to create an extension type that only has one
+ * public method, and you'd rather not create a whole class for it: just set up
+ * its state as variables in your factory function and return a closure. Then,
+ * you can simply call `myMethod(target, ...args)`, which will look up the
+ * (possibly cached) closure for `target` and call it with `(...args)`.  (You
+ * could do the same thing with an {@link ext}() accessor, but then the API
+ * would be `myMethod(target)(...args)`.)
+ *
+ * @template Target The type of target object that will be extended.  Both the
+ * passed-in factory function and the returned accessor function will take a
+ * parameter of this type, which must be an object or function type.  (So it's
+ * suitable for weak referencing.)
+ *
+ * @template Method The type of the closure that will be cached.  The passed-in
+ * factory function must return a value of this type, and the resulting wrapper
+ * function will be of the same type but with an added initial `target`
+ * parameter.  (Note: if this type has more than one call signature, only the
+ * *last* overload will be used in the resulting method signature, due to
+ * TypeScript compiler limitations.)
+ *
+ * @param factory Function called with a target object or function and a weakmap
+ * to create a method closure for that target.  The result is cached in the
+ * weakmap so the factory is called at most once per target (unless you alter
+ * the weakmap contents directly).
+ *
+ * @param map Optional: the weakmap to use to store the method closures.  This
+ * allows you to manipulate the map contents (e.g. remove items or clear it)
+ * from outside the factory function.  If no map is provided, one is created
+ * automatically, but then it's only accessible via the factory function's
+ * second parameter.
+ *
+ * @returns A wrapper function that always invokes the same closure for a given
+ * target (assuming you don't alter the WeakMap), calling the factory function
+ * if a method closure doesn't exist yet for that target.  When called, the
+ * wrapper function returns the result of calling the closure with the same
+ * arguments (minus an initial `target` argument).
+ */
+declare function method<Target extends object, Method extends PlainFunction>(factory: (tgt: Target, map: WeakMap<Target, Method>) => Method, map?: WeakMap<Target, Method>): (tgt: Target, ...args: Parameters<Method>) => ReturnType<Method>;
+/** Helper types for working with {@link Ext} Subclasses */
+declare namespace Ext {
+    /** Get the target type of an {@link Ext} subclass constructor */
+    type Target<T extends Ext.Class> = InstanceType<T>["of"];
+    /**
+     * Get the type of extension that will be returned by the static API.
+     *
+     * Defaults to the subclass instance type, but can be overridden by `declare
+     * readonly __type__: OtherType` in a subclass, so long as the
+     * {@link Ext.__new__ `__new__()`} method is also overridden to return that
+     * type.
+     */
+    type Type<T extends Ext.Class> = InstanceType<T> extends {
+        __type__: infer R;
+    } ? (unknown extends R ? InstanceType<T> : R) : InstanceType<T>;
+    /** The type of weakmap passed to {@link Ext.__new__ `__new__()`} */
+    type Map<Class extends Ext.Class> = WeakMap<Ext.Target<Class>, any>;
+    /**
+     * The type constraint for static generics in the API; you probably won't use this directly.
+     */
+    type Class = typeof Ext<WeakKey>;
+}
+/**
+ * A base class for more complex extension types, providing static accessor and
+ * management APIs.  (e.g. `MyExt.for(aTarget)`, `MyExt.delete(aTarget)`, etc.)
+ *
+ * To create an extension class, just subclass Ext with an appropriate target
+ * type, e.g.:
+ *
+ * ```ts
+ * class MyExt extends Ext<MyTargetType> {
+ *     // ...
+ * }
+ * ```
+ * You can then use `MyExt.for()`, `.delete()`, `.has()`, etc. on instances of
+ * `MyTargetType`, to manage the `MyExt` instances attached to them.
+ *
+ * @template Target The type of target this extension will extend.
+ *
+ * @categoryDescription Extension Management
+ *
+ * Static methods for working with extensions of the subclass type, e.g.
+ * `MyExt.for(someTarget)`.
+ *
+ * @categoryDescription Lifecycle Hooks
+ *
+ * Instance and static members you can override to customize extension creation,
+ * deletion, target and return types.
+ */
+declare abstract class Ext<Target extends WeakKey = WeakKey> {
+    /**
+     * The target the extension was created for (set automatically by the base
+     * class constructor).  You can narrow the target type either by extending
+     * `Ext<SomeType>` directly, or by using `declare readonly of: SomeType` in
+     * your subclass.
+     *
+     * @category Lifecycle Hooks
+     */
+    readonly of: Target;
+    /**
+     * A "virtual" property you can override in subclasses to change the static
+     * interface's return type.  For example, if a subclass does `declare readonly __type__:
+     * Promise<this>`, and overrides `__new__`() to return a promise, then the
+     * static APIs for the subclass (like `.for()`) will return promises instead
+     * of instances. (See the {@link __new__ `__new__`} method for more
+     * details.)
+     *
+     * Note: this property is not actually set by any code, so you can't do anything
+     * other than declare it.  It's just a hack to work around TypeScript's limited
+     * type parameterization for static generics.
+     *
+     * @category Lifecycle Hooks
+     */
+    readonly __type__: unknown;
+    /**
+     * @deprecated Use .for() instead!
+     *
+     * Never directly call the constructor of an Ext subclass except from the
+     * {@link __new__ `__new__()`} method - otherwise you run the risk of having
+     * multiple instances for the same target.  (And it may accept invalid
+     * parameter values if you've redefined the type of the {@link Ext.of `of`}
+     * property in a sub-subclass.)
+     */
+    constructor(of: Target);
+    /**
+     * Get or create an extension instance for the given target.
+     * @category Extension Management
+     */
+    static for<Class extends Ext.Class>(this: Class, tgt: Ext.Target<Class>): Ext.Type<Class>;
+    /**
+     * Get the current extension instance for the given target, or `undefined`
+     * if there isn't one.
+     *
+     * @category Extension Management
+     */
+    static get<Class extends Ext.Class>(this: Class, tgt: Ext.Target<Class>): Ext.Type<Class> | undefined;
+    /**
+     * Does an extension currently exist for the given target?
+     *
+     * @category Extension Management
+     */
+    static has<Class extends Ext.Class>(this: Class, tgt: Ext.Target<Class>): boolean;
+    /**
+     * Delete the current extension for the given target (if one exists), after calling the
+     * {@link __del__ `__del__()`} method on it.
+     *
+     * @category Extension Management
+     */
+    static delete<Class extends Ext.Class>(this: Class, tgt: Ext.Target<Class>): void;
+    /**
+     * This method is called by {@link for}() to create the extension instance
+     * for a target. You can override this method to customize instance creation
+     * behavior, e.g. to execute the constructor within a job, or create a
+     * promise for an extension instance to be asynchronously initiaized, etc.
+     *
+     * If you will be creating something other than an instance of the subclass,
+     * you must also redeclare the type of the {@link __type__ `__type__`}
+     * property.  For example:
+     *
+     * ```ts
+     * class AsyncExt extends Ext {
+     *     declare readonly __type__: Job<this>
+     *
+     *     // simulate slow initialization
+     *     *setup() { yield *sleep(100); return this; }
+     *
+     *     static __new__<Class extends typeof AsyncExt>(
+     *         tgt: Ext.Target<Class>, map: Ext.Map<Class>
+     *     ) {
+     *         const ext = new this(tgt);
+     *         map.set(tgt, root.start(ext.setup()) as Ext.Type<Class>);
+     *     }
+     * }
+     * ```
+     *
+     * Now, `AsyncExt.for(someTarget)` will create and cache  a Job yielding an
+     * extension whose `setup()` has finished. (And subclasses of `AsyncExt`
+     * will share the same behavior, while being subtyped appropriately.)
+     *
+     * (Note: your `__new__` method *must* store what it created in the supplied
+     * map for the given target, and the value it sets must conform to the
+     * declared `__type__`, which is *not* checked for you by TypeScript!)
+     *
+     * @category Lifecycle Hooks
+     */
+    static __new__<Class extends Ext.Class>(this: Class, tgt: Ext.Target<Class>, map: Ext.Map<Class>): void;
+    /**
+     * This method is called by {@link delete}() if it finds an existing
+     * extension for the target. You can override it in a subclass to do any
+     * necessary cleanup on the extension.  (If you need to retrieve the
+     * extension, you can call .get() on the target.)
+     *
+     * @category Lifecycle Hooks
+     */
+    static __del__<Class extends Ext.Class>(this: Class, _target: Ext.Target<Class>): void;
+}
+
+export { Ext, ext, method };

package/dist/ext.mjs

@@ -0,0 +1,112 @@
+import { s as setMap } from './utils-cyEhnyp7.mjs';
+
+function ext(factory, map = /* @__PURE__ */ new WeakMap()) {
+  return (tgt) => map.has(tgt) ? map.get(tgt) : setMap(map, tgt, factory(tgt, map));
+}
+function method(factory, map = /* @__PURE__ */ new WeakMap()) {
+  return (tgt, ...args) => (map.get(tgt) ?? setMap(map, tgt, factory(tgt, map)))(...args);
+}
+const classMap = /* @__PURE__ */ ext((cls) => /* @__PURE__ */ new WeakMap());
+class Ext {
+  /**
+   * @deprecated Use .for() instead!
+   *
+   * Never directly call the constructor of an Ext subclass except from the
+   * {@link __new__ `__new__()`} method - otherwise you run the risk of having
+   * multiple instances for the same target.  (And it may accept invalid
+   * parameter values if you've redefined the type of the {@link Ext.of `of`}
+   * property in a sub-subclass.)
+   */
+  constructor(of) {
+    this.of = of;
+  }
+  /**
+   * Get or create an extension instance for the given target.
+   * @category Extension Management
+   */
+  static for(tgt) {
+    const map = classMap(this);
+    return map.get(tgt) ?? (this.__new__(tgt, map), map.get(tgt));
+  }
+  /**
+   * Get the current extension instance for the given target, or `undefined`
+   * if there isn't one.
+   *
+   * @category Extension Management
+   */
+  static get(tgt) {
+    return classMap(this).get(tgt);
+  }
+  /**
+   * Does an extension currently exist for the given target?
+   *
+   * @category Extension Management
+   */
+  static has(tgt) {
+    return classMap(this).has(tgt);
+  }
+  /**
+   * Delete the current extension for the given target (if one exists), after calling the
+   * {@link __del__ `__del__()`} method on it.
+   *
+   * @category Extension Management
+   */
+  static delete(tgt) {
+    const map = classMap(this);
+    if (map.has(tgt)) {
+      this.__del__(tgt);
+      map.delete(tgt);
+    }
+  }
+  /**
+   * This method is called by {@link for}() to create the extension instance
+   * for a target. You can override this method to customize instance creation
+   * behavior, e.g. to execute the constructor within a job, or create a
+   * promise for an extension instance to be asynchronously initiaized, etc.
+   *
+   * If you will be creating something other than an instance of the subclass,
+   * you must also redeclare the type of the {@link __type__ `__type__`}
+   * property.  For example:
+   *
+   * ```ts
+   * class AsyncExt extends Ext {
+   *     declare readonly __type__: Job<this>
+   *
+   *     // simulate slow initialization
+   *     *setup() { yield *sleep(100); return this; }
+   *
+   *     static __new__<Class extends typeof AsyncExt>(
+   *         tgt: Ext.Target<Class>, map: Ext.Map<Class>
+   *     ) {
+   *         const ext = new this(tgt);
+   *         map.set(tgt, root.start(ext.setup()) as Ext.Type<Class>);
+   *     }
+   * }
+   * ```
+   *
+   * Now, `AsyncExt.for(someTarget)` will create and cache  a Job yielding an
+   * extension whose `setup()` has finished. (And subclasses of `AsyncExt`
+   * will share the same behavior, while being subtyped appropriately.)
+   *
+   * (Note: your `__new__` method *must* store what it created in the supplied
+   * map for the given target, and the value it sets must conform to the
+   * declared `__type__`, which is *not* checked for you by TypeScript!)
+   *
+   * @category Lifecycle Hooks
+   */
+  static __new__(tgt, map) {
+    map.set(tgt, new this(tgt, map));
+  }
+  /**
+   * This method is called by {@link delete}() if it finds an existing
+   * extension for the target. You can override it in a subclass to do any
+   * necessary cleanup on the extension.  (If you need to retrieve the
+   * extension, you can call .get() on the target.)
+   *
+   * @category Lifecycle Hooks
+   */
+  static __del__(_target) {
+  }
+}
+
+export { Ext, ext, method };

package/dist/{jobutils-CmHay7sf.mjs → jobutils-Dvu-e99o.mjs}

@@ -1,4 +1,4 @@
-import { e as batch, d as defer, i as isFunction, G as GeneratorBase, c as apply } from './utils-DnMz1K-o.mjs';
+import { e as batch, d as defer, i as isFunction, G as GeneratorBase, c as apply } from './utils-cyEhnyp7.mjs';
 
 function resolve(request, val) {
   request("next", val);
@@ -44,12 +44,13 @@ function markHandled(res) {
   return res.err;
 }
 function getResult(res) {
-  if (isValue(res))
-    return res.val;
-  res.op;
-  fulfillPromise(noop, (e) => {
-    throw e;
-  }, res);
+  if (!isValue(res)) {
+    res.op;
+    fulfillPromise(noop, (e) => {
+      throw e;
+    }, res);
+  }
+  return res.val;
 }
 function fulfillPromise(resolve2, reject2, res) {
   if (isError(res))
@@ -66,31 +67,25 @@ function propagateResult(job, res) {
 class CancelError extends Error {
 }
 
-var current = makeCtx();
-function swapCtx(future) {
-  const now = current;
-  current = future;
-  return now;
-}
-var freelist = [];
-function makeCtx(job, cell) {
-  if (freelist && freelist.length) {
-    const s = freelist.pop();
-    s.job = job;
-    s.cell = cell;
-    return s;
-  }
-  return { job, cell };
-}
-function freeCtx(s) {
-  s.job = s.cell = null;
-  freelist.push(s);
+var currentJob, currentCell;
+const cells = [], jobs = [];
+function pushCtx(job, cell) {
+  jobs.push(currentJob);
+  cells.push(currentCell);
+  currentJob = job;
+  currentCell = cell;
+}
+function popCtx() {
+  currentJob = jobs.pop();
+  currentCell = cells.pop();
+}
+function cellJob() {
+  return currentJob ||= currentCell?.getJob();
 }
 
 const catchers = /* @__PURE__ */ new WeakMap(), defaultCatch = (e) => {
   Promise.reject(e);
 };
-const nullCtx = makeCtx();
 const owners = /* @__PURE__ */ new WeakMap();
 const pulls = /* @__PURE__ */ batch((pulls2) => {
   for (const conn of pulls2) {
@@ -127,8 +122,7 @@ function qlen(c) {
   return c ? c.v : 0;
 }
 function pop(c) {
-  if (qlen(c))
-    return unlink(c, c.p);
+  return qlen(c) ? unlink(c, c.p) : void 0;
 }
 class Node {
   constructor() {
@@ -185,22 +179,23 @@ function unlinker(chain2, node) {
 }
 
 function getJob() {
-  const job = current.job || current.cell?.getJob();
+  const job = currentJob || cellJob();
   if (job)
     return job;
   throw new Error("No job is currently active");
 }
 function recalcJob(job) {
   return (cb) => {
-    current.job.must(job.release(cb));
+    currentJob.must(job.release(cb));
   };
 }
 function runChain(res, cbs) {
-  while (qlen(cbs))
+  let cb;
+  while (cb = pop(cbs))
     try {
-      pop(cbs)(res);
+      cb(res);
     } catch (e) {
-      detached.asyncThrow(e);
+      _detached.asyncThrow(e);
     }
   cbs && recycle(cbs);
   return void 0;
@@ -212,14 +207,15 @@ class _Job {
       const res = this._done ||= CancelResult, cbs = this._cbs;
       if (!cbs && !isUnhandled(res))
         return;
-      const ct = inProcess.size, old = swapCtx(nullCtx);
+      const ct = inProcess.size;
+      pushCtx();
       if (!ct)
         inProcess.add(null);
       if (cbs && cbs.u)
         cbs.u = runChain(res, cbs.u);
       inProcess.add(this);
       if (ct) {
-        swapCtx(old);
+        popCtx();
         return;
       }
       inProcess.delete(null);
@@ -230,7 +226,7 @@ class _Job {
         if (isUnhandled(item._done))
           item.throw(markHandled(item._done));
       }
-      swapCtx(old);
+      popCtx();
     };
     this._done = void 0;
     // Chain whose .u stores a second chain for `release()` callbacks
@@ -268,7 +264,7 @@ class _Job {
     });
   }
   result() {
-    return this._done || current.cell?.recalcWhen(this, recalcJob) || void 0;
+    return this._done || currentCell?.recalcWhen(this, recalcJob) || void 0;
   }
   get [Symbol.toStringTag]() {
     return "Job";
@@ -380,21 +376,21 @@ class _Job {
     return this.start((job) => void src(sink, job, inlet));
   }
   run(fn, ...args) {
-    const old = swapCtx(makeCtx(this));
+    pushCtx(this);
     try {
       return fn(...args);
     } finally {
-      freeCtx(swapCtx(old));
+      popCtx();
     }
   }
   bind(fn) {
     const job = this;
     return function() {
-      const old = swapCtx(makeCtx(job));
+      pushCtx(job);
       try {
         return apply(fn, this, arguments);
       } finally {
-        freeCtx(swapCtx(old));
+        popCtx();
       }
     };
   }
@@ -469,8 +465,8 @@ function newRoot() {
   return root;
 }
 function runGen(g, job) {
-  let it = g[Symbol.iterator](), running = true, ctx = makeCtx(job), ct = 0;
-  let done = ctx.job.release(() => {
+  let it = g[Symbol.iterator](), running = true, j = job, ct = 0;
+  let done = job.release(() => {
     job = void 0;
     ++ct;
     step("return", void 0);
@@ -485,7 +481,7 @@ function runGen(g, job) {
     if (running) {
       return defer(step.bind(null, method, arg));
     }
-    const old = swapCtx(ctx);
+    pushCtx(j);
     try {
       running = true;
       try {
@@ -519,13 +515,13 @@ function runGen(g, job) {
         }
       } catch (e) {
         it = job = void 0;
-        ctx.job.throw(e);
+        j.throw(e);
       }
       it = void 0;
       done?.();
       done = void 0;
     } finally {
-      swapCtx(old);
+      popCtx();
       running = false;
     }
   }
@@ -538,7 +534,7 @@ function start(init, fn) {
   return getJob().start(init, fn);
 }
 function isJobActive() {
-  return !!current.job;
+  return !!currentJob;
 }
 const timers = /* @__PURE__ */ new WeakMap();
 function timeout(ms = 0, job = getJob()) {
@@ -584,14 +580,14 @@ function restarting(task2) {
   inner.asyncCatch((e) => outer.asyncThrow(e));
   return function() {
     inner.restart().must(outer.release(end));
-    const old = swapCtx(makeCtx(inner));
+    pushCtx(inner);
     try {
       return apply(task2, this, arguments);
     } catch (e) {
       inner.restart();
       throw e;
     } finally {
-      freeCtx(swapCtx(old));
+      popCtx();
     }
   };
 }
@@ -603,5 +599,4 @@ function task(fn, _ctx, desc) {
   };
 }
 
-export { timeout as A, abortSignal as B, CancelResult as C, task as D, ErrorResult as E, swapCtx as F, nullCtx as G, makeCtx as H, freeCtx as I, pulls as J, ValueResult as V, rejecter as a, resolve as b, root as c, isUnhandled as d, markHandled as e, isError as f, getJob as g, fulfillPromise as h, isCancel as i, restarting as j, current as k, isValue as l, must as m, noop as n, reject as o, isHandled as p, getResult as q, resolver as r, start as s, propagateResult as t, CancelError as u, nativePromise as v, makeJob as w, detached as x, newRoot as y, isJobActive as z };
-//# sourceMappingURL=jobutils-CmHay7sf.mjs.map
+export { timeout as A, abortSignal as B, CancelResult as C, task as D, ErrorResult as E, pushCtx as F, popCtx as G, currentJob as H, pulls as I, ValueResult as V, rejecter as a, resolve as b, root as c, isUnhandled as d, markHandled as e, isError as f, getJob as g, fulfillPromise as h, isCancel as i, restarting as j, currentCell as k, isValue as l, must as m, noop as n, reject as o, isHandled as p, getResult as q, resolver as r, start as s, propagateResult as t, CancelError as u, nativePromise as v, makeJob as w, detached as x, newRoot as y, isJobActive as z };

package/dist/mod.d.ts

@@ -6,6 +6,7 @@ export { a as Each, E as EachResult, N as NextMethod, U as UntilMethod, e as eac
  * Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()
  *
  * @category Scheduling
+ * @function
  */
 declare let defer: (cb: () => any) => void;
 
@@ -53,6 +54,7 @@ declare function nativePromise<T>(job: Job<T>): Promise<T>;
  * a detached (parentless) job otherwise.
  *
  * @category Jobs
+ * @function
  */
 declare const makeJob: <T>(parent?: Job, stop?: CleanupFn) => Job<T>;
 /**