effect 2.0.0-next.37 → 2.0.0-next.39

package/dist/Hub-9f3d5c5d.esm.js

@@ -1,1264 +0,0 @@
-import { f as fromIterable, u as unsafeGet, d as drop, e as empty, i as isEmpty$2, a as unsafeHead, o as of, b as appendAll, c as append, g as filter, p as prepend } from './Chunk-98371336.esm.js';
-import { p as pipe, d as dual } from './Function-52fb7d21.esm.js';
-import { f as flatMap, s as sync, m as map, d as deferredMake, I as InvalidHubCapacityException, a as suspend, i as interrupt, b as deferredAwait, u as uninterruptible, w as withFiberRuntime, c as asUnit, e as whenEffect, g as deferredSucceed, z as zipRight, h as exitInterrupt, j as succeed, t as tap, k as deferredInterruptWith, l as deferredUnsafeMake, o as onInterrupt, n as fiberId, p as unit, q as deferredUnsafeDone } from './core-9f5f0dc2.esm.js';
-import { s as sequential } from './ExecutionStrategy-c6f7c490.esm.js';
-import { s as scopeMake, a as all, b as acquireRelease, f as forEachParUnbounded, c as forEachParUnboundedDiscard } from './fiberRuntime-98f09d31.esm.js';
-import { E as EnqueueTypeId, e as enqueueVariance, D as DequeueTypeId, d as dequeueVariance } from './queue-b79c472d.esm.js';
-import { u as unbounded$2, i as isEmpty$3, E as EmptyMutableQueue, o as offer, p as pollUpTo, a as poll, b as offerAll } from './MutableQueue-54a4b584.esm.js';
-import { m as make, g as get, s as set } from './MutableRef-cb4d2fc0.esm.js';
-import { n as none, s as some } from './Option-1d073850.esm.js';
-import { p as pipeArguments } from './Pipeable-fe51dc02.esm.js';
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-const addSubscribers = (subscription, pollers) => subscribers => {
-  if (!subscribers.has(subscription)) {
-    subscribers.set(subscription, new Set());
-  }
-  const set = subscribers.get(subscription);
-  set.add(pollers);
-};
-const removeSubscribers = (subscription, pollers) => subscribers => {
-  if (!subscribers.has(subscription)) {
-    return;
-  }
-  const set = subscribers.get(subscription);
-  set.delete(pollers);
-  if (set.size === 0) {
-    subscribers.delete(subscription);
-  }
-};
-
-/** @internal */
-const bounded$1 = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new BackPressureStrategy())));
-
-/** @internal */
-const dropping$1 = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
-
-/** @internal */
-const sliding$1 = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new SlidingStrategy())));
-
-/** @internal */
-const unbounded$1 = () => pipe(sync(() => makeUnboundedHub()), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
-
-/** @internal */
-const capacity$1 = self => self.capacity();
-
-/** @internal */
-const size$1 = self => self.size();
-
-/** @internal */
-const isFull$1 = self => self.isFull();
-
-/** @internal */
-const isEmpty$1 = self => self.isEmpty();
-
-/** @internal */
-const shutdown$1 = self => self.shutdown();
-
-/** @internal */
-const isShutdown$1 = self => self.isShutdown();
-
-/** @internal */
-const awaitShutdown$1 = self => self.awaitShutdown();
-
-/** @internal */
-const publish$1 = /*#__PURE__*/dual(2, (self, value) => self.publish(value));
-
-/** @internal */
-const publishAll$1 = /*#__PURE__*/dual(2, (self, elements) => self.publishAll(elements));
-
-/** @internal */
-const subscribe$1 = self => self.subscribe();
-
-/** @internal */
-const makeBoundedHub = requestedCapacity => {
-  ensureCapacity(requestedCapacity);
-  if (requestedCapacity === 1) {
-    return new BoundedHubSingle();
-  } else if (nextPow2(requestedCapacity) === requestedCapacity) {
-    return new BoundedHubPow2(requestedCapacity);
-  } else {
-    return new BoundedHubArb(requestedCapacity);
-  }
-};
-
-/** @internal */
-const makeUnboundedHub = () => {
-  return new UnboundedHub();
-};
-
-/** @internal */
-const makeSubscription = (hub, subscribers, strategy) => map(deferredMake(), deferred => unsafeMakeSubscription(hub, subscribers, hub.subscribe(), unbounded$2(), deferred, make(false), strategy));
-
-/** @internal */
-const unsafeMakeSubscription = (hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => {
-  return new SubscriptionImpl(hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy);
-};
-
-/** @internal */
-class BoundedHubArb {
-  publisherIndex = 0;
-  subscriberCount = 0;
-  subscribersIndex = 0;
-  constructor(requestedCapacity) {
-    this.array = Array.from({
-      length: requestedCapacity
-    });
-    this.subscribers = Array.from({
-      length: requestedCapacity
-    });
-    this.capacity = requestedCapacity;
-  }
-  isEmpty() {
-    return this.publisherIndex === this.subscribersIndex;
-  }
-  isFull() {
-    return this.publisherIndex === this.subscribersIndex + this.capacity;
-  }
-  size() {
-    return this.publisherIndex - this.subscribersIndex;
-  }
-  publish(value) {
-    if (this.isFull()) {
-      return false;
-    }
-    if (this.subscriberCount !== 0) {
-      const index = this.publisherIndex % this.capacity;
-      this.array[index] = value;
-      this.subscribers[index] = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return true;
-  }
-  publishAll(elements) {
-    const chunk = fromIterable(elements);
-    const n = chunk.length;
-    const size = this.publisherIndex - this.subscribersIndex;
-    const available = this.capacity - size;
-    const forHub = Math.min(n, available);
-    if (forHub === 0) {
-      return chunk;
-    }
-    let iteratorIndex = 0;
-    const publishAllIndex = this.publisherIndex + forHub;
-    while (this.publisherIndex !== publishAllIndex) {
-      const a = unsafeGet(chunk, iteratorIndex++);
-      const index = this.publisherIndex % this.capacity;
-      this.array[index] = a;
-      this.subscribers[index] = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return drop(chunk, iteratorIndex);
-  }
-  slide() {
-    if (this.subscribersIndex !== this.publisherIndex) {
-      const index = this.subscribersIndex % this.capacity;
-      this.array[index] = null;
-      this.subscribers[index] = 0;
-      this.subscribersIndex += 1;
-    }
-  }
-  subscribe() {
-    this.subscriberCount += 1;
-    return new BoundedHubArbSubscription(this, this.publisherIndex, false);
-  }
-}
-class BoundedHubArbSubscription {
-  constructor(self, subscriberIndex, unsubscribed) {
-    this.self = self;
-    this.subscriberIndex = subscriberIndex;
-    this.unsubscribed = unsubscribed;
-  }
-  isEmpty() {
-    return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
-  }
-  size() {
-    if (this.unsubscribed) {
-      return 0;
-    }
-    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
-  }
-  poll(default_) {
-    if (this.unsubscribed) {
-      return default_;
-    }
-    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-    if (this.subscriberIndex !== this.self.publisherIndex) {
-      const index = this.subscriberIndex % this.self.capacity;
-      const elem = this.self.array[index];
-      this.self.subscribers[index] -= 1;
-      if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null;
-        this.self.subscribersIndex += 1;
-      }
-      this.subscriberIndex += 1;
-      return elem;
-    }
-    return default_;
-  }
-  pollUpTo(n) {
-    if (this.unsubscribed) {
-      return empty();
-    }
-    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-    const size = this.self.publisherIndex - this.subscriberIndex;
-    const toPoll = Math.min(n, size);
-    if (toPoll <= 0) {
-      return empty();
-    }
-    const builder = [];
-    const pollUpToIndex = this.subscriberIndex + toPoll;
-    while (this.subscriberIndex !== pollUpToIndex) {
-      const index = this.subscriberIndex % this.self.capacity;
-      const a = this.self.array[index];
-      this.self.subscribers[index] -= 1;
-      if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null;
-        this.self.subscribersIndex += 1;
-      }
-      builder.push(a);
-      this.subscriberIndex += 1;
-    }
-    return fromIterable(builder);
-  }
-  unsubscribe() {
-    if (!this.unsubscribed) {
-      this.unsubscribed = true;
-      this.self.subscriberCount -= 1;
-      this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-      while (this.subscriberIndex !== this.self.publisherIndex) {
-        const index = this.subscriberIndex % this.self.capacity;
-        this.self.subscribers[index] -= 1;
-        if (this.self.subscribers[index] === 0) {
-          this.self.array[index] = null;
-          this.self.subscribersIndex += 1;
-        }
-        this.subscriberIndex += 1;
-      }
-    }
-  }
-}
-
-/** @internal */
-class BoundedHubPow2 {
-  publisherIndex = 0;
-  subscriberCount = 0;
-  subscribersIndex = 0;
-  constructor(requestedCapacity) {
-    this.array = Array.from({
-      length: requestedCapacity
-    });
-    this.mask = requestedCapacity - 1;
-    this.subscribers = Array.from({
-      length: requestedCapacity
-    });
-    this.capacity = requestedCapacity;
-  }
-  isEmpty() {
-    return this.publisherIndex === this.subscribersIndex;
-  }
-  isFull() {
-    return this.publisherIndex === this.subscribersIndex + this.capacity;
-  }
-  size() {
-    return this.publisherIndex - this.subscribersIndex;
-  }
-  publish(value) {
-    if (this.isFull()) {
-      return false;
-    }
-    if (this.subscriberCount !== 0) {
-      const index = this.publisherIndex & this.mask;
-      this.array[index] = value;
-      this.subscribers[index] = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return true;
-  }
-  publishAll(elements) {
-    const chunk = fromIterable(elements);
-    const n = chunk.length;
-    const size = this.publisherIndex - this.subscribersIndex;
-    const available = this.capacity - size;
-    const forHub = Math.min(n, available);
-    if (forHub === 0) {
-      return chunk;
-    }
-    let iteratorIndex = 0;
-    const publishAllIndex = this.publisherIndex + forHub;
-    while (this.publisherIndex !== publishAllIndex) {
-      const elem = unsafeGet(chunk, iteratorIndex++);
-      const index = this.publisherIndex & this.mask;
-      this.array[index] = elem;
-      this.subscribers[index] = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return drop(chunk, iteratorIndex);
-  }
-  slide() {
-    if (this.subscribersIndex !== this.publisherIndex) {
-      const index = this.subscribersIndex & this.mask;
-      this.array[index] = null;
-      this.subscribers[index] = 0;
-      this.subscribersIndex += 1;
-    }
-  }
-  subscribe() {
-    this.subscriberCount += 1;
-    return new BoundedHubPow2Subscription(this, this.publisherIndex, false);
-  }
-}
-
-/** @internal */
-class BoundedHubPow2Subscription {
-  constructor(self, subscriberIndex, unsubscribed) {
-    this.self = self;
-    this.subscriberIndex = subscriberIndex;
-    this.unsubscribed = unsubscribed;
-  }
-  isEmpty() {
-    return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
-  }
-  size() {
-    if (this.unsubscribed) {
-      return 0;
-    }
-    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
-  }
-  poll(default_) {
-    if (this.unsubscribed) {
-      return default_;
-    }
-    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-    if (this.subscriberIndex !== this.self.publisherIndex) {
-      const index = this.subscriberIndex & this.self.mask;
-      const elem = this.self.array[index];
-      this.self.subscribers[index] -= 1;
-      if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null;
-        this.self.subscribersIndex += 1;
-      }
-      this.subscriberIndex += 1;
-      return elem;
-    }
-    return default_;
-  }
-  pollUpTo(n) {
-    if (this.unsubscribed) {
-      return empty();
-    }
-    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-    const size = this.self.publisherIndex - this.subscriberIndex;
-    const toPoll = Math.min(n, size);
-    if (toPoll <= 0) {
-      return empty();
-    }
-    const builder = [];
-    const pollUpToIndex = this.subscriberIndex + toPoll;
-    while (this.subscriberIndex !== pollUpToIndex) {
-      const index = this.subscriberIndex & this.self.mask;
-      const elem = this.self.array[index];
-      this.self.subscribers[index] -= 1;
-      if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null;
-        this.self.subscribersIndex += 1;
-      }
-      builder.push(elem);
-      this.subscriberIndex += 1;
-    }
-    return fromIterable(builder);
-  }
-  unsubscribe() {
-    if (!this.unsubscribed) {
-      this.unsubscribed = true;
-      this.self.subscriberCount -= 1;
-      this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-      while (this.subscriberIndex !== this.self.publisherIndex) {
-        const index = this.subscriberIndex & this.self.mask;
-        this.self.subscribers[index] -= 1;
-        if (this.self.subscribers[index] === 0) {
-          this.self.array[index] = null;
-          this.self.subscribersIndex += 1;
-        }
-        this.subscriberIndex += 1;
-      }
-    }
-  }
-}
-
-/** @internal */
-class BoundedHubSingle {
-  publisherIndex = 0;
-  subscriberCount = 0;
-  subscribers = 0;
-  value = null;
-  capacity = 1;
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  isEmpty() {
-    return this.subscribers === 0;
-  }
-  isFull() {
-    return !this.isEmpty();
-  }
-  size() {
-    return this.isEmpty() ? 0 : 1;
-  }
-  publish(value) {
-    if (this.isFull()) {
-      return false;
-    }
-    if (this.subscriberCount !== 0) {
-      this.value = value;
-      this.subscribers = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return true;
-  }
-  publishAll(elements) {
-    const chunk = fromIterable(elements);
-    if (isEmpty$2(chunk)) {
-      return chunk;
-    }
-    if (this.publish(unsafeHead(chunk))) {
-      return drop(chunk, 1);
-    } else {
-      return chunk;
-    }
-  }
-  slide() {
-    if (this.isFull()) {
-      this.subscribers = 0;
-      this.value = null;
-    }
-  }
-  subscribe() {
-    this.subscriberCount += 1;
-    return new BoundedHubSingleSubscription(this, this.publisherIndex, false);
-  }
-}
-
-/** @internal */
-class BoundedHubSingleSubscription {
-  constructor(self, subscriberIndex, unsubscribed) {
-    this.self = self;
-    this.subscriberIndex = subscriberIndex;
-    this.unsubscribed = unsubscribed;
-  }
-  isEmpty() {
-    return this.unsubscribed || this.self.subscribers === 0 || this.subscriberIndex === this.self.publisherIndex;
-  }
-  size() {
-    return this.isEmpty() ? 0 : 1;
-  }
-  poll(default_) {
-    if (this.isEmpty()) {
-      return default_;
-    }
-    const elem = this.self.value;
-    this.self.subscribers -= 1;
-    if (this.self.subscribers === 0) {
-      this.self.value = null;
-    }
-    this.subscriberIndex += 1;
-    return elem;
-  }
-  pollUpTo(n) {
-    if (this.isEmpty() || n < 1) {
-      return empty();
-    }
-    const a = this.self.value;
-    this.self.subscribers -= 1;
-    if (this.self.subscribers === 0) {
-      this.self.value = null;
-    }
-    this.subscriberIndex += 1;
-    return of(a);
-  }
-  unsubscribe() {
-    if (!this.unsubscribed) {
-      this.unsubscribed = true;
-      this.self.subscriberCount -= 1;
-      if (this.subscriberIndex !== this.self.publisherIndex) {
-        this.self.subscribers -= 1;
-        if (this.self.subscribers === 0) {
-          this.self.value = null;
-        }
-      }
-    }
-  }
-}
-
-/** @internal */
-class Node {
-  constructor(value, subscribers, next) {
-    this.value = value;
-    this.subscribers = subscribers;
-    this.next = next;
-  }
-}
-
-/** @internal */
-class UnboundedHub {
-  publisherHead = new Node(null, 0, null);
-  publisherIndex = 0;
-  subscribersIndex = 0;
-  capacity = Number.MAX_SAFE_INTEGER;
-  constructor() {
-    this.publisherTail = this.publisherHead;
-  }
-  isEmpty() {
-    return this.publisherHead === this.publisherTail;
-  }
-  isFull() {
-    return false;
-  }
-  size() {
-    return this.publisherIndex - this.subscribersIndex;
-  }
-  publish(value) {
-    const subscribers = this.publisherTail.subscribers;
-    if (subscribers !== 0) {
-      this.publisherTail.next = new Node(value, subscribers, null);
-      this.publisherTail = this.publisherTail.next;
-      this.publisherIndex += 1;
-    }
-    return true;
-  }
-  publishAll(elements) {
-    for (const a of elements) {
-      this.publish(a);
-    }
-    return empty();
-  }
-  slide() {
-    if (this.publisherHead !== this.publisherTail) {
-      this.publisherHead = this.publisherHead.next;
-      this.publisherHead.value = null;
-      this.subscribersIndex += 1;
-    }
-  }
-  subscribe() {
-    this.publisherTail.subscribers += 1;
-    return new UnboundedHubSubscription(this, this.publisherTail, this.publisherIndex, false);
-  }
-}
-
-/** @internal */
-class UnboundedHubSubscription {
-  constructor(self, subscriberHead, subscriberIndex, unsubscribed) {
-    this.self = self;
-    this.subscriberHead = subscriberHead;
-    this.subscriberIndex = subscriberIndex;
-    this.unsubscribed = unsubscribed;
-  }
-  isEmpty() {
-    if (this.unsubscribed) {
-      return true;
-    }
-    let empty = true;
-    let loop = true;
-    while (loop) {
-      if (this.subscriberHead === this.self.publisherTail) {
-        loop = false;
-      } else {
-        if (this.subscriberHead.next.value !== null) {
-          empty = false;
-          loop = false;
-        } else {
-          this.subscriberHead = this.subscriberHead.next;
-          this.subscriberIndex += 1;
-        }
-      }
-    }
-    return empty;
-  }
-  size() {
-    if (this.unsubscribed) {
-      return 0;
-    }
-    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
-  }
-  poll(default_) {
-    if (this.unsubscribed) {
-      return default_;
-    }
-    let loop = true;
-    let polled = default_;
-    while (loop) {
-      if (this.subscriberHead === this.self.publisherTail) {
-        loop = false;
-      } else {
-        const elem = this.subscriberHead.next.value;
-        if (elem !== null) {
-          polled = elem;
-          this.subscriberHead.subscribers -= 1;
-          if (this.subscriberHead.subscribers === 0) {
-            this.self.publisherHead = this.self.publisherHead.next;
-            this.self.publisherHead.value = null;
-            this.self.subscribersIndex += 1;
-          }
-          loop = false;
-        }
-        this.subscriberHead = this.subscriberHead.next;
-        this.subscriberIndex += 1;
-      }
-    }
-    return polled;
-  }
-  pollUpTo(n) {
-    const builder = [];
-    const default_ = null;
-    let i = 0;
-    while (i !== n) {
-      const a = this.poll(default_);
-      if (a === default_) {
-        i = n;
-      } else {
-        builder.push(a);
-        i += 1;
-      }
-    }
-    return fromIterable(builder);
-  }
-  unsubscribe() {
-    if (!this.unsubscribed) {
-      this.unsubscribed = true;
-      this.self.publisherTail.subscribers -= 1;
-      while (this.subscriberHead !== this.self.publisherTail) {
-        if (this.subscriberHead.next.value !== null) {
-          this.subscriberHead.subscribers -= 1;
-          if (this.subscriberHead.subscribers === 0) {
-            this.self.publisherHead = this.self.publisherHead.next;
-            this.self.publisherHead.value = null;
-            this.self.subscribersIndex += 1;
-          }
-        }
-        this.subscriberHead = this.subscriberHead.next;
-      }
-    }
-  }
-}
-
-/** @internal */
-class SubscriptionImpl {
-  [DequeueTypeId] = dequeueVariance;
-  constructor(hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) {
-    this.hub = hub;
-    this.subscribers = subscribers;
-    this.subscription = subscription;
-    this.pollers = pollers;
-    this.shutdownHook = shutdownHook;
-    this.shutdownFlag = shutdownFlag;
-    this.strategy = strategy;
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-  capacity() {
-    return this.hub.capacity;
-  }
-  isActive() {
-    return !get(this.shutdownFlag);
-  }
-  size() {
-    return suspend(() => get(this.shutdownFlag) ? interrupt : succeed(this.subscription.size()));
-  }
-  unsafeSize() {
-    if (get(this.shutdownFlag)) {
-      return none();
-    }
-    return some(this.subscription.size());
-  }
-  isFull() {
-    return map(this.size(), size => size === this.capacity());
-  }
-  isEmpty() {
-    return map(this.size(), size => size === 0);
-  }
-  shutdown() {
-    return uninterruptible(withFiberRuntime(state => {
-      set(this.shutdownFlag, true);
-      return pipe(forEachParUnbounded(unsafePollAllQueue(this.pollers), d => deferredInterruptWith(d, state.id()), false), zipRight(sync(() => {
-        this.subscribers.delete(this.subscription);
-        this.subscription.unsubscribe();
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-      })), whenEffect(deferredSucceed(this.shutdownHook, void 0)), asUnit);
-    }));
-  }
-  isShutdown() {
-    return sync(() => get(this.shutdownFlag));
-  }
-  awaitShutdown() {
-    return deferredAwait(this.shutdownHook);
-  }
-  take() {
-    return withFiberRuntime(state => {
-      if (get(this.shutdownFlag)) {
-        return interrupt;
-      }
-      const message = isEmpty$3(this.pollers) ? this.subscription.poll(EmptyMutableQueue) : EmptyMutableQueue;
-      if (message === EmptyMutableQueue) {
-        const deferred = deferredUnsafeMake(state.id());
-        return pipe(suspend(() => {
-          pipe(this.pollers, offer(deferred));
-          pipe(this.subscribers, addSubscribers(this.subscription, this.pollers));
-          this.strategy.unsafeCompletePollers(this.hub, this.subscribers, this.subscription, this.pollers);
-          return get(this.shutdownFlag) ? interrupt : deferredAwait(deferred);
-        }), onInterrupt(() => sync(() => unsafeRemove(this.pollers, deferred))));
-      } else {
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-        return succeed(message);
-      }
-    });
-  }
-  takeAll() {
-    return suspend(() => {
-      if (get(this.shutdownFlag)) {
-        return interrupt;
-      }
-      const as = isEmpty$3(this.pollers) ? unsafePollAllSubscription(this.subscription) : empty();
-      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-      return succeed(as);
-    });
-  }
-  takeUpTo(max) {
-    return suspend(() => {
-      if (get(this.shutdownFlag)) {
-        return interrupt;
-      }
-      const as = isEmpty$3(this.pollers) ? unsafePollN(this.subscription, max) : empty();
-      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-      return succeed(as);
-    });
-  }
-  takeBetween(min, max) {
-    return suspend(() => takeRemainderLoop(this, min, max, empty()));
-  }
-}
-
-/** @internal */
-const takeRemainderLoop = (self, min, max, acc) => {
-  if (max < min) {
-    return succeed(acc);
-  }
-  return pipe(self.takeUpTo(max), flatMap(bs => {
-    const remaining = min - bs.length;
-    if (remaining === 1) {
-      return pipe(self.take(), map(b => pipe(acc, appendAll(bs), append(b))));
-    }
-    if (remaining > 1) {
-      return pipe(self.take(), flatMap(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, pipe(acc, appendAll(bs), append(b)))));
-    }
-    return succeed(pipe(acc, appendAll(bs)));
-  }));
-};
-
-/** @internal */
-class HubImpl {
-  [EnqueueTypeId] = enqueueVariance;
-  constructor(hub, subscribers, scope, shutdownHook, shutdownFlag, strategy) {
-    this.hub = hub;
-    this.subscribers = subscribers;
-    this.scope = scope;
-    this.shutdownHook = shutdownHook;
-    this.shutdownFlag = shutdownFlag;
-    this.strategy = strategy;
-  }
-  capacity() {
-    return this.hub.capacity;
-  }
-  size() {
-    return suspend(() => get(this.shutdownFlag) ? interrupt : sync(() => this.hub.size()));
-  }
-  unsafeSize() {
-    if (get(this.shutdownFlag)) {
-      return none();
-    }
-    return some(this.hub.size());
-  }
-  isFull() {
-    return map(this.size(), size => size === this.capacity());
-  }
-  isEmpty() {
-    return map(this.size(), size => size === 0);
-  }
-  awaitShutdown() {
-    return deferredAwait(this.shutdownHook);
-  }
-  isShutdown() {
-    return sync(() => get(this.shutdownFlag));
-  }
-  shutdown() {
-    return uninterruptible(withFiberRuntime(state => {
-      pipe(this.shutdownFlag, set(true));
-      return pipe(this.scope.close(exitInterrupt(state.id())), zipRight(this.strategy.shutdown()), whenEffect(deferredSucceed(this.shutdownHook, void 0)), asUnit);
-    }));
-  }
-  publish(value) {
-    return suspend(() => {
-      if (get(this.shutdownFlag)) {
-        return interrupt;
-      }
-      if (this.hub.publish(value)) {
-        this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-        return succeed(true);
-      }
-      return this.strategy.handleSurplus(this.hub, this.subscribers, of(value), this.shutdownFlag);
-    });
-  }
-  isActive() {
-    return !get(this.shutdownFlag);
-  }
-  unsafeOffer(value) {
-    if (get(this.shutdownFlag)) {
-      return false;
-    }
-    if (this.hub.publish(value)) {
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-      return true;
-    }
-    return false;
-  }
-  publishAll(elements) {
-    return suspend(() => {
-      if (get(this.shutdownFlag)) {
-        return interrupt;
-      }
-      const surplus = unsafePublishAll(this.hub, elements);
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-      if (isEmpty$2(surplus)) {
-        return succeed(true);
-      }
-      return this.strategy.handleSurplus(this.hub, this.subscribers, surplus, this.shutdownFlag);
-    });
-  }
-  subscribe() {
-    const acquire = tap(all([this.scope.fork(sequential), makeSubscription(this.hub, this.subscribers, this.strategy)]), tuple => tuple[0].addFinalizer(() => tuple[1].shutdown()));
-    return map(acquireRelease(acquire, (tuple, exit) => tuple[0].close(exit)), tuple => tuple[1]);
-  }
-  offer(value) {
-    return this.publish(value);
-  }
-  offerAll(elements) {
-    return this.publishAll(elements);
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-const makeHub = (hub, strategy) => flatMap(scopeMake(), scope => map(deferredMake(), deferred => unsafeMakeHub(hub, new Map(), scope, deferred, make(false), strategy)));
-
-/** @internal */
-const unsafeMakeHub = (hub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => {
-  return new HubImpl(hub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
-};
-
-/** @internal */
-const nextPow2 = n => {
-  const nextPow = Math.ceil(Math.log(n) / Math.log(2.0));
-  return Math.max(Math.pow(2, nextPow), 2);
-};
-
-/** @internal */
-const ensureCapacity = capacity => {
-  if (capacity <= 0) {
-    throw InvalidHubCapacityException(`Cannot construct Hub with capacity of ${capacity}`);
-  }
-};
-
-/** @internal */
-const unsafeCompleteDeferred = (deferred, a) => {
-  deferredUnsafeDone(deferred, succeed(a));
-};
-
-/** @internal */
-const unsafeOfferAll = (queue, as) => {
-  return pipe(queue, offerAll(as));
-};
-
-/** @internal */
-const unsafePollAllQueue = queue => {
-  return pipe(queue, pollUpTo(Number.POSITIVE_INFINITY));
-};
-
-/** @internal */
-const unsafePollAllSubscription = subscription => {
-  return subscription.pollUpTo(Number.POSITIVE_INFINITY);
-};
-
-/** @internal */
-const unsafePollN = (subscription, max) => {
-  return subscription.pollUpTo(max);
-};
-
-/** @internal */
-const unsafePublishAll = (hub, as) => {
-  return hub.publishAll(as);
-};
-
-/** @internal */
-const unsafeRemove = (queue, value) => {
-  unsafeOfferAll(queue, pipe(unsafePollAllQueue(queue), filter(elem => elem !== value)));
-};
-
-// -----------------------------------------------------------------------------
-// Hub.Strategy
-// -----------------------------------------------------------------------------
-
-/**
- * A `HubStrategy<A>` describes the protocol for how publishers and subscribers
- * will communicate with each other through the hub.
- *
- * @internal
- */
-/**
- * A strategy that applies back pressure to publishers when the hub is at
- * capacity. This guarantees that all subscribers will receive all messages
- * published to the hub while they are subscribed. However, it creates the
- * risk that a slow subscriber will slow down the rate at which messages
- * are published and received by other subscribers.
- *
- * @internal
- */
-class BackPressureStrategy {
-  publishers = unbounded$2();
-  shutdown() {
-    return flatMap(fiberId, fiberId => flatMap(sync(() => unsafePollAllQueue(this.publishers)), publishers => forEachParUnboundedDiscard(publishers, ([_, deferred, last]) => last ? pipe(deferredInterruptWith(deferred, fiberId), asUnit) : unit, false)));
-  }
-  handleSurplus(hub, subscribers, elements, isShutdown) {
-    return withFiberRuntime(state => {
-      const deferred = deferredUnsafeMake(state.id());
-      return pipe(suspend(() => {
-        this.unsafeOffer(elements, deferred);
-        this.unsafeOnHubEmptySpace(hub, subscribers);
-        this.unsafeCompleteSubscribers(hub, subscribers);
-        return get(isShutdown) ? interrupt : deferredAwait(deferred);
-      }), onInterrupt(() => sync(() => this.unsafeRemove(deferred))));
-    });
-  }
-  unsafeOnHubEmptySpace(hub, subscribers) {
-    let keepPolling = true;
-    while (keepPolling && !hub.isFull()) {
-      const publisher = pipe(this.publishers, poll(EmptyMutableQueue));
-      if (publisher === EmptyMutableQueue) {
-        keepPolling = false;
-      } else {
-        const published = hub.publish(publisher[0]);
-        if (published && publisher[2]) {
-          unsafeCompleteDeferred(publisher[1], true);
-        } else if (!published) {
-          unsafeOfferAll(this.publishers, pipe(unsafePollAllQueue(this.publishers), prepend(publisher)));
-        }
-        this.unsafeCompleteSubscribers(hub, subscribers);
-      }
-    }
-  }
-  unsafeCompletePollers(hub, subscribers, subscription, pollers) {
-    return unsafeStrategyCompletePollers(this, hub, subscribers, subscription, pollers);
-  }
-  unsafeCompleteSubscribers(hub, subscribers) {
-    return unsafeStrategyCompleteSubscribers(this, hub, subscribers);
-  }
-  unsafeOffer(elements, deferred) {
-    const iterator = elements[Symbol.iterator]();
-    let next = iterator.next();
-    if (!next.done) {
-      // eslint-disable-next-line no-constant-condition
-      while (1) {
-        const value = next.value;
-        next = iterator.next();
-        if (next.done) {
-          pipe(this.publishers, offer([value, deferred, true]));
-          break;
-        }
-        pipe(this.publishers, offer([value, deferred, false]));
-      }
-    }
-  }
-  unsafeRemove(deferred) {
-    unsafeOfferAll(this.publishers, pipe(unsafePollAllQueue(this.publishers), filter(([_, a]) => a !== deferred)));
-  }
-}
-
-/**
- * A strategy that drops new messages when the hub is at capacity. This
- * guarantees that a slow subscriber will not slow down the rate at which
- * messages are published. However, it creates the risk that a slow
- * subscriber will slow down the rate at which messages are received by
- * other subscribers and that subscribers may not receive all messages
- * published to the hub while they are subscribed.
- *
- * @internal
- */
-class DroppingStrategy {
-  shutdown() {
-    return unit;
-  }
-  handleSurplus(_hub, _subscribers, _elements, _isShutdown) {
-    return succeed(false);
-  }
-  unsafeOnHubEmptySpace(_hub, _subscribers) {
-    //
-  }
-  unsafeCompletePollers(hub, subscribers, subscription, pollers) {
-    return unsafeStrategyCompletePollers(this, hub, subscribers, subscription, pollers);
-  }
-  unsafeCompleteSubscribers(hub, subscribers) {
-    return unsafeStrategyCompleteSubscribers(this, hub, subscribers);
-  }
-}
-
-/**
- * A strategy that adds new messages and drops old messages when the hub is
- * at capacity. This guarantees that a slow subscriber will not slow down
- * the rate at which messages are published and received by other
- * subscribers. However, it creates the risk that a slow subscriber will
- * not receive some messages published to the hub while it is subscribed.
- *
- * @internal
- */
-class SlidingStrategy {
-  shutdown() {
-    return unit;
-  }
-  handleSurplus(hub, subscribers, elements, _isShutdown) {
-    return sync(() => {
-      this.unsafeSlidingPublish(hub, elements);
-      this.unsafeCompleteSubscribers(hub, subscribers);
-      return true;
-    });
-  }
-  unsafeOnHubEmptySpace(_hub, _subscribers) {
-    //
-  }
-  unsafeCompletePollers(hub, subscribers, subscription, pollers) {
-    return unsafeStrategyCompletePollers(this, hub, subscribers, subscription, pollers);
-  }
-  unsafeCompleteSubscribers(hub, subscribers) {
-    return unsafeStrategyCompleteSubscribers(this, hub, subscribers);
-  }
-  unsafeSlidingPublish(hub, elements) {
-    const it = elements[Symbol.iterator]();
-    let next = it.next();
-    if (!next.done && hub.capacity > 0) {
-      let a = next.value;
-      let loop = true;
-      while (loop) {
-        hub.slide();
-        const pub = hub.publish(a);
-        if (pub && (next = it.next()) && !next.done) {
-          a = next.value;
-        } else if (pub) {
-          loop = false;
-        }
-      }
-    }
-  }
-}
-
-/** @internal */
-const unsafeStrategyCompletePollers = (strategy, hub, subscribers, subscription, pollers) => {
-  let keepPolling = true;
-  while (keepPolling && !subscription.isEmpty()) {
-    const poller = pipe(pollers, poll(EmptyMutableQueue));
-    if (poller === EmptyMutableQueue) {
-      pipe(subscribers, removeSubscribers(subscription, pollers));
-      if (isEmpty$3(pollers)) {
-        keepPolling = false;
-      } else {
-        pipe(subscribers, addSubscribers(subscription, pollers));
-      }
-    } else {
-      const pollResult = subscription.poll(EmptyMutableQueue);
-      if (pollResult === EmptyMutableQueue) {
-        unsafeOfferAll(pollers, pipe(unsafePollAllQueue(pollers), prepend(poller)));
-      } else {
-        unsafeCompleteDeferred(poller, pollResult);
-        strategy.unsafeOnHubEmptySpace(hub, subscribers);
-      }
-    }
-  }
-};
-
-/** @internal */
-const unsafeStrategyCompleteSubscribers = (strategy, hub, subscribers) => {
-  for (const [subscription, pollersSet] of subscribers) {
-    for (const pollers of pollersSet) {
-      strategy.unsafeCompletePollers(hub, subscribers, subscription, pollers);
-    }
-  }
-};
-
-/**
- * @since 1.0.0
- */
-
-/**
- * A `Hub<A>` is an asynchronous message hub into which publishers can publish
- * messages of type `A` and subscribers can subscribe to take messages of type
- * `A`.
- *
- * @since 1.0.0
- * @category models
- */
-
-/**
- * Creates a bounded hub with the back pressure strategy. The hub will retain
- * messages until they have been taken by all subscribers, applying back
- * pressure to publishers if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 1.0.0
- * @category constructors
- */
-const bounded = bounded$1;
-
-/**
- * Creates a bounded hub with the dropping strategy. The hub will drop new
- * messages if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 1.0.0
- * @category constructors
- */
-const dropping = dropping$1;
-
-/**
- * Creates a bounded hub with the sliding strategy. The hub will add new
- * messages and drop old messages if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 1.0.0
- * @category constructors
- */
-const sliding = sliding$1;
-
-/**
- * Creates an unbounded hub.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unbounded = unbounded$1;
-
-/**
- *  Returns the number of elements the queue can hold.
- *
- * @since 1.0.0
- * @category getters
- */
-const capacity = capacity$1;
-
-/**
- * Retrieves the size of the queue, which is equal to the number of elements
- * in the queue. This may be negative if fibers are suspended waiting for
- * elements to be added to the queue.
- *
- * @since 1.0.0
- * @category getters
- */
-const size = size$1;
-
-/**
- * Returns `true` if the `Queue` contains at least one element, `false`
- * otherwise.
- *
- * @since 1.0.0
- * @category getters
- */
-const isFull = isFull$1;
-
-/**
- * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
- *
- * @since 1.0.0
- * @category getters
- */
-const isEmpty = isEmpty$1;
-
-/**
- * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
- * to `offer*` and `take*` will be interrupted immediately.
- *
- * @since 1.0.0
- * @category utils
- */
-const shutdown = shutdown$1;
-
-/**
- * Returns `true` if `shutdown` has been called, otherwise returns `false`.
- *
- * @since 1.0.0
- * @category getters
- */
-const isShutdown = isShutdown$1;
-
-/**
- * Waits until the queue is shutdown. The `Effect` returned by this method will
- * not resume until the queue has been shutdown. If the queue is already
- * shutdown, the `Effect` will resume right away.
- *
- * @since 1.0.0
- * @category utils
- */
-const awaitShutdown = awaitShutdown$1;
-
-/**
- * Publishes a message to the hub, returning whether the message was published
- * to the hub.
- *
- * @since 1.0.0
- * @category utils
- */
-const publish = publish$1;
-
-/**
- * Publishes all of the specified messages to the hub, returning whether they
- * were published to the hub.
- *
- * @since 1.0.0
- * @category utils
- */
-const publishAll = publishAll$1;
-
-/**
- * Subscribes to receive messages from the hub. The resulting subscription can
- * be evaluated multiple times within the scope to take a message from the hub
- * each time.
- *
- * @since 1.0.0
- * @category utils
- */
-const subscribe = subscribe$1;
-
-var Hub = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  bounded: bounded,
-  dropping: dropping,
-  sliding: sliding,
-  unbounded: unbounded,
-  capacity: capacity,
-  size: size,
-  isFull: isFull,
-  isEmpty: isEmpty,
-  shutdown: shutdown,
-  isShutdown: isShutdown,
-  awaitShutdown: awaitShutdown,
-  publish: publish,
-  publishAll: publishAll,
-  subscribe: subscribe
-});
-
-export { Hub as H, shutdown as a, bounded as b, sliding as c, dropping as d, capacity as e, size as f, isEmpty as g, isShutdown as h, isFull as i, awaitShutdown as j, publishAll as k, publish as p, subscribe as s, unbounded as u };