effect 2.0.0-next.35 → 2.0.0-next.37

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

@@ -0,0 +1,1280 @@
+'use strict';
+
+var Chunk_dist_effectChunk = require('./Chunk-937f4423.cjs.dev.js');
+var Function_dist_effectFunction = require('./Function-fd10bde3.cjs.dev.js');
+var core = require('./core-bedc63fe.cjs.dev.js');
+var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-cd9204b4.cjs.dev.js');
+var fiberRuntime = require('./fiberRuntime-233db874.cjs.dev.js');
+var queue = require('./queue-bf262207.cjs.dev.js');
+var MutableQueue_dist_effectMutableQueue = require('./MutableQueue-3dfd5fea.cjs.dev.js');
+var MutableRef_dist_effectMutableRef = require('./MutableRef-ef31c15d.cjs.dev.js');
+var Option_dist_effectOption = require('./Option-837ae0da.cjs.dev.js');
+var Pipeable_dist_effectPipeable = require('./Pipeable-ef202667.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 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
+});
+
+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;