uneventful 0.0.10 → 0.0.12

package/dist/mod.mjs

@@ -1,8 +1,8 @@
-import { d as defer, i as isFunction } from './utils-DnMz1K-o.mjs';
-import { r as resolver, a as rejecter, b as resolve, m as must, s as start, g as getJob, n as noop, c as root, i as isCancel, d as isUnhandled, e as markHandled, f as isError, h as fulfillPromise, j as restarting, k as current, l as isValue } from './jobutils-CmHay7sf.mjs';
-export { u as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, B as abortSignal, x as detached, q as getResult, p as isHandled, z as isJobActive, w as makeJob, v as nativePromise, y as newRoot, t as propagateResult, o as reject, D as task, A as timeout } from './jobutils-CmHay7sf.mjs';
-import { I as IsStream, b as backpressure, t as throttle, c as connect, a as callOrWait, m as mustBeSourceOrSignal } from './call-or-wait-DORP7nkp.mjs';
-export { d as compose, i as into, p as pipe } from './call-or-wait-DORP7nkp.mjs';
+import { d as defer, i as isFunction } from './utils-cyEhnyp7.mjs';
+import { r as resolver, a as rejecter, b as resolve, m as must, s as start, g as getJob, n as noop, c as root, i as isCancel, d as isUnhandled, e as markHandled, f as isError, h as fulfillPromise, j as restarting, k as currentCell, l as isValue } from './jobutils-Dvu-e99o.mjs';
+export { u as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, B as abortSignal, x as detached, q as getResult, p as isHandled, z as isJobActive, w as makeJob, v as nativePromise, y as newRoot, t as propagateResult, o as reject, D as task, A as timeout } from './jobutils-Dvu-e99o.mjs';
+import { I as IsStream, b as backpressure, t as throttle, c as connect, a as callOrWait, m as mustBeSourceOrSignal } from './call-or-wait-EzXJX5Dq.mjs';
+export { d as compose, i as into, p as pipe } from './call-or-wait-EzXJX5Dq.mjs';
 
 function* to(p) {
   return yield (res) => Promise.resolve(p).then(resolver(res), rejecter(res));
@@ -276,10 +276,10 @@ function forEach(src, sink, inlet) {
   return (src2) => forEach(src2, sink, inlet);
 }
 function recalcWhen(fnOrKey, fn) {
-  current.cell?.recalcWhen(fnOrKey, fn);
+  currentCell?.recalcWhen(fnOrKey, fn);
 }
 function isObserved() {
-  return current.cell?.isObserved();
+  return currentCell?.isObserved();
 }
 
 function concat(sources) {
@@ -371,7 +371,7 @@ function slack(size, dropped = noop) {
     conn.connect(src, (v) => {
       buffer.push(v);
       if (!draining && ready())
-        return drain();
+        return void drain();
       while (buffer.length > max) {
         dropped(size < 0 ? buffer.pop() : buffer.shift());
       }
@@ -401,6 +401,7 @@ function slack(size, dropped = noop) {
       } finally {
         draining = false;
       }
+      return false;
     }
     return IsStream;
   };
@@ -441,4 +442,3 @@ function takeWhile(condition) {
 }
 
 export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, 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, root, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };
-//# sourceMappingURL=mod.mjs.map

package/dist/shared.d.ts

@@ -5,6 +5,7 @@ import { Y as Yielding } from './types-N2ua11te.js';
  * boundaries.
  *
  * @module uneventful/shared
+ * @disableGroups
  */
 
 /**

package/dist/shared.mjs

@@ -1,5 +1,5 @@
-import { c as root, m as must, s as start, n as noop } from './jobutils-CmHay7sf.mjs';
-import { a as isGeneratorFunction, b as decorateMethod, i as isFunction, c as apply, s as setMap } from './utils-DnMz1K-o.mjs';
+import { c as root, m as must, s as start, n as noop } from './jobutils-Dvu-e99o.mjs';
+import { a as isGeneratorFunction, b as decorateMethod, i as isFunction, c as apply, s as setMap } from './utils-cyEhnyp7.mjs';
 
 function service(factory) {
   let known = false, value = void 0;
@@ -50,4 +50,3 @@ function fork(genOrFunc, ...args) {
 const forks = /* @__PURE__ */ new WeakMap();
 
 export { expiring, fork, service };
-//# sourceMappingURL=shared.mjs.map

package/dist/signals.d.ts

@@ -194,7 +194,8 @@ interface RuleFactory {
  *
  * @returns A function that can be called to terminate the rule.
  *
- * @category Reactive Behaviors
+ * @category none
+ * @function
  */
 declare const rule: ((fn: () => OptionalCleanup) => DisposeFn) & RuleFactory;
 /**
@@ -213,7 +214,7 @@ declare const rule: ((fn: () => OptionalCleanup) => DisposeFn) & RuleFactory;
  * factory you wish to run pending rules for.  If not given, the default
  * {@link rule}() factory is targeted.
  *
- * @category Reactive Behaviors
+ * @category Scheduling
  */
 declare function runRules(scheduleFn?: SchedulerFn): void;
 /**
@@ -245,34 +246,6 @@ declare class WriteConflict extends Error {
  */
 declare class CircularDependency extends Error {
 }
-/**
- * Keep an expression's old value unless there's a semantic change
- *
- * By default, reactive values (i.e. {@link cached}(), or {@link value}() with a
- * {@link Configurable.setf setf}()) are considered to have "changed" (and thus
- * trigger recalculation of their dependents) when they are different according
- * to `===` comparison.
- *
- * This works well for primitive values, but for arrays and objects it's not
- * always ideal, because two arrays can have the exact same elements and still
- * be different according to `===`.  So this function lets you substitute a
- * different comparison function (like a deep-equal or shallow-equal) instead.
- * (The default is {@link arrayEq}() if no compare function is supplied.)
- *
- * Specifically, if your reactive expression returns `unchangedIf(newVal,
- * compare)`, then the expression's previous value will be kept if the compare
- * function returns true when called with the old and new values. Otherwise, the
- * new value will be used.
- *
- * @remarks
- * - If the reactive expression's last "value" was an error, the new value is
- *   returned
- * - An error will be thrown if this function is called outside a reactive
- *   expression or from within a {@link peek}() call or {@link action} wrapper.
- *
- * @category Reactive Values
- */
-declare function unchangedIf<T>(newVal: T, equals?: (v1: T, v2: T) => boolean): T;
 
 /**
  * The Signals API for uneventful.
@@ -376,7 +349,7 @@ interface Configurable<T> extends Writable<T> {
 /**
  * Create a {@link Configurable} signal with the given inital value
  *
- * @category Reactive Values
+ * @category none
  */
 declare function value<T>(val?: T): Configurable<T>;
 /**
@@ -388,7 +361,7 @@ declare function value<T>(val?: T): Configurable<T>;
  * calling signature below will apply, even if TypeScript doesn't see it that
  * way!)
  *
- * @category Reactive Values
+ * @category none
  */
 declare function cached<T>(compute: () => T): Signal<T>;
 /**
@@ -429,7 +402,7 @@ declare function cached<T extends Signal<any>>(signal: T): T;
  *
  * @returns The result of calling `fn(..args)`
  *
- * @category Reactive Values
+ * @category Dependency Tracking
  */
 declare function peek<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F>;
 /**
@@ -471,7 +444,7 @@ declare function peek<F extends PlainFunction>(fn: F, ...args: Parameters<F>): R
  * to the original function, while running with dependency tracking suppressed
  * (as with {@link peek}()).
  *
- * @category Reactive Behaviors
+ * @category Dependency Tracking
  */
 declare function action<F extends AnyFunction>(fn: F): F;
 /** @hidden TC39 Decorator protocol */
@@ -482,6 +455,78 @@ declare function action<F extends AnyFunction>(fn: F, ctx: {
 declare function action<F extends AnyFunction, D extends {
     value?: F;
 }>(clsOrProto: any, name: string | symbol, desc: D): D;
+/**
+ * Keep an expression's old value unless there's a semantic change
+ *
+ * By default, reactive values (i.e. {@link cached}(), or {@link value}() with a
+ * {@link Configurable.setf setf}()) are considered to have "changed" (and thus
+ * trigger recalculation of their dependents) when they are different according
+ * to `===` comparison.
+ *
+ * This works well for primitive values, but for arrays and objects it's not
+ * always ideal, because two arrays can have the exact same elements and still
+ * be different according to `===`.  So this function lets you substitute a
+ * different comparison function (like a deep-equal or shallow-equal) instead.
+ *
+ * Specifically, if your reactive expression returns `stable(compare, newVal)`,
+ * then the expression's previous value will be kept if the `compare` function
+ * returns true when called with the old and new values. Otherwise, the new
+ * value will be used.
+ *
+ * @remarks
+ * - If the reactive expression's last "value" was an error, the new value is
+ *   returned.
+ * - An error will be thrown if this function is called outside a reactive
+ *   expression or from within a {@link peek}() call or {@link action} wrapper.
+ * - You can use the {@link stabilizer}() function to create custom functions
+ *   similar to {@link stableJSON}. or {@link stableArray}().
+ *
+ * @category Dependency Tracking
+ */
+declare function stable<T>(equals: (v1: T, v2: T) => boolean, newVal: T): T;
+/**
+ * @deprecated This is {@link stable}() but with swapped arguments.  Please switch
+ * to using stable(), stableArray(), or a stabilizer(), as this function will be removed
+ * in a future release.
+ *
+ * @hidden
+ */
+declare function unchangedIf<T>(newVal: T, equals?: (v1: T, v2: T) => boolean): T;
+/**
+ * Create a shorthand version of {@link stable}(), pre-bound to a specific comparison
+ * function.
+ *
+ * @param equals The comparison function to use
+ * @template T The type of value the comparison function works on
+ *
+ * @category Dependency Tracking
+ */
+declare function stabilizer<T>(equals: <T>(v1: T, v2: T) => boolean): <R extends T>(newVal: R) => R;
+/**
+ * Keep an expression's old value if the new value is an array with the same
+ * contents.
+ *
+ * (Shorthand for {@link stable}({@link arrayEq}, ...).)
+ *
+ * @function
+ * @category Dependency Tracking
+ */
+declare const stableArray: <R extends unknown[]>(newVal: R) => R;
+/**
+ * Keep an expression's old value if its JSON string is the same as the new one.
+ *
+ * (Shorthand for {@link stable}() with a JSON-string comparison function.)
+ *
+ * Note that JSON string comparison is slow and memory intensive for more
+ * complex data structures, is order-sensitive for object keys, and doesn't
+ * support maps or sets.  If you need any of those things, you should probably
+ * use a {@link stabilizer}() based on
+ * [fast-equals](https://github.com/planttheidea/fast-equals) instead.
+ *
+ * @function
+ * @category Dependency Tracking
+ */
+declare const stableJSON: <R extends any>(newVal: R) => R;
 /**
  * Wait for and return the next truthy value (or error) from a data source (when
  * processed with `yield *` within a {@link Job}).
@@ -513,4 +558,4 @@ declare function action<F extends AnyFunction, D extends {
  */
 declare function until<T>(source: UntilMethod<T> | Stream<T> | (() => T)): Yielding<T>;
 
-export { CircularDependency, type Configurable, type GenericMethodDecorator, type RuleFactory, type SchedulerFn, type Signal, type Writable, WriteConflict, action, cached, peek, rule, runRules, unchangedIf, until, value };
+export { CircularDependency, type Configurable, type GenericMethodDecorator, type RuleFactory, type SchedulerFn, type Signal, type Writable, WriteConflict, action, cached, peek, rule, runRules, stabilizer, stable, stableArray, stableJSON, unchangedIf, until, value };

package/dist/signals.mjs

@@ -1,6 +1,6 @@
-import { F as swapCtx, G as nullCtx, k as current, H as makeCtx, w as makeJob, c as root, f as isError, e as markHandled, g as getJob, x as detached, o as reject, b as resolve, I as freeCtx } from './jobutils-CmHay7sf.mjs';
-import { b as backpressure, I as IsStream, a as callOrWait } from './call-or-wait-DORP7nkp.mjs';
-import { e as batch, f as arrayEq, d as defer, c as apply, s as setMap, C as CallableObject } from './utils-DnMz1K-o.mjs';
+import { F as pushCtx, G as popCtx, w as makeJob, c as root, f as isError, e as markHandled, g as getJob, x as detached, k as currentCell, o as reject, b as resolve } from './jobutils-Dvu-e99o.mjs';
+import { b as backpressure, I as IsStream, a as callOrWait } from './call-or-wait-EzXJX5Dq.mjs';
+import { e as batch, d as defer, c as apply, s as setMap, C as CallableObject, f as arrayEq } from './utils-cyEhnyp7.mjs';
 
 const ruleQueues = /* @__PURE__ */ new WeakMap();
 function ruleQueue(scheduleFn = defer) {
@@ -32,6 +32,14 @@ var timestamp = 1;
 const fntrackers = /* @__PURE__ */ new WeakMap();
 const obtrackers = /* @__PURE__ */ new WeakMap();
 const monitors = /* @__PURE__ */ new WeakMap();
+const staleStreams = batch((q) => {
+  for (const cell of q)
+    if (!cell.subscribers) {
+      ++timestamp;
+      break;
+    }
+  q.clear();
+});
 const demandChanges = batch((q) => {
   for (const cell of q)
     cell.updateDemand();
@@ -129,6 +137,7 @@ function toggleDemand(c) {
     demandChanges.has(c) ? demandChanges.delete(c) : demandChanges.add(c);
   }
 }
+let dummySource;
 class Cell {
   constructor() {
     this.value = void 0;
@@ -140,7 +149,7 @@ class Cell {
     this.latestSource = timestamp;
     // max lastChanged of this cell or any ancestor source
     this.flags = 0;
-    this.ctx = void 0;
+    this.job = void 0;
     /** The subscription being added during the current calculation - used for uniqueness */
     this.adding = void 0;
     /** Linked list of sources */
@@ -159,11 +168,11 @@ class Cell {
     Cell.mkRule(() => {
       const val = this.getValue();
       if (val !== lastValue) {
-        const old = swapCtx(nullCtx);
+        pushCtx();
         try {
           sink(lastValue = val);
         } finally {
-          swapCtx(old);
+          popCtx();
         }
       }
     }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
@@ -172,8 +181,8 @@ class Cell {
   getValue() {
     if (arguments.length)
       return apply(this.stream, this, arguments);
-    const dep = current.cell;
-    if (dep && this.flags & 132 /* Variable */) {
+    const dep = currentCell;
+    if (dep && this.flags & 132 /* Variable */ && (dep.flags & 8 /* Peeking */) === 0) {
       if (this.flags & 32 /* Running */)
         throw new CircularDependency("Cached function dependency cycle");
       let s = this.adding;
@@ -204,7 +213,7 @@ class Cell {
     return this.value;
   }
   shouldWrite(changed) {
-    const cell = current.cell || currentRule;
+    const cell = currentCell || currentRule;
     if (cell) {
       if (!cell.queue)
         throw new WriteConflict("Side-effects not allowed outside rules");
@@ -237,7 +246,6 @@ class Cell {
     if (this.shouldWrite(compute !== this.compute)) {
       this.flags |= 4 /* Compute */;
       this.compute = compute;
-      this.ctx ||= makeCtx(null, this);
     }
   }
   hasBeenRead() {
@@ -253,8 +261,13 @@ class Cell {
     if (validThrough === timestamp)
       return;
     this.validThrough = timestamp;
-    if (!(this.flags & 4 /* Compute */))
+    if (!(this.flags & 4 /* Compute */)) {
+      if (this.flags & 256 /* Stream */ && !this.subscribers) {
+        this.lastChanged = timestamp;
+        staleStreams.add(this);
+      }
       return;
+    }
     if (this.sources) {
       for (let sub = this.sources; sub; sub = sub.nS) {
         const s = sub.src;
@@ -275,9 +288,9 @@ class Cell {
       return this.doRecalc();
   }
   doRecalc() {
-    const { ctx } = this, oldCtx = swapCtx(ctx);
+    pushCtx(this.job, this);
     if (this.flags & 64 /* Stateful */) {
-      ctx.job?.restart();
+      this.job?.restart();
     }
     for (let sub = this.sources; sub; sub = sub.nS) {
       sub.ts = -1;
@@ -307,12 +320,12 @@ class Cell {
         demandChanges.delete(this);
         if (this.flags & (16 /* Error */ | 2 /* Stopped */)) {
           this.flags &= ~2 /* Stopped */;
-          ctx.job?.restart();
+          this.job?.restart();
         } else if (this.flags & 1 /* Observed */) ; else {
-          ctx.job?.restart();
+          this.job?.restart();
         }
       }
-      swapCtx(oldCtx);
+      popCtx();
       let head;
       for (let sub = this.sources; sub; ) {
         const pS = sub.pS;
@@ -328,8 +341,12 @@ class Cell {
     }
   }
   becomeConstant() {
-    if (this.flags & (32 /* Running */ | 64 /* Stateful */))
+    if (this.flags & 32 /* Running */)
+      return;
+    if (this.flags & 64 /* Stateful */) {
+      mksub(dummySource ||= Cell.mkValue(null), this);
       return;
+    }
     this.flags &= ~4 /* Compute */;
     if (this.flags & 132 /* Variable */)
       return;
@@ -396,14 +413,15 @@ class Cell {
     return cell;
   }
   isObserved() {
+    if (this.flags & 8 /* Peeking */)
+      return false;
     return !!((this.flags |= 64 /* Stateful */) & 1 /* Observed */);
   }
   getJob() {
+    if (this.job)
+      return this.job;
     this.flags |= 64 /* Stateful */;
-    return this.ctx.job ||= makeJob(root, () => {
-      this.ctx.job?.end();
-      this.ctx.job = void 0;
-    });
+    return this.job = makeJob();
   }
   updateDemand() {
     demandChanges.delete(this);
@@ -412,13 +430,12 @@ class Cell {
     } else if (this.flags & 1 /* Observed */) {
       this.shouldWrite(true);
     } else {
-      this.ctx.job?.restart();
+      this.job?.restart();
     }
   }
   static mkStream(src, val) {
     const cell = this.mkValue(val);
-    cell.flags |= 64 /* Stateful */;
-    const ctx = makeCtx();
+    cell.flags |= 64 /* Stateful */ | 256 /* Stream */;
     const write = (v) => {
       cell.setValue(v, false);
     };
@@ -431,27 +448,42 @@ class Cell {
       }
       if (job)
         return;
-      job = ctx.job = makeJob(root).do((r) => {
+      job = makeJob(root).do((r) => {
         if (isError(r)) {
           cell.setValue(markHandled(r), true);
         } else {
           cell.setValue(val, false);
         }
-        ctx.job = job = void 0;
+        job = void 0;
       });
-      const old = swapCtx(ctx);
+      pushCtx(job);
       try {
         src(write, job);
       } catch (e) {
         job.end();
         root.asyncThrow(e);
       } finally {
-        swapCtx(old);
+        popCtx();
       }
     });
     return cell;
   }
+  peek(fn, thisArg, args) {
+    if (this.flags & 8 /* Peeking */)
+      return apply(fn, thisArg, args);
+    this.flags |= 8 /* Peeking */;
+    try {
+      return apply(fn, thisArg, args);
+    } finally {
+      this.flags &= ~8 /* Peeking */;
+    }
+  }
+  unchangedIf(newVal, equals) {
+    return this.flags & 16 /* Error */ || !equals(this.value, newVal) ? newVal : this.value;
+  }
   recalcWhen(fnOrKey, fn) {
+    if (this.flags & 8 /* Peeking */)
+      return;
     let trackers = fn ? obtrackers.get(fn) || setMap(obtrackers, fn, /* @__PURE__ */ new WeakMap()) : fntrackers;
     let signal = trackers.get(fnOrKey);
     if (!signal) {
@@ -465,35 +497,32 @@ class Cell {
   static mkCached(compute) {
     const cell = new Cell();
     cell.compute = compute;
-    cell.ctx = makeCtx(null, cell);
     cell.flags = 4 /* Compute */;
     return cell;
   }
   static mkRule(fn, q) {
     const outer = getJob(), cell = Cell.mkCached(() => {
       try {
-        cell.getJob();
         const cleanup = fn();
         if (cleanup)
-          (cell.ctx.job || cell.getJob()).must(cleanup);
-        cell.lastChanged = timestamp;
+          (cell.job || cell.getJob()).must(cleanup);
       } catch (e) {
         cell.stop();
         throw e;
       }
     }), stop = cell.stop.bind(cell);
     outer === detached || ruleStops.set(cell, outer.release(stop));
+    cell.flags |= 64 /* Stateful */;
     cell.setQ(q);
     return stop;
   }
 }
-function unchangedIf(newVal, equals = arrayEq) {
-  const { cell } = current;
-  if (cell) {
-    return cell.flags & 16 /* Error */ || !equals(cell.value, newVal) ? newVal : cell.value;
-  } else {
-    throw new Error("unchangedIf() must be called from a reactive expression");
-  }
+function getCell(f = "") {
+  if (!currentCell || currentCell.flags & 8 /* Peeking */)
+    throw new Error(
+      `${f}must be called from a reactive expression`
+    );
+  return currentCell;
 }
 
 class RF extends CallableObject {
@@ -649,29 +678,26 @@ function cached(compute, initVal) {
   );
 }
 function peek(fn, ...args) {
-  if (!current.cell)
-    return fn(...args);
-  const old = swapCtx(makeCtx(current.job));
-  try {
-    return fn(...args);
-  } finally {
-    freeCtx(swapCtx(old));
-  }
+  return currentCell ? currentCell.peek(fn, null, args) : fn(...args);
 }
 function action(fn, _ctx, desc) {
   if (desc)
     return { ...desc, value: action(desc.value) };
-  return function() {
-    if (!current.cell)
-      return apply(fn, this, arguments);
-    const old = swapCtx(makeCtx(current.job));
-    try {
-      return apply(fn, this, arguments);
-    } finally {
-      freeCtx(swapCtx(old));
-    }
+  return function(...args) {
+    return currentCell ? currentCell.peek(fn, this, args) : apply(fn, this, args);
   };
 }
+function stable(equals, newVal) {
+  return getCell("stabilizers ").unchangedIf(newVal, equals);
+}
+function unchangedIf(newVal, equals = arrayEq) {
+  return stable(equals, newVal);
+}
+function stabilizer(equals) {
+  return stable.bind(null, equals);
+}
+const stableArray = /* @__PURE__ */ stabilizer(arrayEq);
+const stableJSON = /* @__PURE__ */ stabilizer((a, b) => JSON.stringify(a) === JSON.stringify(b));
 function until(source) {
   return callOrWait(source, "uneventful.until", waitTruthy, recache);
 }
@@ -682,5 +708,4 @@ function waitTruthy(job, v) {
   v && job.return(v);
 }
 
-export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, unchangedIf, until, value };
-//# sourceMappingURL=signals.mjs.map
+export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, stabilizer, stable, stableArray, stableJSON, unchangedIf, until, value };

package/dist/{utils-DnMz1K-o.mjs → utils-cyEhnyp7.mjs}

@@ -79,6 +79,9 @@ const CallableObject = /* @__PURE__ */ (() => {
   return CallableObject2;
 })();
 const apply = Reflect.apply;
+function call(fn, thisArg, ...args) {
+  return thisArg ? apply(fn, thisArg, args) : args.length ? fn(...args) : fn();
+}
 const GeneratorBase = /* @__PURE__ */ (() => {
   function G() {
   }
@@ -90,5 +93,4 @@ function isGeneratorFunction(fn) {
   return isFunction(fn) && fn.prototype instanceof GeneratorBase;
 }
 
-export { CallableObject as C, GeneratorBase as G, isGeneratorFunction as a, decorateMethod as b, apply as c, defer as d, batch as e, arrayEq as f, isArray as g, isFunction as i, setMap as s };
-//# sourceMappingURL=utils-DnMz1K-o.mjs.map
+export { CallableObject as C, GeneratorBase as G, isGeneratorFunction as a, decorateMethod as b, apply as c, defer as d, batch as e, arrayEq as f, isArray as g, call as h, isFunction as i, setMap as s };

package/dist/utils.d.ts

@@ -106,6 +106,7 @@ declare function decorateMethod<F extends AnyFunction, D extends {
  * Shorthand for Array.isArray()
  *
  * @category Data Structures
+ * @function
  */
 declare const isArray: (arg: any) => arg is any[];
 /**
@@ -169,13 +170,25 @@ declare const CallableObject: new <T extends AnyFunction>(fn: T) => T;
  * elements of given array as the arguments.  (Shorthand for Reflect.apply)
  *
  * @category Functions and Decorators
+ * @function
  */
 declare const apply: typeof Reflect.apply;
+/**
+ * Like `fn.call(thisArg, ...args)`, but monomorphic, and the `thisArg`
+ * parameter can be omitted or null.
+ *
+ * This is mostly useful as syntax sugar for an immediately-evaluated function
+ * expression, replacing `(() => {...})()` with `call(() => {...})`.
+ *
+ * @category Functions and Decorators
+ */
+declare function call<F extends AnyFunction>(fn: F, thisArg?: ThisParameterType<F>, ...args: Parameters<F>): ReturnType<F>;
 /**
  * A pseudo-constructor for the abstract ancestor type of all generators,
  * useful for testing whether something is `instanceof Generator`.
  *
  * @category Data Structures
+ * @class
  */
 declare const GeneratorBase: abstract new () => Generator;
 /**
@@ -185,4 +198,4 @@ declare const GeneratorBase: abstract new () => Generator;
  */
 declare function isGeneratorFunction<G extends Generator<any, any, any> = Generator>(fn: any): fn is (this: any, ...args: any[]) => G;
 
-export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, decorateMethod, isArray, isFunction, isGeneratorFunction, setMap };
+export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, call, decorateMethod, isArray, isFunction, isGeneratorFunction, setMap };

package/dist/utils.mjs

@@ -1,2 +1 @@
-export { C as CallableObject, G as GeneratorBase, c as apply, f as arrayEq, e as batch, b as decorateMethod, g as isArray, i as isFunction, a as isGeneratorFunction, s as setMap } from './utils-DnMz1K-o.mjs';
-//# sourceMappingURL=utils.mjs.map
+export { C as CallableObject, G as GeneratorBase, c as apply, f as arrayEq, e as batch, h as call, b as decorateMethod, g as isArray, i as isFunction, a as isGeneratorFunction, s as setMap } from './utils-cyEhnyp7.mjs';