effect 2.0.0-next.41 → 2.0.0-next.43

package/dist/Hub-74834668.cjs.dev.js

@@ -1,1280 +0,0 @@
-'use strict';
-
-var Chunk_dist_effectChunk = require('./Chunk-bd290b8e.cjs.dev.js');
-var Function_dist_effectFunction = require('./Function-41ce433d.cjs.dev.js');
-var core = require('./core-ac668be0.cjs.dev.js');
-var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-89fbe735.cjs.dev.js');
-var fiberRuntime = require('./fiberRuntime-e9680313.cjs.dev.js');
-var queue = require('./queue-04ae7ec7.cjs.dev.js');
-var MutableQueue_dist_effectMutableQueue = require('./MutableQueue-0e9f2466.cjs.dev.js');
-var MutableRef_dist_effectMutableRef = require('./MutableRef-724c4082.cjs.dev.js');
-var Option_dist_effectOption = require('./Option-03997d77.cjs.dev.js');
-var Pipeable_dist_effectPipeable = require('./Pipeable-4698db72.cjs.dev.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 => Function_dist_effectFunction.pipe(core.sync(() => makeBoundedHub(requestedCapacity)), core.flatMap(atomicHub => makeHub(atomicHub, new BackPressureStrategy())));
-
-/** @internal */
-const dropping$1 = requestedCapacity => Function_dist_effectFunction.pipe(core.sync(() => makeBoundedHub(requestedCapacity)), core.flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
-
-/** @internal */
-const sliding$1 = requestedCapacity => Function_dist_effectFunction.pipe(core.sync(() => makeBoundedHub(requestedCapacity)), core.flatMap(atomicHub => makeHub(atomicHub, new SlidingStrategy())));
-
-/** @internal */
-const unbounded$1 = () => Function_dist_effectFunction.pipe(core.sync(() => makeUnboundedHub()), core.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__*/Function_dist_effectFunction.dual(2, (self, value) => self.publish(value));
-
-/** @internal */
-const publishAll$1 = /*#__PURE__*/Function_dist_effectFunction.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) => core.map(core.deferredMake(), deferred => unsafeMakeSubscription(hub, subscribers, hub.subscribe(), MutableQueue_dist_effectMutableQueue.unbounded(), deferred, MutableRef_dist_effectMutableRef.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 = Chunk_dist_effectChunk.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 = Chunk_dist_effectChunk.unsafeGet(chunk, iteratorIndex++);
-      const index = this.publisherIndex % this.capacity;
-      this.array[index] = a;
-      this.subscribers[index] = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 = Chunk_dist_effectChunk.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 = Chunk_dist_effectChunk.unsafeGet(chunk, iteratorIndex++);
-      const index = this.publisherIndex & this.mask;
-      this.array[index] = elem;
-      this.subscribers[index] = this.subscriberCount;
-      this.publisherIndex += 1;
-    }
-    return Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 Pipeable_dist_effectPipeable.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 = Chunk_dist_effectChunk.fromIterable(elements);
-    if (Chunk_dist_effectChunk.isEmpty(chunk)) {
-      return chunk;
-    }
-    if (this.publish(Chunk_dist_effectChunk.unsafeHead(chunk))) {
-      return Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.empty();
-    }
-    const a = this.self.value;
-    this.self.subscribers -= 1;
-    if (this.self.subscribers === 0) {
-      this.self.value = null;
-    }
-    this.subscriberIndex += 1;
-    return Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 Chunk_dist_effectChunk.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 {
-  [queue.DequeueTypeId] = queue.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 Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-  capacity() {
-    return this.hub.capacity;
-  }
-  isActive() {
-    return !MutableRef_dist_effectMutableRef.get(this.shutdownFlag);
-  }
-  size() {
-    return core.suspend(() => MutableRef_dist_effectMutableRef.get(this.shutdownFlag) ? core.interrupt : core.succeed(this.subscription.size()));
-  }
-  unsafeSize() {
-    if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-      return Option_dist_effectOption.none();
-    }
-    return Option_dist_effectOption.some(this.subscription.size());
-  }
-  isFull() {
-    return core.map(this.size(), size => size === this.capacity());
-  }
-  isEmpty() {
-    return core.map(this.size(), size => size === 0);
-  }
-  shutdown() {
-    return core.uninterruptible(core.withFiberRuntime(state => {
-      MutableRef_dist_effectMutableRef.set(this.shutdownFlag, true);
-      return Function_dist_effectFunction.pipe(fiberRuntime.forEachParUnbounded(unsafePollAllQueue(this.pollers), d => core.deferredInterruptWith(d, state.id()), false), core.zipRight(core.sync(() => {
-        this.subscribers.delete(this.subscription);
-        this.subscription.unsubscribe();
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-      })), core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)), core.asUnit);
-    }));
-  }
-  isShutdown() {
-    return core.sync(() => MutableRef_dist_effectMutableRef.get(this.shutdownFlag));
-  }
-  awaitShutdown() {
-    return core.deferredAwait(this.shutdownHook);
-  }
-  take() {
-    return core.withFiberRuntime(state => {
-      if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-        return core.interrupt;
-      }
-      const message = MutableQueue_dist_effectMutableQueue.isEmpty(this.pollers) ? this.subscription.poll(MutableQueue_dist_effectMutableQueue.EmptyMutableQueue) : MutableQueue_dist_effectMutableQueue.EmptyMutableQueue;
-      if (message === MutableQueue_dist_effectMutableQueue.EmptyMutableQueue) {
-        const deferred = core.deferredUnsafeMake(state.id());
-        return Function_dist_effectFunction.pipe(core.suspend(() => {
-          Function_dist_effectFunction.pipe(this.pollers, MutableQueue_dist_effectMutableQueue.offer(deferred));
-          Function_dist_effectFunction.pipe(this.subscribers, addSubscribers(this.subscription, this.pollers));
-          this.strategy.unsafeCompletePollers(this.hub, this.subscribers, this.subscription, this.pollers);
-          return MutableRef_dist_effectMutableRef.get(this.shutdownFlag) ? core.interrupt : core.deferredAwait(deferred);
-        }), core.onInterrupt(() => core.sync(() => unsafeRemove(this.pollers, deferred))));
-      } else {
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-        return core.succeed(message);
-      }
-    });
-  }
-  takeAll() {
-    return core.suspend(() => {
-      if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-        return core.interrupt;
-      }
-      const as = MutableQueue_dist_effectMutableQueue.isEmpty(this.pollers) ? unsafePollAllSubscription(this.subscription) : Chunk_dist_effectChunk.empty();
-      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-      return core.succeed(as);
-    });
-  }
-  takeUpTo(max) {
-    return core.suspend(() => {
-      if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-        return core.interrupt;
-      }
-      const as = MutableQueue_dist_effectMutableQueue.isEmpty(this.pollers) ? unsafePollN(this.subscription, max) : Chunk_dist_effectChunk.empty();
-      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
-      return core.succeed(as);
-    });
-  }
-  takeBetween(min, max) {
-    return core.suspend(() => takeRemainderLoop(this, min, max, Chunk_dist_effectChunk.empty()));
-  }
-}
-
-/** @internal */
-const takeRemainderLoop = (self, min, max, acc) => {
-  if (max < min) {
-    return core.succeed(acc);
-  }
-  return Function_dist_effectFunction.pipe(self.takeUpTo(max), core.flatMap(bs => {
-    const remaining = min - bs.length;
-    if (remaining === 1) {
-      return Function_dist_effectFunction.pipe(self.take(), core.map(b => Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(bs), Chunk_dist_effectChunk.append(b))));
-    }
-    if (remaining > 1) {
-      return Function_dist_effectFunction.pipe(self.take(), core.flatMap(b => takeRemainderLoop(self, remaining - 1, max - bs.length - 1, Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(bs), Chunk_dist_effectChunk.append(b)))));
-    }
-    return core.succeed(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(bs)));
-  }));
-};
-
-/** @internal */
-class HubImpl {
-  [queue.EnqueueTypeId] = queue.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 core.suspend(() => MutableRef_dist_effectMutableRef.get(this.shutdownFlag) ? core.interrupt : core.sync(() => this.hub.size()));
-  }
-  unsafeSize() {
-    if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-      return Option_dist_effectOption.none();
-    }
-    return Option_dist_effectOption.some(this.hub.size());
-  }
-  isFull() {
-    return core.map(this.size(), size => size === this.capacity());
-  }
-  isEmpty() {
-    return core.map(this.size(), size => size === 0);
-  }
-  awaitShutdown() {
-    return core.deferredAwait(this.shutdownHook);
-  }
-  isShutdown() {
-    return core.sync(() => MutableRef_dist_effectMutableRef.get(this.shutdownFlag));
-  }
-  shutdown() {
-    return core.uninterruptible(core.withFiberRuntime(state => {
-      Function_dist_effectFunction.pipe(this.shutdownFlag, MutableRef_dist_effectMutableRef.set(true));
-      return Function_dist_effectFunction.pipe(this.scope.close(core.exitInterrupt(state.id())), core.zipRight(this.strategy.shutdown()), core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)), core.asUnit);
-    }));
-  }
-  publish(value) {
-    return core.suspend(() => {
-      if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-        return core.interrupt;
-      }
-      if (this.hub.publish(value)) {
-        this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-        return core.succeed(true);
-      }
-      return this.strategy.handleSurplus(this.hub, this.subscribers, Chunk_dist_effectChunk.of(value), this.shutdownFlag);
-    });
-  }
-  isActive() {
-    return !MutableRef_dist_effectMutableRef.get(this.shutdownFlag);
-  }
-  unsafeOffer(value) {
-    if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-      return false;
-    }
-    if (this.hub.publish(value)) {
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-      return true;
-    }
-    return false;
-  }
-  publishAll(elements) {
-    return core.suspend(() => {
-      if (MutableRef_dist_effectMutableRef.get(this.shutdownFlag)) {
-        return core.interrupt;
-      }
-      const surplus = unsafePublishAll(this.hub, elements);
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-      if (Chunk_dist_effectChunk.isEmpty(surplus)) {
-        return core.succeed(true);
-      }
-      return this.strategy.handleSurplus(this.hub, this.subscribers, surplus, this.shutdownFlag);
-    });
-  }
-  subscribe() {
-    const acquire = core.tap(fiberRuntime.all([this.scope.fork(ExecutionStrategy_dist_effectExecutionStrategy.sequential), makeSubscription(this.hub, this.subscribers, this.strategy)]), tuple => tuple[0].addFinalizer(() => tuple[1].shutdown()));
-    return core.map(fiberRuntime.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 Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-const makeHub = (hub, strategy) => core.flatMap(fiberRuntime.scopeMake(), scope => core.map(core.deferredMake(), deferred => unsafeMakeHub(hub, new Map(), scope, deferred, MutableRef_dist_effectMutableRef.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 core.InvalidHubCapacityException(`Cannot construct Hub with capacity of ${capacity}`);
-  }
-};
-
-/** @internal */
-const unsafeCompleteDeferred = (deferred, a) => {
-  core.deferredUnsafeDone(deferred, core.succeed(a));
-};
-
-/** @internal */
-const unsafeOfferAll = (queue, as) => {
-  return Function_dist_effectFunction.pipe(queue, MutableQueue_dist_effectMutableQueue.offerAll(as));
-};
-
-/** @internal */
-const unsafePollAllQueue = queue => {
-  return Function_dist_effectFunction.pipe(queue, MutableQueue_dist_effectMutableQueue.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, Function_dist_effectFunction.pipe(unsafePollAllQueue(queue), Chunk_dist_effectChunk.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 = MutableQueue_dist_effectMutableQueue.unbounded();
-  shutdown() {
-    return core.flatMap(core.fiberId, fiberId => core.flatMap(core.sync(() => unsafePollAllQueue(this.publishers)), publishers => fiberRuntime.forEachParUnboundedDiscard(publishers, ([_, deferred, last]) => last ? Function_dist_effectFunction.pipe(core.deferredInterruptWith(deferred, fiberId), core.asUnit) : core.unit, false)));
-  }
-  handleSurplus(hub, subscribers, elements, isShutdown) {
-    return core.withFiberRuntime(state => {
-      const deferred = core.deferredUnsafeMake(state.id());
-      return Function_dist_effectFunction.pipe(core.suspend(() => {
-        this.unsafeOffer(elements, deferred);
-        this.unsafeOnHubEmptySpace(hub, subscribers);
-        this.unsafeCompleteSubscribers(hub, subscribers);
-        return MutableRef_dist_effectMutableRef.get(isShutdown) ? core.interrupt : core.deferredAwait(deferred);
-      }), core.onInterrupt(() => core.sync(() => this.unsafeRemove(deferred))));
-    });
-  }
-  unsafeOnHubEmptySpace(hub, subscribers) {
-    let keepPolling = true;
-    while (keepPolling && !hub.isFull()) {
-      const publisher = Function_dist_effectFunction.pipe(this.publishers, MutableQueue_dist_effectMutableQueue.poll(MutableQueue_dist_effectMutableQueue.EmptyMutableQueue));
-      if (publisher === MutableQueue_dist_effectMutableQueue.EmptyMutableQueue) {
-        keepPolling = false;
-      } else {
-        const published = hub.publish(publisher[0]);
-        if (published && publisher[2]) {
-          unsafeCompleteDeferred(publisher[1], true);
-        } else if (!published) {
-          unsafeOfferAll(this.publishers, Function_dist_effectFunction.pipe(unsafePollAllQueue(this.publishers), Chunk_dist_effectChunk.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) {
-          Function_dist_effectFunction.pipe(this.publishers, MutableQueue_dist_effectMutableQueue.offer([value, deferred, true]));
-          break;
-        }
-        Function_dist_effectFunction.pipe(this.publishers, MutableQueue_dist_effectMutableQueue.offer([value, deferred, false]));
-      }
-    }
-  }
-  unsafeRemove(deferred) {
-    unsafeOfferAll(this.publishers, Function_dist_effectFunction.pipe(unsafePollAllQueue(this.publishers), Chunk_dist_effectChunk.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 core.unit;
-  }
-  handleSurplus(_hub, _subscribers, _elements, _isShutdown) {
-    return core.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 core.unit;
-  }
-  handleSurplus(hub, subscribers, elements, _isShutdown) {
-    return core.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 = Function_dist_effectFunction.pipe(pollers, MutableQueue_dist_effectMutableQueue.poll(MutableQueue_dist_effectMutableQueue.EmptyMutableQueue));
-    if (poller === MutableQueue_dist_effectMutableQueue.EmptyMutableQueue) {
-      Function_dist_effectFunction.pipe(subscribers, removeSubscribers(subscription, pollers));
-      if (MutableQueue_dist_effectMutableQueue.isEmpty(pollers)) {
-        keepPolling = false;
-      } else {
-        Function_dist_effectFunction.pipe(subscribers, addSubscribers(subscription, pollers));
-      }
-    } else {
-      const pollResult = subscription.poll(MutableQueue_dist_effectMutableQueue.EmptyMutableQueue);
-      if (pollResult === MutableQueue_dist_effectMutableQueue.EmptyMutableQueue) {
-        unsafeOfferAll(pollers, Function_dist_effectFunction.pipe(unsafePollAllQueue(pollers), Chunk_dist_effectChunk.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 2.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 2.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 2.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 2.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 2.0.0
- * @category constructors
- */
-const sliding = sliding$1;
-
-/**
- * Creates an unbounded hub.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unbounded = unbounded$1;
-
-/**
- *  Returns the number of elements the queue can hold.
- *
- * @since 2.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 2.0.0
- * @category getters
- */
-const size = size$1;
-
-/**
- * Returns `true` if the `Queue` contains at least one element, `false`
- * otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isFull = isFull$1;
-
-/**
- * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
- *
- * @since 2.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 2.0.0
- * @category utils
- */
-const shutdown = shutdown$1;
-
-/**
- * Returns `true` if `shutdown` has been called, otherwise returns `false`.
- *
- * @since 2.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 2.0.0
- * @category utils
- */
-const awaitShutdown = awaitShutdown$1;
-
-/**
- * Publishes a message to the hub, returning whether the message was published
- * to the hub.
- *
- * @since 2.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 2.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 2.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
-});
-
-exports.Hub = Hub;
-exports.awaitShutdown = awaitShutdown;
-exports.bounded = bounded;
-exports.capacity = capacity;
-exports.dropping = dropping;
-exports.isEmpty = isEmpty;
-exports.isFull = isFull;
-exports.isShutdown = isShutdown;
-exports.publish = publish;
-exports.publishAll = publishAll;
-exports.shutdown = shutdown;
-exports.size = size;
-exports.sliding = sliding;
-exports.subscribe = subscribe;
-exports.unbounded = unbounded;