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

package/Hub/dist/effect-Hub.cjs.prod.js

@@ -2,94 +2,1325 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var Hub_dist_effectHub = require('../../dist/Hub-6e64debd.cjs.prod.js');
-require('../../dist/Chunk-6cf5a8e6.cjs.prod.js');
-require('../../dist/Equal-ce9977a8.cjs.prod.js');
-require('../../dist/Hash-1bd73210.cjs.prod.js');
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-require('../../dist/GlobalValue-cb645c99.cjs.prod.js');
-require('../../dist/Utils-864e1d48.cjs.prod.js');
-require('../../dist/Predicate-daa86e61.cjs.prod.js');
-require('../../dist/Equivalence-0bc84518.cjs.prod.js');
-require('../../dist/Inspectable-3c4a0f5d.cjs.prod.js');
-require('../../dist/Option-02025c86.cjs.prod.js');
-require('../../dist/Either-d03d5f05.cjs.prod.js');
-require('../../dist/Effectable-f867d1cb.cjs.prod.js');
-require('../../dist/Data-07dc27f1.cjs.prod.js');
-require('../../dist/Pipeable-d3ec6711.cjs.prod.js');
-require('../../dist/Number-cb2ba2e8.cjs.prod.js');
-require('../../dist/Order-8a112bfb.cjs.prod.js');
-require('../../dist/ReadonlyArray-8157f697.cjs.prod.js');
-require('../../dist/Either-3fab3796.cjs.prod.js');
+var Chunk_dist_effectChunk = require('../../Chunk/dist/effect-Chunk.cjs.prod.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.prod.js');
+var core = require('../../dist/core-0b0539de.cjs.prod.js');
+var ExecutionStrategy_dist_effectExecutionStrategy = require('../../dist/ExecutionStrategy-14d3053a.cjs.prod.js');
+var fiberRuntime = require('../../dist/fiberRuntime-af2d0ca1.cjs.prod.js');
+var queue = require('../../dist/queue-38614769.cjs.prod.js');
+var MutableQueue_dist_effectMutableQueue = require('../../MutableQueue/dist/effect-MutableQueue.cjs.prod.js');
+var MutableRef_dist_effectMutableRef = require('../../MutableRef/dist/effect-MutableRef.cjs.prod.js');
+var Option_dist_effectOption = require('../../Option/dist/effect-Option.cjs.prod.js');
+var Pipeable_dist_effectPipeable = require('../../Pipeable/dist/effect-Pipeable.cjs.prod.js');
+require('../../Equal/dist/effect-Equal.cjs.prod.js');
+require('../../Hash/dist/effect-Hash.cjs.prod.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.prod.js');
+require('../../Utils/dist/effect-Utils.cjs.prod.js');
+require('../../Predicate/dist/effect-Predicate.cjs.prod.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.prod.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.prod.js');
+require('../../Order/dist/effect-Order.cjs.prod.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
+require('../../Either/dist/effect-Either.cjs.prod.js');
+require('../../dist/Either-7a881c7a.cjs.prod.js');
+require('../../dist/Effectable-cd8f3a96.cjs.prod.js');
+require('../../Data/dist/effect-Data.cjs.prod.js');
 require('../../dist/ReadonlyArray-f9ed7a05.cjs.prod.js');
-require('../../dist/ReadonlyRecord-8db8bada.cjs.prod.js');
-require('../../dist/core-c2eb171a.cjs.prod.js');
-require('../../dist/Context-25a49952.cjs.prod.js');
-require('../../dist/Context-f958cabc.cjs.prod.js');
-require('../../dist/Differ-0bd34066.cjs.prod.js');
-require('../../dist/HashMap-12668911.cjs.prod.js');
-require('../../dist/HashSet-6fe62df2.cjs.prod.js');
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.prod.js');
+require('../../Context/dist/effect-Context.cjs.prod.js');
+require('../../dist/Context-01a123ac.cjs.prod.js');
+require('../../Differ/dist/effect-Differ.cjs.prod.js');
+require('../../HashMap/dist/effect-HashMap.cjs.prod.js');
+require('../../dist/HashSet-6257b66d.cjs.prod.js');
 require('../../dist/Stack-fc8f9fe5.cjs.prod.js');
-require('../../dist/HashSet-c40a52b1.cjs.prod.js');
-require('../../dist/FiberId-b79e8047.cjs.prod.js');
-require('../../dist/MutableRef-4a2f1f23.cjs.prod.js');
-require('../../dist/List-d9775087.cjs.prod.js');
-require('../../dist/RuntimeFlagsPatch-5570758d.cjs.prod.js');
-require('../../dist/ExecutionStrategy-dc778180.cjs.prod.js');
-require('../../dist/fiberRuntime-1c369a47.cjs.prod.js');
-require('../../dist/Boolean-97839b78.cjs.prod.js');
-require('../../dist/Deferred-9d825b3b.cjs.prod.js');
-require('../../dist/FiberRefs-4cb171f7.cjs.prod.js');
-require('../../dist/fiberRefs-64c35250.cjs.prod.js');
-require('../../dist/FiberRefsPatch-cb847553.cjs.prod.js');
-require('../../dist/patch-f27e9f08.cjs.prod.js');
-require('../../dist/FiberStatus-b82dad24.cjs.prod.js');
-require('../../dist/defaultServices-4112c0c9.cjs.prod.js');
-require('../../dist/Duration-0bc08d03.cjs.prod.js');
-require('../../dist/timeout-2a62e4b5.cjs.prod.js');
-require('../../dist/configProvider-2b177eac.cjs.prod.js');
-require('../../dist/config-78feb1ac.cjs.prod.js');
-require('../../dist/ConfigError-cee682fa.cjs.prod.js');
-require('../../dist/configError-6a3652f8.cjs.prod.js');
-require('../../dist/configSecret-ecb6c5b3.cjs.prod.js');
-require('../../dist/pathPatch-ded405f6.cjs.prod.js');
-require('../../dist/core-effect-bf806dd9.cjs.prod.js');
-require('../../dist/Clock-09ecce0a.cjs.prod.js');
-require('../../dist/label-3e143765.cjs.prod.js');
-require('../../dist/LogLevel-e9848e15.cjs.prod.js');
-require('../../dist/LogSpan-c905a192.cjs.prod.js');
-require('../../dist/Ref-30e5ee58.cjs.prod.js');
-require('../../dist/Tracer-d06d0b61.cjs.prod.js');
-require('../../dist/fiber-90ffaf8c.cjs.prod.js');
-require('../../dist/Exit-5691142c.cjs.prod.js');
-require('../../dist/boundaries-5d1a46e1.cjs.prod.js');
-require('../../dist/key-330b98b1.cjs.prod.js');
-require('../../dist/keyType-8460e792.cjs.prod.js');
-require('../../dist/registry-29905dcc.cjs.prod.js');
-require('../../dist/hook-6c7550dc.cjs.prod.js');
-require('../../dist/state-0d29362f.cjs.prod.js');
-require('../../dist/pair-e5443c93.cjs.prod.js');
-require('../../dist/MutableHashMap-95493edb.cjs.prod.js');
-require('../../dist/SortedSet-424670fe.cjs.prod.js');
-require('../../dist/RedBlackTree-eb41ea8a.cjs.prod.js');
-require('../../dist/Scheduler-819ee02a.cjs.prod.js');
-require('../../dist/queue-b81aee38.cjs.prod.js');
-require('../../dist/MutableQueue-f8aba856.cjs.prod.js');
-require('../../dist/MutableList-732af09a.cjs.prod.js');
-
-
-
-exports.awaitShutdown = Hub_dist_effectHub.awaitShutdown;
-exports.bounded = Hub_dist_effectHub.bounded;
-exports.capacity = Hub_dist_effectHub.capacity;
-exports.dropping = Hub_dist_effectHub.dropping;
-exports.isEmpty = Hub_dist_effectHub.isEmpty;
-exports.isFull = Hub_dist_effectHub.isFull;
-exports.isShutdown = Hub_dist_effectHub.isShutdown;
-exports.publish = Hub_dist_effectHub.publish;
-exports.publishAll = Hub_dist_effectHub.publishAll;
-exports.shutdown = Hub_dist_effectHub.shutdown;
-exports.size = Hub_dist_effectHub.size;
-exports.sliding = Hub_dist_effectHub.sliding;
-exports.subscribe = Hub_dist_effectHub.subscribe;
-exports.unbounded = Hub_dist_effectHub.unbounded;
+require('../../HashSet/dist/effect-HashSet.cjs.prod.js');
+require('../../dist/FiberId-e594f6e8.cjs.prod.js');
+require('../../List/dist/effect-List.cjs.prod.js');
+require('../../dist/RuntimeFlagsPatch-e2769b87.cjs.prod.js');
+require('../../Boolean/dist/effect-Boolean.cjs.prod.js');
+require('../../Deferred/dist/effect-Deferred.cjs.prod.js');
+require('../../FiberRefs/dist/effect-FiberRefs.cjs.prod.js');
+require('../../dist/fiberRefs-be6b6a70.cjs.prod.js');
+require('../../FiberRefsPatch/dist/effect-FiberRefsPatch.cjs.prod.js');
+require('../../dist/patch-c4d6c61e.cjs.prod.js');
+require('../../FiberStatus/dist/effect-FiberStatus.cjs.prod.js');
+require('../../dist/defaultServices-086b8ac9.cjs.prod.js');
+require('../../Duration/dist/effect-Duration.cjs.prod.js');
+require('../../dist/timeout-489f3f86.cjs.prod.js');
+require('../../dist/configProvider-93617d6d.cjs.prod.js');
+require('../../dist/config-d0ddc159.cjs.prod.js');
+require('../../ConfigError/dist/effect-ConfigError.cjs.prod.js');
+require('../../dist/configError-33e55472.cjs.prod.js');
+require('../../dist/configSecret-d1caca55.cjs.prod.js');
+require('../../dist/pathPatch-15c8d723.cjs.prod.js');
+require('../../Number/dist/effect-Number.cjs.prod.js');
+require('../../dist/core-effect-c65770cd.cjs.prod.js');
+require('../../Clock/dist/effect-Clock.cjs.prod.js');
+require('../../dist/label-655343b5.cjs.prod.js');
+require('../../LogLevel/dist/effect-LogLevel.cjs.prod.js');
+require('../../LogSpan/dist/effect-LogSpan.cjs.prod.js');
+require('../../dist/Ref-a3a4e50d.cjs.prod.js');
+require('../../Tracer/dist/effect-Tracer.cjs.prod.js');
+require('../../dist/fiber-2eb0a4c1.cjs.prod.js');
+require('../../Exit/dist/effect-Exit.cjs.prod.js');
+require('../../dist/boundaries-20cfad9d.cjs.prod.js');
+require('../../dist/key-378a6a2c.cjs.prod.js');
+require('../../dist/keyType-cf67c69c.cjs.prod.js');
+require('../../dist/registry-013ecdde.cjs.prod.js');
+require('../../dist/hook-470b717e.cjs.prod.js');
+require('../../dist/state-dd1bd066.cjs.prod.js');
+require('../../dist/pair-6254cf85.cjs.prod.js');
+require('../../MutableHashMap/dist/effect-MutableHashMap.cjs.prod.js');
+require('../../SortedSet/dist/effect-SortedSet.cjs.prod.js');
+require('../../RedBlackTree/dist/effect-RedBlackTree.cjs.prod.js');
+require('../../Scheduler/dist/effect-Scheduler.cjs.prod.js');
+require('../../MutableList/dist/effect-MutableList.cjs.prod.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;
+
+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;