@graphrefly/graphrefly 0.27.0 → 0.28.0

package/dist/chunk-RNHBMHKA.js

@@ -1,1665 +0,0 @@
-import {
-  reactiveMap
-} from "./chunk-WKNUIZOY.js";
-import {
-  forEach,
-  fromAny
-} from "./chunk-BVZYTZ5H.js";
-import {
-  batch,
-  derived,
-  monotonicNs,
-  node,
-  producer,
-  state
-} from "./chunk-PHOUUNK7.js";
-import {
-  COMPLETE,
-  DATA,
-  DIRTY,
-  ERROR,
-  RESOLVED,
-  START
-} from "./chunk-SX52TAR4.js";
-
-// src/extra/backoff.ts
-var NS_PER_MS = 1e6;
-var NS_PER_SEC = 1e9;
-function clampNonNegative(value) {
-  return value < 0 ? 0 : value;
-}
-function applyJitter(delay2, jitter) {
-  if (jitter === "none") return delay2;
-  if (jitter === "full") return Math.random() * delay2;
-  return delay2 / 2 + Math.random() * (delay2 / 2);
-}
-function randomBetween(min, max) {
-  return min + Math.random() * (max - min);
-}
-function constant(delayNs) {
-  const safe = clampNonNegative(delayNs);
-  return () => safe;
-}
-function linear(baseNs, stepNs) {
-  const safeBase = clampNonNegative(baseNs);
-  const safeStep = stepNs === void 0 ? safeBase : clampNonNegative(stepNs);
-  return (attempt) => safeBase + safeStep * Math.max(0, attempt);
-}
-function exponential(options) {
-  const baseNs = clampNonNegative(options?.baseNs ?? 100 * NS_PER_MS);
-  const factor = options?.factor !== void 0 && options.factor < 1 ? 1 : options?.factor ?? 2;
-  const maxDelayNs = clampNonNegative(options?.maxDelayNs ?? 30 * NS_PER_SEC);
-  const jitter = options?.jitter ?? "none";
-  return (attempt) => {
-    let delay2;
-    if (baseNs === 0) {
-      delay2 = 0;
-    } else if (factor === 1) {
-      delay2 = baseNs;
-    } else {
-      const capRatio = maxDelayNs / baseNs;
-      let growth = 1;
-      for (let i = 0; i < Math.max(0, attempt); i++) {
-        if (growth >= capRatio) {
-          growth = capRatio;
-          break;
-        }
-        growth *= factor;
-      }
-      delay2 = baseNs * growth;
-      if (delay2 > maxDelayNs) delay2 = maxDelayNs;
-    }
-    return applyJitter(delay2, jitter);
-  };
-}
-function fibonacci(baseNs = 100 * NS_PER_MS, maxDelayNs = 30 * NS_PER_SEC) {
-  const safeBase = clampNonNegative(baseNs);
-  const safeMax = clampNonNegative(maxDelayNs);
-  function fibUnit(attempt) {
-    if (attempt <= 0) return 1;
-    let prev = 1;
-    let cur = 2;
-    for (let i = 1; i < attempt; i++) {
-      const next = prev + cur;
-      prev = cur;
-      cur = next;
-    }
-    return cur;
-  }
-  return (attempt) => {
-    const raw = fibUnit(attempt) * safeBase;
-    return raw <= safeMax ? raw : safeMax;
-  };
-}
-function decorrelatedJitter(baseNs = 100 * NS_PER_MS, maxNs = 30 * NS_PER_SEC) {
-  return (_attempt, _error, prevDelayNs) => {
-    const last2 = prevDelayNs ?? baseNs;
-    const ceiling = Math.min(maxNs, last2 * 3);
-    return randomBetween(baseNs, ceiling);
-  };
-}
-function withMaxAttempts(strategy, maxAttempts) {
-  return (attempt, error, prevDelayNs) => {
-    if (attempt >= maxAttempts) return null;
-    return strategy(attempt, error, prevDelayNs);
-  };
-}
-function resolveBackoffPreset(name) {
-  if (name === "constant") return constant(1 * NS_PER_SEC);
-  if (name === "linear") return linear(1 * NS_PER_SEC);
-  if (name === "exponential") return exponential();
-  if (name === "fibonacci") return fibonacci();
-  if (name === "decorrelatedJitter") return decorrelatedJitter();
-  throw new Error(
-    `Unknown backoff preset: "${String(name)}". Use one of: constant, linear, exponential, fibonacci, decorrelatedJitter`
-  );
-}
-
-// src/extra/operators.ts
-function operatorOpts(opts) {
-  return { describeKind: "derived", ...opts };
-}
-function map(source, project, opts) {
-  return node(
-    [source],
-    (data, a) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        a.emit(project(v));
-      }
-    },
-    operatorOpts(opts)
-  );
-}
-function filter(source, predicate, opts) {
-  return node(
-    [source],
-    (data, a) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const v of batch0) {
-        if (predicate(v)) {
-          a.emit(v);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function scan(source, reducer, seed, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("acc" in ctx.store)) ctx.store.acc = seed;
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        ctx.store.acc = reducer(ctx.store.acc, v);
-        a.emit(ctx.store.acc);
-      }
-    },
-    { ...operatorOpts(opts), initial: seed, resetOnTeardown: true }
-  );
-}
-function reduce(source, reducer, seed, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("acc" in ctx.store)) ctx.store.acc = seed;
-      if (ctx.terminalDeps[0] === true) {
-        a.emit(ctx.store.acc);
-        a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        ctx.store.acc = reducer(ctx.store.acc, v);
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function take(source, count, opts) {
-  if (count <= 0) {
-    return node(
-      [source],
-      (_d, a, ctx) => {
-        if (ctx.store.completed) return;
-        ctx.store.completed = true;
-        a.down([[COMPLETE]]);
-      },
-      {
-        ...operatorOpts(opts),
-        completeWhenDepsComplete: false
-      }
-    );
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("taken" in ctx.store)) ctx.store.taken = 0;
-      if (ctx.store.done) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        ctx.store.done = true;
-        a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        ctx.store.taken++;
-        a.emit(v);
-        if (ctx.store.taken >= count) {
-          ctx.store.done = true;
-          a.down([[COMPLETE]]);
-          return;
-        }
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function skip(source, count, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (!("skipped" in ctx.store)) ctx.store.skipped = 0;
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const v of batch0) {
-        ctx.store.skipped++;
-        if (ctx.store.skipped <= count) {
-        } else {
-          a.emit(v);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function takeWhile(source, predicate, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.store.done) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        if (!predicate(v)) {
-          ctx.store.done = true;
-          a.down([[COMPLETE]]);
-          return;
-        }
-        a.emit(v);
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function takeUntil(source, notifier, opts) {
-  const pred = opts?.predicate ?? ((m) => m[0] === DATA);
-  const { predicate: _, ...restOpts } = opts ?? {};
-  return producer(
-    (a) => {
-      let stopped = false;
-      const srcUnsub = source.subscribe((msgs) => {
-        if (stopped) return;
-        for (const m of msgs) {
-          if (stopped) return;
-          if (m[0] === DATA) a.emit(m[1]);
-          else if (m[0] === COMPLETE || m[0] === ERROR) {
-            stopped = true;
-            a.down([m]);
-          }
-        }
-      });
-      const notUnsub = notifier.subscribe((msgs) => {
-        if (stopped) return;
-        for (const m of msgs) {
-          if (stopped) return;
-          if (pred(m)) {
-            stopped = true;
-            a.down([[COMPLETE]]);
-            return;
-          }
-        }
-      });
-      return () => {
-        srcUnsub();
-        notUnsub();
-      };
-    },
-    operatorOpts(restOpts)
-  );
-}
-function first(source, opts) {
-  return take(source, 1, opts);
-}
-function last(source, options) {
-  const { defaultValue, ...rest } = options ?? {};
-  const useDefault = options != null && Object.hasOwn(options, "defaultValue");
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] === true) {
-        if (ctx.store.has) {
-          a.emit(ctx.store.latest);
-        } else if (useDefault) {
-          a.emit(defaultValue);
-        }
-        a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      ctx.store.latest = batch0.at(-1);
-      ctx.store.has = true;
-    },
-    {
-      ...operatorOpts(rest),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function find(source, predicate, opts) {
-  return take(filter(source, predicate, opts), 1, opts);
-}
-function elementAt(source, index, opts) {
-  return take(skip(source, index, opts), 1, opts);
-}
-function tap(source, fnOrObserver, opts) {
-  if (typeof fnOrObserver === "function") {
-    return node(
-      [source],
-      (data, a) => {
-        const batch0 = data[0];
-        if (batch0 == null || batch0.length === 0) {
-          a.down([[RESOLVED]]);
-          return;
-        }
-        for (const v of batch0) {
-          fnOrObserver(v);
-          a.emit(v);
-        }
-      },
-      operatorOpts(opts)
-    );
-  }
-  const obs = fnOrObserver;
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] !== void 0) {
-        if (ctx.terminalDeps[0] === true) {
-          obs.complete?.();
-          a.down([[COMPLETE]]);
-        } else {
-          obs.error?.(ctx.terminalDeps[0]);
-          a.down([[ERROR, ctx.terminalDeps[0]]]);
-        }
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) {
-        obs.data?.(v);
-        a.emit(v);
-      }
-    },
-    {
-      ...operatorOpts(opts),
-      completeWhenDepsComplete: false
-    }
-  );
-}
-function distinctUntilChanged(source, equals = Object.is, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const val of batch0) {
-        if (ctx.store.hasPrev && equals(ctx.store.prev, val)) {
-        } else {
-          ctx.store.prev = val;
-          ctx.store.hasPrev = true;
-          a.emit(val);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function pairwise(source, opts) {
-  return node(
-    [source],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      let emitted = false;
-      for (const x of batch0) {
-        if (!ctx.store.hasPrev) {
-          ctx.store.prev = x;
-          ctx.store.hasPrev = true;
-        } else {
-          const pair = [ctx.store.prev, x];
-          ctx.store.prev = x;
-          a.emit(pair);
-          emitted = true;
-        }
-      }
-      if (!emitted) a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-function combine(...sources) {
-  const deps = [...sources];
-  return derived(deps, (vals) => vals, {
-    ...operatorOpts(),
-    equals: (a, b) => {
-      if (a.length !== b.length) return false;
-      for (let i = 0; i < a.length; i++) {
-        if (!Object.is(a[i], b[i])) return false;
-      }
-      return true;
-    }
-  });
-}
-function withLatestFrom(primary, secondary, opts) {
-  return node(
-    [primary, secondary],
-    (data, a, ctx) => {
-      const batch0 = data[0];
-      const batch1 = data[1];
-      const secondaryVal = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (batch0 != null && batch0.length > 0) {
-        if (!(batch1 != null && batch1.length > 0) && ctx.prevData[1] === void 0) {
-          a.down([[RESOLVED]]);
-          return;
-        }
-        for (const v of batch0) {
-          a.emit([v, secondaryVal]);
-        }
-      } else {
-        a.down([[RESOLVED]]);
-      }
-    },
-    operatorOpts(opts)
-  );
-}
-function merge(...sources) {
-  if (sources.length === 0) {
-    return producer((a) => {
-      a.down([[COMPLETE]]);
-    }, operatorOpts());
-  }
-  return producer((a) => {
-    const n = sources.length;
-    let completed = 0;
-    const unsubs = [];
-    for (const src of sources) {
-      const u = src.subscribe((msgs) => {
-        for (const m of msgs) {
-          if (m[0] === DATA) {
-            a.emit(m[1]);
-          } else if (m[0] === COMPLETE) {
-            completed += 1;
-            if (completed >= n) {
-              a.down([[COMPLETE]]);
-            }
-          } else if (m[0] === ERROR) {
-            a.down([m]);
-          }
-        }
-      });
-      unsubs.push(u);
-    }
-    return () => {
-      for (const u of unsubs) u();
-    };
-  }, operatorOpts());
-}
-function zip(...sources) {
-  const n = sources.length;
-  if (n === 0) {
-    return producer((a) => {
-      a.emit([]);
-      a.down([[COMPLETE]]);
-    }, operatorOpts());
-  }
-  return producer((a) => {
-    const queues = Array.from({ length: n }, () => []);
-    let active = n;
-    function tryEmit() {
-      while (queues.every((q) => q.length > 0)) {
-        const tuple = queues.map((q) => q.shift());
-        a.emit(tuple);
-      }
-    }
-    const unsubs = [];
-    for (let i = 0; i < n; i++) {
-      const idx = i;
-      const u = sources[i].subscribe((msgs) => {
-        for (const m of msgs) {
-          if (m[0] === DATA) {
-            queues[idx].push(m[1]);
-            tryEmit();
-          } else if (m[0] === COMPLETE) {
-            active -= 1;
-            if (active === 0 || queues[idx].length === 0) {
-              a.down([[COMPLETE]]);
-            }
-          } else if (m[0] === ERROR) {
-            a.down([m]);
-          }
-        }
-      });
-      unsubs.push(u);
-    }
-    return () => {
-      for (const u of unsubs) u();
-    };
-  }, operatorOpts());
-}
-function concat(firstSrc, secondSrc, opts) {
-  return producer((a) => {
-    let phase = 0;
-    const pending = [];
-    let firstUnsub;
-    let secondUnsub;
-    secondUnsub = secondSrc.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (phase === 0) {
-          if (m[0] === DATA) pending.push(m[1]);
-          else if (m[0] === ERROR) a.down([m]);
-        } else {
-          if (m[0] === DATA) a.emit(m[1]);
-          else if (m[0] === COMPLETE || m[0] === ERROR) a.down([m]);
-        }
-      }
-    });
-    firstUnsub = firstSrc.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (phase === 0) {
-          if (m[0] === DATA) {
-            a.emit(m[1]);
-          } else if (m[0] === COMPLETE) {
-            phase = 1;
-            for (const v of pending) {
-              a.emit(v);
-            }
-            pending.length = 0;
-          } else if (m[0] === ERROR) {
-            a.down([m]);
-          }
-        }
-      }
-    });
-    return () => {
-      firstUnsub?.();
-      secondUnsub?.();
-    };
-  }, operatorOpts(opts));
-}
-function race(...sources) {
-  if (sources.length === 0) {
-    return producer((a) => {
-      a.down([[COMPLETE]]);
-    }, operatorOpts());
-  }
-  if (sources.length === 1) {
-    return node(
-      [sources[0]],
-      (data, a) => {
-        const batch0 = data[0];
-        if (batch0 == null || batch0.length === 0) {
-          a.down([[RESOLVED]]);
-          return;
-        }
-        for (const v of batch0) a.emit(v);
-      },
-      operatorOpts()
-    );
-  }
-  return producer((a) => {
-    let winner = null;
-    const unsubs = [];
-    for (let i = 0; i < sources.length; i++) {
-      const idx = i;
-      const u = sources[i].subscribe((msgs) => {
-        for (const m of msgs) {
-          if (winner !== null && idx !== winner) return;
-          if (m[0] === DATA) {
-            if (winner === null) winner = idx;
-            a.emit(m[1]);
-          } else if (m[0] === COMPLETE || m[0] === ERROR) {
-            if (winner === null || idx === winner) {
-              a.down([m]);
-            }
-          }
-        }
-      });
-      unsubs.push(u);
-    }
-    return () => {
-      for (const u of unsubs) u();
-    };
-  }, operatorOpts());
-}
-function forwardInner(inner, a, onInnerComplete) {
-  let unsub;
-  let finished = false;
-  const finish = () => {
-    if (finished) return;
-    finished = true;
-    onInnerComplete();
-  };
-  unsub = inner.subscribe((msgs) => {
-    let sawComplete = false;
-    let sawError = false;
-    for (const m of msgs) {
-      if (m[0] === START) continue;
-      if (m[0] === DATA) {
-        a.emit(m[1]);
-      } else if (m[0] === COMPLETE) {
-        sawComplete = true;
-      } else if (m[0] === ERROR) {
-        sawError = true;
-        a.down([m]);
-      } else if (m[0] === DIRTY || m[0] === RESOLVED) {
-        a.down([m]);
-      }
-    }
-    if (sawError) {
-      unsub?.();
-      unsub = void 0;
-      finish();
-    } else if (sawComplete) {
-      finish();
-    }
-  });
-  return () => {
-    unsub?.();
-    unsub = void 0;
-  };
-}
-function switchMap(source, project, opts) {
-  let innerUnsub;
-  let sourceDone = false;
-  function clearInner() {
-    innerUnsub?.();
-    innerUnsub = void 0;
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearInner();
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        if (!innerUnsub) a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      clearInner();
-      innerUnsub = forwardInner(fromAny(project(batch0[batch0.length - 1])), a, () => {
-        clearInner();
-        if (sourceDone) a.down([[COMPLETE]]);
-      });
-      return {
-        deactivation: () => {
-          clearInner();
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(opts), completeWhenDepsComplete: false }
-  );
-}
-function exhaustMap(source, project, opts) {
-  let innerUnsub;
-  let sourceDone = false;
-  function clearInner() {
-    innerUnsub?.();
-    innerUnsub = void 0;
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearInner();
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        if (!innerUnsub) a.down([[COMPLETE]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      if (innerUnsub === void 0) {
-        innerUnsub = forwardInner(fromAny(project(batch0[0])), a, () => {
-          clearInner();
-          if (sourceDone) a.down([[COMPLETE]]);
-        });
-      } else {
-        a.down([[RESOLVED]]);
-      }
-      return {
-        deactivation: () => {
-          clearInner();
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(opts), completeWhenDepsComplete: false }
-  );
-}
-function concatMap(source, project, opts) {
-  const { maxBuffer: maxBuf, ...concatNodeOpts } = opts ?? {};
-  const queue = [];
-  let innerUnsub;
-  let sourceDone = false;
-  let actions;
-  function clearInner() {
-    innerUnsub?.();
-    innerUnsub = void 0;
-  }
-  function tryPump() {
-    if (!actions || innerUnsub !== void 0) return;
-    if (queue.length === 0) {
-      if (sourceDone) actions.down([[COMPLETE]]);
-      return;
-    }
-    const v = queue.shift();
-    innerUnsub = forwardInner(fromAny(project(v)), actions, () => {
-      clearInner();
-      tryPump();
-    });
-  }
-  function enqueue(v) {
-    if (maxBuf && maxBuf > 0 && queue.length >= maxBuf) queue.shift();
-    queue.push(v);
-    tryPump();
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      actions = a;
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearInner();
-        queue.length = 0;
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        tryPump();
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      for (const v of batch0) {
-        enqueue(v);
-      }
-      return {
-        deactivation: () => {
-          clearInner();
-          queue.length = 0;
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(concatNodeOpts), completeWhenDepsComplete: false }
-  );
-}
-function mergeMap(source, project, opts) {
-  const { concurrent: concurrentOpt, ...mergeNodeOpts } = opts ?? {};
-  const maxConcurrent = concurrentOpt != null && concurrentOpt > 0 ? concurrentOpt : Number.POSITIVE_INFINITY;
-  let active = 0;
-  let sourceDone = false;
-  const innerStops = /* @__PURE__ */ new Set();
-  const buffer2 = [];
-  let actions;
-  function tryComplete() {
-    if (sourceDone && active === 0 && buffer2.length === 0 && actions) {
-      actions.down([[COMPLETE]]);
-    }
-  }
-  function spawn(v) {
-    if (!actions) return;
-    active++;
-    let stop;
-    stop = forwardInner(fromAny(project(v)), actions, () => {
-      if (stop) innerStops.delete(stop);
-      active--;
-      drainBuffer();
-      tryComplete();
-    });
-    innerStops.add(stop);
-  }
-  function drainBuffer() {
-    while (buffer2.length > 0 && active < maxConcurrent) {
-      spawn(buffer2.shift());
-    }
-  }
-  function enqueue(v) {
-    if (active < maxConcurrent) spawn(v);
-    else buffer2.push(v);
-  }
-  function clearAll() {
-    for (const u of innerStops) u();
-    innerStops.clear();
-    active = 0;
-    buffer2.length = 0;
-  }
-  return node(
-    [source],
-    (data, a, ctx) => {
-      actions = a;
-      if (ctx.terminalDeps[0] != null && ctx.terminalDeps[0] !== true) {
-        clearAll();
-        return;
-      }
-      if (ctx.terminalDeps[0] === true) {
-        sourceDone = true;
-        tryComplete();
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) return;
-      for (const v of batch0) {
-        enqueue(v);
-      }
-      return {
-        deactivation: () => {
-          clearAll();
-          sourceDone = false;
-        }
-      };
-    },
-    { ...operatorOpts(mergeNodeOpts), completeWhenDepsComplete: false }
-  );
-}
-var flatMap = mergeMap;
-function delay(source, ms, opts) {
-  return producer((a) => {
-    const timers = /* @__PURE__ */ new Set();
-    function clearAll() {
-      for (const id of timers) clearTimeout(id);
-      timers.clear();
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          const id = setTimeout(() => {
-            timers.delete(id);
-            a.emit(m[1]);
-          }, ms);
-          timers.add(id);
-        } else if (m[0] === COMPLETE) {
-          const id = setTimeout(() => {
-            timers.delete(id);
-            a.down([[COMPLETE]]);
-          }, ms);
-          timers.add(id);
-        } else if (m[0] === ERROR) {
-          clearAll();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearAll();
-    };
-  }, operatorOpts(opts));
-}
-function debounce(source, ms, opts) {
-  return producer((a) => {
-    let timer;
-    let pending;
-    function clearTimer() {
-      if (timer !== void 0) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          clearTimer();
-          pending = m[1];
-          timer = setTimeout(() => {
-            timer = void 0;
-            a.emit(pending);
-          }, ms);
-        } else if (m[0] === COMPLETE) {
-          if (timer !== void 0) {
-            clearTimer();
-            a.emit(pending);
-          }
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          clearTimer();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearTimer();
-    };
-  }, operatorOpts(opts));
-}
-function throttle(source, ms, opts) {
-  const { leading: leadingOpt, trailing: trailingOpt, ...throttleNodeOpts } = opts ?? {};
-  const leading = leadingOpt !== false;
-  const trailing = trailingOpt === true;
-  const windowNs = ms * NS_PER_MS;
-  return producer((a) => {
-    let timer;
-    let lastEmitNs = -Infinity;
-    let pending;
-    let hasPending = false;
-    function clearTimer() {
-      if (timer !== void 0) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          const v = m[1];
-          const nowNs = monotonicNs();
-          if (leading && nowNs - lastEmitNs >= windowNs) {
-            lastEmitNs = nowNs;
-            a.emit(v);
-            clearTimer();
-            if (trailing) {
-              timer = setTimeout(() => {
-                timer = void 0;
-                if (hasPending) {
-                  lastEmitNs = monotonicNs();
-                  a.emit(pending);
-                  hasPending = false;
-                }
-              }, ms);
-            }
-          } else if (trailing) {
-            pending = v;
-            hasPending = true;
-            if (timer === void 0) {
-              const elapsedMs = (nowNs - lastEmitNs) / NS_PER_MS;
-              timer = setTimeout(
-                () => {
-                  timer = void 0;
-                  if (hasPending) {
-                    lastEmitNs = monotonicNs();
-                    a.emit(pending);
-                    hasPending = false;
-                  }
-                },
-                Math.max(0, ms - elapsedMs)
-              );
-            }
-          }
-        } else if (m[0] === COMPLETE || m[0] === ERROR) {
-          clearTimer();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearTimer();
-    };
-  }, operatorOpts(throttleNodeOpts));
-}
-function sample(source, notifier, opts) {
-  return producer((a) => {
-    let lastSourceValue;
-    let terminated = false;
-    let sourceCompleted = false;
-    const srcUnsub = source.subscribe((msgs) => {
-      if (terminated) return;
-      for (const m of msgs) {
-        if (terminated) return;
-        if (m[0] === DATA) {
-          lastSourceValue = { v: m[1] };
-        } else if (m[0] === ERROR) {
-          terminated = true;
-          a.down([m]);
-        } else if (m[0] === COMPLETE) {
-          sourceCompleted = true;
-          lastSourceValue = void 0;
-        }
-      }
-    });
-    const notUnsub = notifier.subscribe((msgs) => {
-      if (terminated) return;
-      for (const m of msgs) {
-        if (terminated) return;
-        if (m[0] === DATA) {
-          if (lastSourceValue !== void 0 && !sourceCompleted) {
-            a.emit(lastSourceValue.v);
-          }
-        } else if (m[0] === ERROR) {
-          terminated = true;
-          a.down([m]);
-        } else if (m[0] === COMPLETE) {
-          terminated = true;
-          a.down([[COMPLETE]]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      notUnsub();
-    };
-  }, operatorOpts(opts));
-}
-function audit(source, ms, opts) {
-  return producer((a) => {
-    let timer;
-    let latest;
-    let has = false;
-    function clearTimer() {
-      if (timer !== void 0) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          latest = m[1];
-          has = true;
-          clearTimer();
-          timer = setTimeout(() => {
-            timer = void 0;
-            if (has) {
-              has = false;
-              a.emit(latest);
-            }
-          }, ms);
-        } else if (m[0] === COMPLETE || m[0] === ERROR) {
-          clearTimer();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearTimer();
-    };
-  }, operatorOpts(opts));
-}
-function buffer(source, notifier, opts) {
-  return producer((a) => {
-    const buf = [];
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          buf.push(m[1]);
-        } else if (m[0] === COMPLETE) {
-          if (buf.length > 0) a.emit([...buf]);
-          buf.length = 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          a.down([m]);
-        }
-      }
-    });
-    const notUnsub = notifier.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          if (buf.length > 0) {
-            a.emit([...buf]);
-            buf.length = 0;
-          }
-        } else if (m[0] === COMPLETE) {
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      notUnsub();
-      buf.length = 0;
-    };
-  }, operatorOpts(opts));
-}
-function bufferCount(source, count, opts) {
-  if (count <= 0) throw new RangeError("bufferCount expects count > 0");
-  return producer((a) => {
-    const buf = [];
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          buf.push(m[1]);
-          if (buf.length >= count) {
-            a.emit(buf.splice(0, buf.length));
-          }
-        } else if (m[0] === COMPLETE) {
-          if (buf.length > 0) a.emit([...buf]);
-          buf.length = 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      buf.length = 0;
-    };
-  }, operatorOpts(opts));
-}
-function windowCount(source, count, opts) {
-  if (count <= 0) throw new RangeError("windowCount expects count > 0");
-  return producer((a) => {
-    let winDown;
-    let n = 0;
-    function openWindow() {
-      const s = producer((actions) => {
-        winDown = actions.down.bind(actions);
-        return () => {
-          winDown = void 0;
-        };
-      }, operatorOpts());
-      n = 0;
-      a.emit(s);
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          if (!winDown) openWindow();
-          winDown?.([[DATA, m[1]]]);
-          n += 1;
-          if (n >= count) {
-            winDown?.([[COMPLETE]]);
-            winDown = void 0;
-          }
-        } else if (m[0] === COMPLETE) {
-          winDown?.([[COMPLETE]]);
-          winDown = void 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          winDown?.([m]);
-          winDown = void 0;
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      winDown?.([[COMPLETE]]);
-      winDown = void 0;
-    };
-  }, operatorOpts(opts));
-}
-function bufferTime(source, ms, opts) {
-  return producer((a) => {
-    const buf = [];
-    const iv = setInterval(() => {
-      if (buf.length > 0) {
-        a.emit([...buf]);
-        buf.length = 0;
-      }
-    }, ms);
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          buf.push(m[1]);
-        } else if (m[0] === COMPLETE) {
-          clearInterval(iv);
-          if (buf.length > 0) a.emit([...buf]);
-          buf.length = 0;
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          clearInterval(iv);
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearInterval(iv);
-      buf.length = 0;
-    };
-  }, operatorOpts(opts));
-}
-function windowTime(source, ms, opts) {
-  return producer((a) => {
-    let winDown;
-    function closeWindow() {
-      winDown?.([[COMPLETE]]);
-      winDown = void 0;
-    }
-    function openWindow() {
-      const s = producer((actions) => {
-        winDown = actions.down.bind(actions);
-        return () => {
-          winDown = void 0;
-        };
-      }, operatorOpts());
-      a.emit(s);
-    }
-    openWindow();
-    const iv = setInterval(() => {
-      closeWindow();
-      openWindow();
-    }, ms);
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          winDown?.([[DATA, m[1]]]);
-        } else if (m[0] === COMPLETE) {
-          clearInterval(iv);
-          closeWindow();
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          clearInterval(iv);
-          winDown?.([m]);
-          closeWindow();
-          a.down([m]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      clearInterval(iv);
-      closeWindow();
-    };
-  }, operatorOpts(opts));
-}
-function window(source, notifier, opts) {
-  return producer((a) => {
-    let winDown;
-    function closeWindow() {
-      winDown?.([[COMPLETE]]);
-      winDown = void 0;
-    }
-    function openWindow() {
-      const s = producer((actions) => {
-        winDown = actions.down.bind(actions);
-        return () => {
-          winDown = void 0;
-        };
-      }, operatorOpts());
-      a.emit(s);
-    }
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          if (!winDown) openWindow();
-          winDown?.([[DATA, m[1]]]);
-        } else if (m[0] === COMPLETE) {
-          closeWindow();
-          a.down([[COMPLETE]]);
-        } else if (m[0] === ERROR) {
-          winDown?.([m]);
-          winDown = void 0;
-          a.down([m]);
-        }
-      }
-    });
-    const notUnsub = notifier.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          closeWindow();
-          openWindow();
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-      notUnsub();
-      closeWindow();
-    };
-  }, operatorOpts(opts));
-}
-function interval(periodMs, opts) {
-  return producer((a, ctx) => {
-    if (!("n" in ctx.store)) ctx.store.n = 0;
-    const id = setInterval(() => {
-      a.emit(ctx.store.n);
-      ctx.store.n = ctx.store.n + 1;
-    }, periodMs);
-    return () => clearInterval(id);
-  }, operatorOpts(opts));
-}
-function repeat(source, count, opts) {
-  if (count <= 0) throw new RangeError("repeat expects count > 0");
-  return producer((a) => {
-    let remaining = count;
-    let innerU;
-    const start = () => {
-      innerU?.();
-      innerU = source.subscribe((msgs) => {
-        let completed = false;
-        const fwd = [];
-        for (const m of msgs) {
-          if (m[0] === COMPLETE) completed = true;
-          else fwd.push(m);
-        }
-        if (fwd.length > 0) a.down(fwd);
-        if (completed) {
-          innerU?.();
-          innerU = void 0;
-          remaining -= 1;
-          if (remaining > 0) start();
-          else a.down([[COMPLETE]]);
-        }
-      });
-    };
-    start();
-    return () => {
-      innerU?.();
-    };
-  }, operatorOpts(opts));
-}
-function pausable(source, opts) {
-  return node(
-    [source],
-    (data, a) => {
-      const batch0 = data[0];
-      if (batch0 == null || batch0.length === 0) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      for (const v of batch0) a.emit(v);
-    },
-    operatorOpts(opts)
-  );
-}
-function rescue(source, recover, opts) {
-  return producer((a) => {
-    const srcUnsub = source.subscribe((msgs) => {
-      for (const m of msgs) {
-        if (m[0] === DATA) {
-          a.emit(m[1]);
-        } else if (m[0] === ERROR) {
-          try {
-            a.emit(recover(m[1]));
-          } catch (recoverErr) {
-            a.down([[ERROR, recoverErr]]);
-          }
-        } else if (m[0] === COMPLETE) {
-          a.down([[COMPLETE]]);
-        }
-      }
-    });
-    return () => {
-      srcUnsub();
-    };
-  }, operatorOpts(opts));
-}
-function valve(source, control, opts) {
-  return node(
-    [source, control],
-    (data, a, ctx) => {
-      const batch1 = data[1];
-      const controlValue = batch1 != null && batch1.length > 0 ? batch1.at(-1) : ctx.prevData[1];
-      if (!controlValue) {
-        a.down([[RESOLVED]]);
-        return;
-      }
-      const batch0 = data[0];
-      if (batch0 != null && batch0.length > 0) {
-        for (const v of batch0) a.emit(v);
-        return;
-      }
-      if (batch1 != null && batch1.length > 0 && ctx.prevData[0] !== void 0) {
-        a.emit(ctx.prevData[0]);
-        return;
-      }
-      a.down([[RESOLVED]]);
-    },
-    operatorOpts(opts)
-  );
-}
-var combineLatest = combine;
-var debounceTime = debounce;
-var throttleTime = throttle;
-var catchError = rescue;
-
-// src/extra/composite.ts
-function isNodeLike(value) {
-  return typeof value === "object" && value !== null && "cache" in value && typeof value.subscribe === "function";
-}
-function verifiable(source, verifyFn, opts) {
-  const sourceNode = fromAny(source);
-  const hasSourceVersioning = sourceNode.v != null;
-  const verified = state(opts?.initialVerified ?? null, {
-    ...hasSourceVersioning ? { meta: { sourceVersion: null } } : {}
-  });
-  const hasTrigger = opts?.trigger !== void 0 && opts.trigger !== null;
-  let triggerNode = null;
-  if (hasTrigger && opts?.autoVerify) {
-    triggerNode = merge(fromAny(opts.trigger), sourceNode);
-  } else if (hasTrigger) {
-    triggerNode = fromAny(opts.trigger);
-  } else if (opts?.autoVerify) {
-    triggerNode = sourceNode;
-  }
-  if (triggerNode !== null) {
-    let verifyStream;
-    if (triggerNode === sourceNode) {
-      verifyStream = switchMap(sourceNode, (src) => verifyFn(src));
-    } else {
-      let latestSource = sourceNode.cache;
-      sourceNode.subscribe((msgs) => {
-        for (const m of msgs) {
-          if (m[0] === DATA) latestSource = m[1];
-        }
-      });
-      verifyStream = switchMap(triggerNode, () => verifyFn(latestSource));
-    }
-    forEach(verifyStream, (value) => {
-      batch(() => {
-        verified.down([[DATA, value]]);
-        if (hasSourceVersioning) {
-          const sv = sourceNode.v;
-          if (sv != null) {
-            verified.meta.sourceVersion.down([[DATA, { id: sv.id, version: sv.version }]]);
-          }
-        }
-      });
-    });
-  }
-  return { node: sourceNode, verified, trigger: triggerNode };
-}
-function keepalive(node2) {
-  node2.subscribe(() => void 0);
-}
-function mapFromSnapshot(snapshot) {
-  if (snapshot instanceof Map) return snapshot;
-  return /* @__PURE__ */ new Map();
-}
-function applyExtraction(store, extraction) {
-  if (!Array.isArray(extraction.upsert)) {
-    throw new TypeError("distill extraction requires upsert: Array<{ key, value }>");
-  }
-  batch(() => {
-    for (const { key, value } of extraction.upsert) {
-      store.set(key, value);
-    }
-    for (const key of extraction.remove ?? []) {
-      store.delete(key);
-    }
-  });
-}
-function distill(source, extractFn, opts) {
-  const sourceNode = fromAny(source);
-  const store = reactiveMap(opts.mapOptions ?? {});
-  const budget = opts.budget ?? 2e3;
-  const hasContext = opts.context !== void 0 && opts.context !== null;
-  const contextNode = hasContext ? fromAny(opts.context) : state(null);
-  let latestStore = mapFromSnapshot(store.entries.cache);
-  store.entries.subscribe((msgs) => {
-    for (const m of msgs) {
-      if (m[0] === DATA) latestStore = mapFromSnapshot(m[1]);
-    }
-  });
-  const extractionStream = switchMap(sourceNode, (raw) => extractFn(raw, latestStore));
-  forEach(extractionStream, (extraction) => {
-    applyExtraction(store, extraction);
-  });
-  if (opts.evict) {
-    const verdictUnsubs = /* @__PURE__ */ new Map();
-    const evictionKeys = derived([store.entries], ([snapshot]) => {
-      const out = [];
-      const entries = mapFromSnapshot(snapshot);
-      for (const key of verdictUnsubs.keys()) {
-        if (!entries.has(key)) {
-          verdictUnsubs.get(key)();
-          verdictUnsubs.delete(key);
-        }
-      }
-      for (const [key, mem] of entries) {
-        const verdict = opts.evict(key, mem);
-        if (isNodeLike(verdict)) {
-          if (!verdictUnsubs.has(key)) {
-            const unsub = forEach(verdict, (val) => {
-              if (val === true && store.has(key)) {
-                store.delete(key);
-              }
-            });
-            verdictUnsubs.set(key, unsub);
-          }
-          continue;
-        }
-        if (typeof verdict === "boolean") {
-          if (verdict) out.push(key);
-          continue;
-        }
-        throw new TypeError("distill evict() must return boolean or Node<boolean>");
-      }
-      return out;
-    });
-    forEach(evictionKeys, (keys) => {
-      for (const key of keys) store.delete(key);
-    });
-  }
-  const hasConsolidateTrigger = opts.consolidateTrigger !== void 0 && opts.consolidateTrigger !== null;
-  if (opts.consolidate && hasConsolidateTrigger) {
-    const consolidateTriggerNode = fromAny(opts.consolidateTrigger);
-    const consolidationStream = switchMap(
-      consolidateTriggerNode,
-      () => opts.consolidate(latestStore)
-    );
-    forEach(consolidationStream, (extraction) => {
-      applyExtraction(store, extraction);
-    });
-  }
-  const compact = derived([store.entries, contextNode], ([snapshot, context]) => {
-    const entries = [...mapFromSnapshot(snapshot).entries()].map(([key, value]) => ({
-      key,
-      value,
-      score: opts.score(value, context),
-      cost: opts.cost(value)
-    }));
-    entries.sort((a, b) => b.score - a.score);
-    const packed = [];
-    let remaining = budget;
-    for (const item of entries) {
-      if (item.cost <= remaining) {
-        packed.push({ key: item.key, value: item.value, score: item.score });
-        remaining -= item.cost;
-      }
-    }
-    return packed;
-  });
-  const size = derived([store.entries], ([snapshot]) => mapFromSnapshot(snapshot).size);
-  keepalive(compact);
-  keepalive(size);
-  return { store, compact, size };
-}
-
-export {
-  NS_PER_MS,
-  NS_PER_SEC,
-  constant,
-  linear,
-  exponential,
-  fibonacci,
-  decorrelatedJitter,
-  withMaxAttempts,
-  resolveBackoffPreset,
-  map,
-  filter,
-  scan,
-  reduce,
-  take,
-  skip,
-  takeWhile,
-  takeUntil,
-  first,
-  last,
-  find,
-  elementAt,
-  tap,
-  distinctUntilChanged,
-  pairwise,
-  combine,
-  withLatestFrom,
-  merge,
-  zip,
-  concat,
-  race,
-  switchMap,
-  exhaustMap,
-  concatMap,
-  mergeMap,
-  flatMap,
-  delay,
-  debounce,
-  throttle,
-  sample,
-  audit,
-  buffer,
-  bufferCount,
-  windowCount,
-  bufferTime,
-  windowTime,
-  window,
-  interval,
-  repeat,
-  pausable,
-  rescue,
-  valve,
-  combineLatest,
-  debounceTime,
-  throttleTime,
-  catchError,
-  verifiable,
-  distill
-};
-//# sourceMappingURL=chunk-RNHBMHKA.js.map