@graphrefly/graphrefly 0.25.0 → 0.27.0

package/dist/chunk-RNHBMHKA.js

@@ -0,0 +1,1665 @@
+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