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

package/dist/stream-b819c5b3.cjs.dev.js

@@ -1,3649 +0,0 @@
-'use strict';
-
-var Cause_dist_effectCause = require('./Cause-d77e20dc.cjs.dev.js');
-var ChannelMergeDecision_dist_effectChannelMergeDecision = require('./ChannelMergeDecision-f05da806.cjs.dev.js');
-var Chunk_dist_effectChunk = require('./Chunk-937f4423.cjs.dev.js');
-var Clock_dist_effectClock = require('./Clock-589e9dc5.cjs.dev.js');
-var Context_dist_effectContext = require('./Context-fdaa5c44.cjs.dev.js');
-var Deferred_dist_effectDeferred = require('./Deferred-143efa7b.cjs.dev.js');
-var Duration_dist_effectDuration = require('./Duration-8b174e0b.cjs.dev.js');
-var Effect_dist_effectEffect = require('./Effect-d362f43a.cjs.dev.js');
-var Either_dist_effectEither = require('./Either-ae722a9e.cjs.dev.js');
-var Equal_dist_effectEqual = require('./Equal-8654b1af.cjs.dev.js');
-var Exit_dist_effectExit = require('./Exit-7a385294.cjs.dev.js');
-var Fiber_dist_effectFiber = require('./Fiber-1a996e3f.cjs.dev.js');
-var Function_dist_effectFunction = require('./Function-fd10bde3.cjs.dev.js');
-var Hub_dist_effectHub = require('./Hub-dd9d70e7.cjs.dev.js');
-var Layer_dist_effectLayer = require('./Layer-11122c64.cjs.dev.js');
-var Option_dist_effectOption = require('./Option-837ae0da.cjs.dev.js');
-var Pipeable_dist_effectPipeable = require('./Pipeable-ef202667.cjs.dev.js');
-var Queue_dist_effectQueue = require('./Queue-48d0b9d4.cjs.dev.js');
-var Ref_dist_effectRef = require('./Ref-8d85fc7a.cjs.dev.js');
-var Runtime_dist_effectRuntime = require('./Runtime-1a63e954.cjs.dev.js');
-var Schedule_dist_effectSchedule = require('./Schedule-d9b0f037.cjs.dev.js');
-var Scope_dist_effectScope = require('./Scope-3cf29072.cjs.dev.js');
-var StreamHaltStrategy_dist_effectStreamHaltStrategy = require('./StreamHaltStrategy-292ed375.cjs.dev.js');
-var sink = require('./sink-3105a90f.cjs.dev.js');
-var mergeStrategy = require('./mergeStrategy-8fe47c7e.cjs.dev.js');
-var singleProducerAsyncInput = require('./singleProducerAsyncInput-6508b7f1.cjs.dev.js');
-require('./GlobalValue-00457222.cjs.dev.js');
-require('./Effectable-e85a1847.cjs.dev.js');
-require('./Differ-0069a8c0.cjs.dev.js');
-require('./timeout-0245c158.cjs.dev.js');
-var take$2 = require('./take-68ed448f.cjs.dev.js');
-
-/** @internal */
-class RingBuffer {
-  size = 0;
-  current = 0;
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.array = Array.from({
-      length: capacity
-    }, Function_dist_effectFunction.constUndefined);
-  }
-  head() {
-    return Option_dist_effectOption.fromNullable(this.array[this.current]);
-  }
-  lastOrNull() {
-    if (this.size === 0) {
-      return undefined;
-    }
-    const index = this.current === 0 ? this.array.length - 1 : this.current - 1;
-    return this.array[index] ?? undefined;
-  }
-  put(value) {
-    this.array[this.current] = value;
-    this.increment();
-  }
-  dropLast() {
-    if (this.size > 0) {
-      this.decrement();
-      this.array[this.current] = undefined;
-    }
-  }
-  toChunk() {
-    const begin = this.current - this.size;
-    const newArray = begin < 0 ? [...this.array.slice(this.capacity + begin, this.capacity), ...this.array.slice(0, this.current)] : this.array.slice(begin, this.current);
-    return Chunk_dist_effectChunk.fromIterable(newArray);
-  }
-  increment() {
-    if (this.size < this.capacity) {
-      this.size += 1;
-    }
-    this.current = (this.current + 1) % this.capacity;
-  }
-  decrement() {
-    this.size -= 1;
-    if (this.current > 0) {
-      this.current -= 1;
-    } else {
-      this.current = this.capacity - 1;
-    }
-  }
-}
-
-/** @internal */
-
-/** @internal */
-const OP_NOT_STARTED = "NotStarted";
-
-/** @internal */
-
-/** @internal */
-const OP_PREVIOUS = "Previous";
-
-/** @internal */
-
-/** @internal */
-const OP_CURRENT = "Current";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const notStarted = {
-  _tag: OP_NOT_STARTED
-};
-
-/** @internal */
-const previous = fiber => ({
-  _tag: OP_PREVIOUS,
-  fiber
-});
-
-/** @internal */
-const current = fiber => ({
-  _tag: OP_CURRENT,
-  fiber
-});
-
-/** @internal */
-const make$2 = emit => {
-  const ops = {
-    chunk(as) {
-      return this(Effect_dist_effectEffect.succeed(as));
-    },
-    die(defect) {
-      return this(Effect_dist_effectEffect.die(defect));
-    },
-    dieMessage(message) {
-      return this(Effect_dist_effectEffect.dieMessage(message));
-    },
-    done(exit) {
-      return this(Effect_dist_effectEffect.suspend(() => Exit_dist_effectExit.mapBoth(exit, {
-        onFailure: Option_dist_effectOption.some,
-        onSuccess: Chunk_dist_effectChunk.of
-      })));
-    },
-    end() {
-      return this(Effect_dist_effectEffect.fail(Option_dist_effectOption.none()));
-    },
-    fail(e) {
-      return this(Effect_dist_effectEffect.fail(Option_dist_effectOption.some(e)));
-    },
-    fromEffect(effect) {
-      return this(Effect_dist_effectEffect.mapBoth(effect, {
-        onFailure: Option_dist_effectOption.some,
-        onSuccess: Chunk_dist_effectChunk.of
-      }));
-    },
-    fromEffectChunk(effect) {
-      return this(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some)));
-    },
-    halt(cause) {
-      return this(Effect_dist_effectEffect.failCause(Function_dist_effectFunction.pipe(cause, Cause_dist_effectCause.map(Option_dist_effectOption.some))));
-    },
-    single(value) {
-      return this(Effect_dist_effectEffect.succeed(Chunk_dist_effectChunk.of(value)));
-    }
-  };
-  return Object.assign(emit, ops);
-};
-
-/** @internal */
-const HandoffTypeId = /*#__PURE__*/Symbol.for("effect/Stream/Handoff");
-
-/** @internal */
-
-/**
- * A synchronous queue-like abstraction that allows a producer to offer an
- * element and wait for it to be taken, and allows a consumer to wait for an
- * element to be available.
- *
- * @internal
- */
-
-/** @internal */
-const OP_HANDOFF_STATE_EMPTY = "Empty";
-
-/** @internal */
-
-/** @internal */
-const OP_HANDOFF_STATE_FULL = "Full";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const handoffStateEmpty = notifyConsumer => ({
-  _tag: OP_HANDOFF_STATE_EMPTY,
-  notifyConsumer
-});
-
-/** @internal */
-const handoffStateFull = (value, notifyProducer) => ({
-  _tag: OP_HANDOFF_STATE_FULL,
-  value,
-  notifyProducer
-});
-
-/** @internal */
-const handoffStateMatch = (onEmpty, onFull) => {
-  return self => {
-    switch (self._tag) {
-      case OP_HANDOFF_STATE_EMPTY:
-        {
-          return onEmpty(self.notifyConsumer);
-        }
-      case OP_HANDOFF_STATE_FULL:
-        {
-          return onFull(self.value, self.notifyProducer);
-        }
-    }
-  };
-};
-
-/** @internal */
-const handoffVariance = {
-  _A: _ => _
-};
-
-/** @internal */
-const make$1 = () => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Ref_dist_effectRef.make(handoffStateEmpty(deferred))), Effect_dist_effectEffect.map(ref => ({
-  [HandoffTypeId]: handoffVariance,
-  ref
-})));
-
-/** @internal */
-const offer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => {
-  return Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred.make(), deferred => Effect_dist_effectEffect.flatten(Ref_dist_effectRef.modify(self.ref, state => Function_dist_effectFunction.pipe(state, handoffStateMatch(notifyConsumer => [Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred.succeed(notifyConsumer, void 0), Deferred_dist_effectDeferred._await(deferred)), handoffStateFull(value, deferred)], (_, notifyProducer) => [Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(notifyProducer), () => Function_dist_effectFunction.pipe(self, offer(value))), state])))));
-});
-
-/** @internal */
-const take$1 = self => Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred.make(), deferred => Effect_dist_effectEffect.flatten(Ref_dist_effectRef.modify(self.ref, state => Function_dist_effectFunction.pipe(state, handoffStateMatch(notifyConsumer => [Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(notifyConsumer), () => take$1(self)), state], (value, notifyProducer) => [Effect_dist_effectEffect.as(Deferred_dist_effectDeferred.succeed(notifyProducer, void 0), value), handoffStateEmpty(deferred)])))));
-
-/** @internal */
-
-/** @internal */
-const OP_EMIT = "Emit";
-
-/** @internal */
-
-/** @internal */
-const OP_HALT = "Halt";
-
-/** @internal */
-
-/** @internal */
-const OP_END = "End";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const emit = elements => ({
-  _tag: OP_EMIT,
-  elements
-});
-
-/** @internal */
-const halt = cause => ({
-  _tag: OP_HALT,
-  cause
-});
-
-/** @internal */
-const end$1 = reason => ({
-  _tag: OP_END,
-  reason
-});
-
-/** @internal */
-const end = () => Effect_dist_effectEffect.fail(Option_dist_effectOption.none());
-
-/** @internal */
-const failCause$1 = cause => Effect_dist_effectEffect.mapError(Effect_dist_effectEffect.failCause(cause), Option_dist_effectOption.some);
-
-/** @internal */
-
-/** @internal */
-const OP_SCHEDULE_END = "ScheduleEnd";
-
-/** @internal */
-
-/** @internal */
-const OP_UPSTREAM_END = "UpstreamEnd";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const ScheduleEnd = {
-  _tag: OP_SCHEDULE_END
-};
-
-/** @internal */
-const UpstreamEnd = {
-  _tag: OP_UPSTREAM_END
-};
-
-/** @internal */
-
-/** @internal */
-const OP_DRAIN_LEFT = "DrainLeft";
-
-/** @internal */
-
-/** @internal */
-const OP_DRAIN_RIGHT = "DrainRight";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_BOTH$1 = "PullBoth";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_LEFT$1 = "PullLeft";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_RIGHT$1 = "PullRight";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const DrainLeft = {
-  _tag: OP_DRAIN_LEFT
-};
-
-/** @internal */
-const DrainRight = {
-  _tag: OP_DRAIN_RIGHT
-};
-
-/** @internal */
-const PullBoth$1 = {
-  _tag: OP_PULL_BOTH$1
-};
-
-/** @internal */
-const PullLeft$1 = rightChunk => ({
-  _tag: OP_PULL_LEFT$1,
-  rightChunk
-});
-
-/** @internal */
-const PullRight$1 = leftChunk => ({
-  _tag: OP_PULL_RIGHT$1,
-  leftChunk
-});
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_BOTH = "PullBoth";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_LEFT = "PullLet";
-
-/** @internal */
-
-/** @internal */
-const OP_PULL_RIGHT = "PullRight";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-const PullBoth = {
-  _tag: OP_PULL_BOTH
-};
-
-/** @internal */
-const PullLeft = rightChunk => ({
-  _tag: OP_PULL_LEFT,
-  rightChunk
-});
-
-/** @internal */
-const PullRight = leftChunk => ({
-  _tag: OP_PULL_RIGHT,
-  leftChunk
-});
-
-/** @internal */
-const StreamSymbolKey = "effect/Stream";
-
-/** @internal */
-const StreamTypeId = /*#__PURE__*/Symbol.for(StreamSymbolKey);
-
-/** @internal */
-const streamVariance = {
-  _R: _ => _,
-  _E: _ => _,
-  _A: _ => _
-};
-
-/** @internal */
-class StreamImpl {
-  [StreamTypeId] = streamVariance;
-  constructor(channel) {
-    this.channel = channel;
-  }
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-const isStream = u => typeof u === "object" && u != null && StreamTypeId in u || Effect_dist_effectEffect.isEffect(u);
-
-/** @internal */
-const DefaultChunkSize = 4096;
-
-/** @internal */
-const acquireRelease = (acquire, release) => scoped(Effect_dist_effectEffect.acquireRelease(acquire, release));
-
-/** @internal */
-const aggregate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink) => aggregateWithin(self, sink, Schedule_dist_effectSchedule.forever));
-
-/** @internal */
-const aggregateWithin = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, sink, schedule) => filterMap(aggregateWithinEither(self, sink, schedule), _ => Either_dist_effectEither.match(_, {
-  onLeft: Option_dist_effectOption.none,
-  onRight: Option_dist_effectOption.some
-})));
-
-/** @internal */
-const aggregateWithinEither = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, sink$1, schedule) => {
-  const layer = Effect_dist_effectEffect.all([make$1(), Ref_dist_effectRef.make(ScheduleEnd), Ref_dist_effectRef.make(Chunk_dist_effectChunk.empty()), Schedule_dist_effectSchedule.driver(schedule), Ref_dist_effectRef.make(false), Ref_dist_effectRef.make(false)]);
-  return Function_dist_effectFunction.pipe(fromEffect(layer), flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
-    const handoffProducer = sink.readWithCause({
-      onInput: input => sink.flatMap(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer(emit(input)), Effect_dist_effectEffect.when(() => Chunk_dist_effectChunk.isNonEmpty(input)))), () => handoffProducer),
-      onFailure: cause => sink.fromEffect(offer(handoff, halt(cause))),
-      onDone: () => sink.fromEffect(offer(handoff, end$1(UpstreamEnd)))
-    });
-    const handoffConsumer = Function_dist_effectFunction.pipe(Ref_dist_effectRef.getAndSet(sinkLeftovers, Chunk_dist_effectChunk.empty()), Effect_dist_effectEffect.flatMap(leftovers => {
-      if (Chunk_dist_effectChunk.isNonEmpty(leftovers)) {
-        return Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(consumed, true), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(sink.write(leftovers), sink.flatMap(() => handoffConsumer)))));
-      }
-      return Function_dist_effectFunction.pipe(take$1(handoff), Effect_dist_effectEffect.map(signal => {
-        switch (signal._tag) {
-          case OP_EMIT:
-            {
-              return Function_dist_effectFunction.pipe(sink.fromEffect(Ref_dist_effectRef.set(consumed, true)), sink.zipRight(sink.write(signal.elements)), sink.zipRight(sink.fromEffect(Ref_dist_effectRef.get(endAfterEmit))), sink.flatMap(bool => bool ? sink.unit : handoffConsumer));
-            }
-          case OP_HALT:
-            {
-              return sink.failCause(signal.cause);
-            }
-          case OP_END:
-            {
-              if (signal.reason._tag === OP_SCHEDULE_END) {
-                return Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(consumed), Effect_dist_effectEffect.map(bool => bool ? sink.fromEffect(Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkEndReason, ScheduleEnd), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, true)))) : Function_dist_effectFunction.pipe(sink.fromEffect(Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkEndReason, ScheduleEnd), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, true)))), sink.flatMap(() => handoffConsumer))), sink.unwrap);
-              }
-              return Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkEndReason, signal.reason), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, true)), sink.fromEffect);
-            }
-        }
-      }));
-    }), sink.unwrap);
-    const timeout = lastB => scheduleDriver.next(lastB);
-    const scheduledAggregator = (sinkFiber, scheduleFiber, scope) => {
-      const forkSink = Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(consumed, false), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(endAfterEmit, false)), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(handoffConsumer, sink.pipeToOrFail(sink.toChannel(sink$1)), sink.collectElements, sink.run, Effect_dist_effectEffect.forkIn(scope))));
-      const handleSide = (leftovers, b, c) => Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(sinkLeftovers, Chunk_dist_effectChunk.flatten(leftovers)), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.map(Ref_dist_effectRef.get(sinkEndReason), reason => {
-        switch (reason._tag) {
-          case OP_SCHEDULE_END:
-            {
-              return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all([Ref_dist_effectRef.get(consumed), forkSink, Function_dist_effectFunction.pipe(timeout(Option_dist_effectOption.some(b)), Effect_dist_effectEffect.forkIn(scope))]), Effect_dist_effectEffect.map(([wasConsumed, sinkFiber, scheduleFiber]) => {
-                const toWrite = Function_dist_effectFunction.pipe(c, Option_dist_effectOption.match({
-                  onNone: () => Chunk_dist_effectChunk.of(Either_dist_effectEither.right(b)),
-                  onSome: c => Chunk_dist_effectChunk.make(Either_dist_effectEither.right(b), Either_dist_effectEither.left(c))
-                }));
-                if (wasConsumed) {
-                  return Function_dist_effectFunction.pipe(sink.write(toWrite), sink.flatMap(() => scheduledAggregator(sinkFiber, scheduleFiber, scope)));
-                }
-                return scheduledAggregator(sinkFiber, scheduleFiber, scope);
-              }), sink.unwrap);
-            }
-          case OP_UPSTREAM_END:
-            {
-              return Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(consumed), Effect_dist_effectEffect.map(wasConsumed => wasConsumed ? sink.write(Chunk_dist_effectChunk.of(Either_dist_effectEither.right(b))) : sink.unit), sink.unwrap);
-            }
-        }
-      })), sink.unwrap);
-      return sink.unwrap(Effect_dist_effectEffect.raceWith(Fiber_dist_effectFiber.join(sinkFiber), Fiber_dist_effectFiber.join(scheduleFiber), {
-        onSelfDone: (sinkExit, _) => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(scheduleFiber), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => sinkExit), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.none()))))),
-        onOtherDone: (scheduleExit, _) => Effect_dist_effectEffect.matchCauseEffect(Effect_dist_effectEffect.suspend(() => scheduleExit), {
-          onFailure: cause => Either_dist_effectEither.match(Cause_dist_effectCause.failureOrCause(cause), {
-            onLeft: () => Function_dist_effectFunction.pipe(handoff, offer(end$1(ScheduleEnd)), Effect_dist_effectEffect.forkDaemon, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(sinkFiber), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.none()))))),
-            onRight: cause => Function_dist_effectFunction.pipe(handoff, offer(halt(cause)), Effect_dist_effectEffect.forkDaemon, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(sinkFiber), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.none())))))
-          }),
-          onSuccess: c => Function_dist_effectFunction.pipe(handoff, offer(end$1(ScheduleEnd)), Effect_dist_effectEffect.forkDaemon, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(sinkFiber), Effect_dist_effectEffect.map(([leftovers, b]) => handleSide(leftovers, b, Option_dist_effectOption.some(c))))))
-        })
-      }));
-    };
-    return unwrapScoped(Function_dist_effectFunction.pipe(self, toChannel, sink.pipeTo(handoffProducer), sink.run, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(handoffConsumer, sink.pipeToOrFail(sink.toChannel(sink$1)), sink.collectElements, sink.run, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.flatMap(sinkFiber => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forkScoped(timeout(Option_dist_effectOption.none())), Effect_dist_effectEffect.flatMap(scheduleFiber => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.scope, Effect_dist_effectEffect.map(scope => new StreamImpl(scheduledAggregator(sinkFiber, scheduleFiber, scope)))))))))));
-  }));
-});
-
-/** @internal */
-const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => map(self, () => value));
-
-/** @internal */
-const _async = (register, outputBuffer = 16) => asyncOption(cb => {
-  register(cb);
-  return Option_dist_effectOption.none();
-}, outputBuffer);
-
-/** @internal */
-const asyncEffect = (register, outputBuffer = 16) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(outputBuffer), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(output => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.runtime(), Effect_dist_effectEffect.flatMap(runtime => Function_dist_effectFunction.pipe(register(make$2(k => Function_dist_effectFunction.pipe(take$2.fromPull(k), Effect_dist_effectEffect.flatMap(take => Queue_dist_effectQueue.offer(output, take)), Effect_dist_effectEffect.asUnit, Runtime_dist_effectRuntime.runPromiseExit(runtime)).then(exit => {
-  if (Exit_dist_effectExit.isFailure(exit)) {
-    if (!Cause_dist_effectCause.isInterrupted(exit.cause)) {
-      throw Cause_dist_effectCause.squash(exit.cause);
-    }
-  }
-}))), Effect_dist_effectEffect.map(() => {
-  const loop = Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(output), Effect_dist_effectEffect.flatMap(take$2.done), Effect_dist_effectEffect.match({
-    onFailure: maybeError => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.shutdown(output)), sink.zipRight(Option_dist_effectOption.match(maybeError, {
-      onNone: () => sink.unit,
-      onSome: sink.fail
-    }))),
-    onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => loop))
-  }), sink.unwrap);
-  return loop;
-}))))), sink.unwrapScoped, fromChannel);
-
-/** @internal */
-const asyncInterrupt = (register, outputBuffer = 16) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(outputBuffer), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(output => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.runtime(), Effect_dist_effectEffect.flatMap(runtime => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => register(make$2(k => Function_dist_effectFunction.pipe(take$2.fromPull(k), Effect_dist_effectEffect.flatMap(take => Queue_dist_effectQueue.offer(output, take)), Effect_dist_effectEffect.asUnit, Runtime_dist_effectRuntime.runPromiseExit(runtime)).then(exit => {
-  if (Exit_dist_effectExit.isFailure(exit)) {
-    if (!Cause_dist_effectCause.isInterrupted(exit.cause)) {
-      throw Cause_dist_effectCause.squash(exit.cause);
-    }
-  }
-})))), Effect_dist_effectEffect.map(Either_dist_effectEither.match({
-  onLeft: canceler => {
-    const loop = Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(output), Effect_dist_effectEffect.flatMap(take$2.done), Effect_dist_effectEffect.match({
-      onFailure: maybeError => sink.zipRight(sink.fromEffect(Queue_dist_effectQueue.shutdown(output)), Option_dist_effectOption.match(maybeError, {
-        onNone: () => sink.unit,
-        onSome: sink.fail
-      })),
-      onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => loop))
-    }), sink.unwrap);
-    return Function_dist_effectFunction.pipe(fromChannel(loop), ensuring(canceler));
-  },
-  onRight: stream => unwrap(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.shutdown(output), Effect_dist_effectEffect.as(stream)))
-})))))), unwrapScoped);
-
-/** @internal */
-const asyncOption = (register, outputBuffer = 16) => asyncInterrupt(emit => Option_dist_effectOption.match(register(emit), {
-  onNone: () => Either_dist_effectEither.left(Effect_dist_effectEffect.unit),
-  onSome: Either_dist_effectEither.right
-}), outputBuffer);
-
-/** @internal */
-const asyncScoped = (register, outputBuffer = 16) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(outputBuffer), queue => Queue_dist_effectQueue.shutdown(queue)), Effect_dist_effectEffect.flatMap(output => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.runtime(), Effect_dist_effectEffect.flatMap(runtime => Function_dist_effectFunction.pipe(register(make$2(k => Function_dist_effectFunction.pipe(take$2.fromPull(k), Effect_dist_effectEffect.flatMap(take => Queue_dist_effectQueue.offer(output, take)), Effect_dist_effectEffect.asUnit, Runtime_dist_effectRuntime.runPromiseExit(runtime)).then(exit => {
-  if (Exit_dist_effectExit.isFailure(exit)) {
-    if (!Cause_dist_effectCause.isInterrupted(exit.cause)) {
-      throw Cause_dist_effectCause.squash(exit.cause);
-    }
-  }
-}))), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.make(false)), Effect_dist_effectEffect.flatMap(ref => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.map(isDone => isDone ? end() : Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(output), Effect_dist_effectEffect.flatMap(take$2.done), Effect_dist_effectEffect.onError(() => Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(ref, true), Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.shutdown(output)))))))))))), scoped, flatMap(repeatEffectChunkOption));
-
-/** @internal */
-const branchAfter = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, f) => suspend(() => {
-  const buffering = acc => sink.readWith({
-    onInput: input => {
-      const nextSize = acc.length + input.length;
-      if (nextSize >= n) {
-        const [b1, b2] = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.splitAt(n - acc.length));
-        return running(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(b1)), b2);
-      }
-      return buffering(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.appendAll(input)));
-    },
-    onFailure: sink.fail,
-    onDone: () => running(acc, Chunk_dist_effectChunk.empty())
-  });
-  const running = (prefix, leftover) => sink.pipeTo(sink.zipRight(sink.write(leftover), sink.identityChannel()), toChannel(f(prefix)));
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(buffering(Chunk_dist_effectChunk.empty()))));
-}));
-
-/** @internal */
-const broadcast = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, maximumLag) => Function_dist_effectFunction.pipe(self, broadcastedQueues(n, maximumLag), Effect_dist_effectEffect.map(tuple => tuple.map(queue => flattenTake(fromQueue(queue, {
-  shutdown: true
-}))))));
-
-/** @internal */
-const broadcastDynamic = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, maximumLag) => Function_dist_effectFunction.pipe(self, broadcastedQueuesDynamic(maximumLag), Effect_dist_effectEffect.map(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
-
-/** @internal */
-const broadcastedQueues = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, maximumLag) => Effect_dist_effectEffect.flatMap(Hub_dist_effectHub.bounded(maximumLag), hub => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all(Array.from({
-  length: n
-}, () => Hub_dist_effectHub.subscribe(hub))), Effect_dist_effectEffect.tap(() => Effect_dist_effectEffect.forkScoped(runIntoHubScoped(self, hub))))));
-
-/** @internal */
-const broadcastedQueuesDynamic = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, maximumLag) => Effect_dist_effectEffect.map(toHub(self, maximumLag), Hub_dist_effectHub.subscribe));
-
-/** @internal */
-const buffer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  if (options.capacity === "unbounded") {
-    return bufferUnbounded(self);
-  } else if (options.strategy === "dropping") {
-    return bufferDropping(self, options.capacity);
-  } else if (options.strategy === "sliding") {
-    return bufferSliding(self, options.capacity);
-  }
-  const queue = toQueueOfElements(self, options);
-  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.map(queue, queue => {
-    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(Exit_dist_effectExit.match({
-      onFailure: cause => Function_dist_effectFunction.pipe(Cause_dist_effectCause.flipCauseOption(cause), Option_dist_effectOption.match({
-        onNone: () => sink.unit,
-        onSome: sink.failCause
-      })),
-      onSuccess: value => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(value)), () => process)
-    })));
-    return process;
-  })));
-});
-
-/** @internal */
-const bufferChunks = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  if (options.strategy === "dropping") {
-    return bufferChunksDropping(self, options.capacity);
-  } else if (options.strategy === "sliding") {
-    return bufferChunksSliding(self, options.capacity);
-  }
-  const queue = toQueue(self, options);
-  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.map(queue, queue => {
-    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(take$2.match({
-      onEnd: () => sink.unit,
-      onFailure: sink.failCause,
-      onSuccess: value => Function_dist_effectFunction.pipe(sink.write(value), sink.flatMap(() => process))
-    })));
-    return process;
-  })));
-});
-const bufferChunksDropping = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
-  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.dropping(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
-  return new StreamImpl(bufferSignal(queue, toChannel(self)));
-});
-const bufferChunksSliding = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
-  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.sliding(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
-  return new StreamImpl(bufferSignal(queue, toChannel(self)));
-});
-const bufferDropping = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
-  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.dropping(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
-  return new StreamImpl(bufferSignal(queue, toChannel(rechunk(1)(self))));
-});
-const bufferSliding = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => {
-  const queue = Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.sliding(capacity), queue => Queue_dist_effectQueue.shutdown(queue));
-  return new StreamImpl(bufferSignal(queue, toChannel(Function_dist_effectFunction.pipe(self, rechunk(1)))));
-});
-const bufferUnbounded = self => {
-  const queue = toQueue(self, {
-    strategy: "unbounded"
-  });
-  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.map(queue, queue => {
-    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(take$2.match({
-      onEnd: () => sink.unit,
-      onFailure: sink.failCause,
-      onSuccess: value => sink.flatMap(sink.write(value), () => process)
-    })));
-    return process;
-  })));
-};
-
-/** @internal */
-const bufferSignal = (scoped, bufferChannel) => {
-  const producer = (queue, ref) => {
-    const terminate = take => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.tap(Deferred_dist_effectDeferred._await), Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred.make()), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, [take, deferred]), Effect_dist_effectEffect.zipRight(Ref_dist_effectRef.set(ref, deferred)), Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred._await(deferred)))), Effect_dist_effectEffect.asUnit, sink.fromEffect);
-    return sink.readWithCause({
-      onInput: input => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, [take$2.chunk(input), deferred]), Effect_dist_effectEffect.flatMap(added => Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(ref, deferred), Effect_dist_effectEffect.when(() => added))))), Effect_dist_effectEffect.asUnit, sink.fromEffect, sink.flatMap(() => producer(queue, ref))),
-      onFailure: error => terminate(take$2.failCause(error)),
-      onDone: () => terminate(take$2.end)
-    });
-  };
-  const consumer = queue => {
-    const process = Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.take(queue)), sink.flatMap(([take, deferred]) => sink.zipRight(sink.fromEffect(Deferred_dist_effectDeferred.succeed(deferred, void 0)), take$2.match(take, {
-      onEnd: () => sink.unit,
-      onFailure: sink.failCause,
-      onSuccess: value => Function_dist_effectFunction.pipe(sink.write(value), sink.flatMap(() => process))
-    }))));
-    return process;
-  };
-  return sink.unwrapScoped(Function_dist_effectFunction.pipe(scoped, Effect_dist_effectEffect.flatMap(queue => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.tap(start => Deferred_dist_effectDeferred.succeed(start, void 0)), Effect_dist_effectEffect.flatMap(start => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(start), Effect_dist_effectEffect.flatMap(ref => Function_dist_effectFunction.pipe(bufferChannel, sink.pipeTo(producer(queue, ref)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.as(consumer(queue))))))));
-};
-
-/** @internal */
-const catchAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => catchAllCause(self, cause => Either_dist_effectEither.match(Cause_dist_effectCause.failureOrCause(cause), {
-  onLeft: f,
-  onRight: failCause
-})));
-
-/** @internal */
-const catchAllCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.catchAllCause(cause => toChannel(f(cause))))));
-
-/** @internal */
-const catchSome = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(self, catchAll(error => Function_dist_effectFunction.pipe(pf(error), Option_dist_effectOption.getOrElse(() => fail(error))))));
-
-/** @internal */
-const catchSomeCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(self, catchAllCause(cause => Function_dist_effectFunction.pipe(pf(cause), Option_dist_effectOption.getOrElse(() => failCause(cause))))));
-
-/* @internal */
-const catchTag = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, k, f) => catchAll(self, e => {
-  if ("_tag" in e && e["_tag"] === k) {
-    return f(e);
-  }
-  return fail(e);
-}));
-
-/** @internal */
-const catchTags = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cases) => catchAll(self, e => {
-  const keys = Object.keys(cases);
-  if ("_tag" in e && keys.includes(e["_tag"])) {
-    return cases[e["_tag"]](e);
-  }
-  return fail(e);
-}));
-
-/** @internal */
-const changes = self => Function_dist_effectFunction.pipe(self, changesWith((x, y) => Equal_dist_effectEqual.equals(y)(x)));
-
-/** @internal */
-const changesWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const writer = last => sink.readWithCause({
-    onInput: input => {
-      const [newLast, newChunk] = Chunk_dist_effectChunk.reduce(input, [last, Chunk_dist_effectChunk.empty()], ([option, outputs], output) => {
-        if (Option_dist_effectOption.isSome(option) && f(option.value, output)) {
-          return [Option_dist_effectOption.some(output), outputs];
-        }
-        return [Option_dist_effectOption.some(output), Function_dist_effectFunction.pipe(outputs, Chunk_dist_effectChunk.append(output))];
-      });
-      return sink.flatMap(sink.write(newChunk), () => writer(newLast));
-    },
-    onFailure: sink.failCause,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer(Option_dist_effectOption.none()))));
-});
-
-/** @internal */
-const changesWithEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const writer = last => sink.readWithCause({
-    onInput: input => Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.reduce([last, Chunk_dist_effectChunk.empty()], ([option, outputs], output) => {
-      if (Option_dist_effectOption.isSome(option)) {
-        return Function_dist_effectFunction.pipe(f(option.value, output), Effect_dist_effectEffect.map(bool => bool ? [Option_dist_effectOption.some(output), outputs] : [Option_dist_effectOption.some(output), Function_dist_effectFunction.pipe(outputs, Chunk_dist_effectChunk.append(output))]));
-      }
-      return Effect_dist_effectEffect.succeed([Option_dist_effectOption.some(output), Function_dist_effectFunction.pipe(outputs, Chunk_dist_effectChunk.append(output))]);
-    }), sink.fromEffect, sink.flatMap(([newLast, newChunk]) => Function_dist_effectFunction.pipe(sink.write(newChunk), sink.flatMap(() => writer(newLast))))),
-    onFailure: sink.failCause,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer(Option_dist_effectOption.none()))));
-});
-
-/** @internal */
-const chunks = self => Function_dist_effectFunction.pipe(self, mapChunks(Chunk_dist_effectChunk.of));
-
-/** @internal */
-const chunksWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => flattenChunks(f(chunks(self))));
-const unsome = effect => Effect_dist_effectEffect.catchAll(Effect_dist_effectEffect.asSome(effect), o => o._tag === "None" ? Effect_dist_effectEffect.succeedNone : Effect_dist_effectEffect.fail(o.value));
-
-/** @internal */
-const combine = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, that, s, f) => {
-  const producer = (handoff, latch) => Function_dist_effectFunction.pipe(sink.fromEffect(take$1(latch)), sink.zipRight(sink.readWithCause({
-    onInput: input => sink.flatMap(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer(Exit_dist_effectExit.succeed(input)))), () => producer(handoff, latch)),
-    onFailure: cause => sink.fromEffect(offer(handoff, Exit_dist_effectExit.failCause(Function_dist_effectFunction.pipe(cause, Cause_dist_effectCause.map(Option_dist_effectOption.some))))),
-    onDone: () => sink.flatMap(sink.fromEffect(offer(handoff, Exit_dist_effectExit.fail(Option_dist_effectOption.none()))), () => producer(handoff, latch))
-  })));
-  return new StreamImpl(sink.unwrapScoped(Effect_dist_effectEffect.gen(function* ($) {
-    const left = yield* $(make$1());
-    const right = yield* $(make$1());
-    const latchL = yield* $(make$1());
-    const latchR = yield* $(make$1());
-    yield* $(toChannel(self), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(left, latchL)), sink.runScoped, Effect_dist_effectEffect.forkScoped);
-    yield* $(toChannel(that), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(right, latchR)), sink.runScoped, Effect_dist_effectEffect.forkScoped);
-    const pullLeft = Function_dist_effectFunction.pipe(latchL, offer(void 0),
-    // TODO: remove
-    Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(left), Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)))));
-    const pullRight = Function_dist_effectFunction.pipe(latchR, offer(void 0),
-    // TODO: remove
-    Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(right), Effect_dist_effectEffect.flatMap(exit => Effect_dist_effectEffect.suspend(() => exit)))));
-    return toChannel(unfoldEffect(s, s => Effect_dist_effectEffect.flatMap(f(s, pullLeft, pullRight), unsome)));
-  })));
-});
-
-/** @internal */
-const combineChunks = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, that, s, f) => {
-  const producer = (handoff, latch) => sink.zipRight(sink.fromEffect(take$1(latch)), sink.readWithCause({
-    onInput: input => sink.flatMap(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer(take$2.chunk(input)))), () => producer(handoff, latch)),
-    onFailure: cause => sink.fromEffect(offer(handoff, take$2.failCause(cause))),
-    onDone: () => sink.fromEffect(offer(handoff, take$2.end))
-  }));
-  return new StreamImpl(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all([make$1(), make$1(), make$1(), make$1()]), Effect_dist_effectEffect.tap(([left, _, latchL]) => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(producer(left, latchL)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.tap(([_, right, __, latchR]) => Function_dist_effectFunction.pipe(toChannel(that), sink.pipeTo(producer(right, latchR)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.map(([left, right, latchL, latchR]) => {
-    const pullLeft = Function_dist_effectFunction.pipe(latchL, offer(void 0), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(left), Effect_dist_effectEffect.flatMap(take$2.done))));
-    const pullRight = Function_dist_effectFunction.pipe(latchR, offer(void 0), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(take$1(right), Effect_dist_effectEffect.flatMap(take$2.done))));
-    return toChannel(unfoldChunkEffect(s, s => Effect_dist_effectEffect.flatMap(f(s, pullLeft, pullRight), unsome)));
-  }), sink.unwrapScoped));
-});
-
-/** @internal */
-const concat = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.zipRight(toChannel(that)))));
-
-/** @internal */
-const concatAll = streams => suspend(() => Function_dist_effectFunction.pipe(streams, Chunk_dist_effectChunk.reduce(empty, (x, y) => concat(y)(x))));
-
-/** @internal */
-const cross = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, crossWith(that, (a, a2) => [a, a2])));
-
-/** @internal */
-const crossLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, crossWith(that, (a, _) => a)));
-
-/** @internal */
-const crossRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => flatMap(self, () => that));
-
-/** @internal */
-const crossWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => Function_dist_effectFunction.pipe(self, flatMap(a => Function_dist_effectFunction.pipe(that, map(b => f(a, b))))));
-
-/** @internal */
-const debounce = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(singleProducerAsyncInput.make(), Effect_dist_effectEffect.flatMap(input => Effect_dist_effectEffect.transplant(grafter => Function_dist_effectFunction.pipe(make$1(), Effect_dist_effectEffect.map(handoff => {
-  const enqueue = last => Function_dist_effectFunction.pipe(Clock_dist_effectClock.sleep(duration), Effect_dist_effectEffect.as(last), Effect_dist_effectEffect.fork, grafter, Effect_dist_effectEffect.map(fiber => consumer(previous(fiber))));
-  const producer = sink.readWithCause({
-    onInput: input => Option_dist_effectOption.match(Chunk_dist_effectChunk.last(input), {
-      onNone: () => producer,
-      onSome: last => sink.flatMap(sink.fromEffect(offer(handoff, emit(Chunk_dist_effectChunk.of(last)))), () => producer)
-    }),
-    onFailure: cause => sink.fromEffect(offer(handoff, halt(cause))),
-    onDone: () => sink.fromEffect(offer(handoff, end$1(UpstreamEnd)))
-  });
-  const consumer = state => {
-    switch (state._tag) {
-      case OP_NOT_STARTED:
-        {
-          return Function_dist_effectFunction.pipe(take$1(handoff), Effect_dist_effectEffect.map(signal => {
-            switch (signal._tag) {
-              case OP_EMIT:
-                {
-                  return sink.unwrap(enqueue(signal.elements));
-                }
-              case OP_HALT:
-                {
-                  return sink.failCause(signal.cause);
-                }
-              case OP_END:
-                {
-                  return sink.unit;
-                }
-            }
-          }), sink.unwrap);
-        }
-      case OP_PREVIOUS:
-        {
-          return sink.unwrap(Effect_dist_effectEffect.raceWith(Fiber_dist_effectFiber.join(state.fiber), take$1(handoff), {
-            onSelfDone: (leftExit, current$1) => Exit_dist_effectExit.match(leftExit, {
-              onFailure: cause => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(current$1), Effect_dist_effectEffect.as(sink.failCause(cause))),
-              onSuccess: chunk => Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => consumer(current(current$1)))))
-            }),
-            onOtherDone: (rightExit, previous) => Exit_dist_effectExit.match(rightExit, {
-              onFailure: cause => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(previous), Effect_dist_effectEffect.as(sink.failCause(cause))),
-              onSuccess: signal => {
-                switch (signal._tag) {
-                  case OP_EMIT:
-                    {
-                      return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(previous), Effect_dist_effectEffect.zipRight(enqueue(signal.elements)));
-                    }
-                  case OP_HALT:
-                    {
-                      return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.interrupt(previous), Effect_dist_effectEffect.as(sink.failCause(signal.cause)));
-                    }
-                  case OP_END:
-                    {
-                      return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(previous), Effect_dist_effectEffect.map(chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.zipRight(sink.unit))));
-                    }
-                }
-              }
-            })
-          }));
-        }
-      case OP_CURRENT:
-        {
-          return Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.join(state.fiber), Effect_dist_effectEffect.map(signal => {
-            switch (signal._tag) {
-              case OP_EMIT:
-                {
-                  return sink.unwrap(enqueue(signal.elements));
-                }
-              case OP_HALT:
-                {
-                  return sink.failCause(signal.cause);
-                }
-              case OP_END:
-                {
-                  return sink.unit;
-                }
-            }
-          }), sink.unwrap);
-        }
-    }
-  };
-  const debounceChannel = Function_dist_effectFunction.pipe(sink.fromInput(input), sink.pipeTo(producer), sink.run, Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.as(Function_dist_effectFunction.pipe(consumer(notStarted), sink.embedInput(input))), sink.unwrapScoped);
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(debounceChannel)));
-})))), unwrap));
-
-/** @internal */
-const die = defect => fromEffect(Effect_dist_effectEffect.die(defect));
-
-/** @internal */
-const dieSync = evaluate => fromEffect(Effect_dist_effectEffect.dieSync(evaluate));
-
-/** @internal */
-const dieMessage = message => fromEffect(Effect_dist_effectEffect.dieMessage(message));
-
-/** @internal */
-const distributedWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(self, distributedWithDynamic({
-  maximumLag: options.maximumLag,
-  decide: a => Effect_dist_effectEffect.flatMap(Deferred_dist_effectDeferred._await(deferred), f => f(a))
-}), Effect_dist_effectEffect.flatMap(next => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.all(Chunk_dist_effectChunk.map(Chunk_dist_effectChunk.range(0, options.size - 1), id => Effect_dist_effectEffect.map(next, ([key, queue]) => [[key, id], queue]))), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray), Effect_dist_effectEffect.flatMap(entries => {
-  const [mappings, queues] = Chunk_dist_effectChunk.reduceRight(entries, [new Map(), Chunk_dist_effectChunk.empty()], ([mappings, queues], [mapping, queue]) => [mappings.set(mapping[0], mapping[1]), Function_dist_effectFunction.pipe(queues, Chunk_dist_effectChunk.prepend(queue))]);
-  return Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.succeed(deferred, a => Effect_dist_effectEffect.map(options.decide(a), f => key => Function_dist_effectFunction.pipe(f(mappings.get(key))))), Effect_dist_effectEffect.as(Array.from(queues)));
-})))))));
-
-/** @internal */
-const distributedWithDynamicId = {
-  ref: 0
-};
-const newDistributedWithDynamicId = () => {
-  const current = distributedWithDynamicId.ref;
-  distributedWithDynamicId.ref = current + 1;
-  return current;
-};
-
-/** @internal */
-const distributedWithDynamic = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => distributedWithDynamicCallback(self, options.maximumLag, options.decide, () => Effect_dist_effectEffect.unit));
-const distributedWithDynamicCallback = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, maximumLag, decide, done) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Ref_dist_effectRef.make(new Map()), (ref, _) => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(ref), Effect_dist_effectEffect.flatMap(queues => Function_dist_effectFunction.pipe(queues.values(), Effect_dist_effectEffect.forEach(Queue_dist_effectQueue.shutdown))))), Effect_dist_effectEffect.flatMap(queuesRef => Effect_dist_effectEffect.gen(function* ($) {
-  const offer = a => Function_dist_effectFunction.pipe(decide(a), Effect_dist_effectEffect.flatMap(shouldProcess => Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(queuesRef), Effect_dist_effectEffect.flatMap(queues => Function_dist_effectFunction.pipe(queues.entries(), Effect_dist_effectEffect.reduce(Chunk_dist_effectChunk.empty(), (acc, [id, queue]) => {
-    if (shouldProcess(id)) {
-      return Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, Exit_dist_effectExit.succeed(a)), Effect_dist_effectEffect.matchCauseEffect({
-        onFailure: cause =>
-        // Ignore all downstream queues that were shut
-        // down and remove them later
-        Cause_dist_effectCause.isInterrupted(cause) ? Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.prepend(id))) : Effect_dist_effectEffect.failCause(cause),
-        onSuccess: () => Effect_dist_effectEffect.succeed(acc)
-      }));
-    }
-    return Effect_dist_effectEffect.succeed(acc);
-  }), Effect_dist_effectEffect.flatMap(ids => {
-    if (Chunk_dist_effectChunk.isNonEmpty(ids)) {
-      return Function_dist_effectFunction.pipe(Ref_dist_effectRef.update(queuesRef, map => {
-        for (const id of ids) {
-          map.delete(id);
-        }
-        return map;
-      }));
-    }
-    return Effect_dist_effectEffect.unit;
-  }))))), Effect_dist_effectEffect.asUnit);
-  const queuesLock = yield* $(Effect_dist_effectEffect.makeSemaphore(1));
-  const newQueue = yield* $(Ref_dist_effectRef.make(Function_dist_effectFunction.pipe(Queue_dist_effectQueue.bounded(maximumLag), Effect_dist_effectEffect.flatMap(queue => {
-    const id = newDistributedWithDynamicId();
-    return Function_dist_effectFunction.pipe(Ref_dist_effectRef.update(queuesRef, map => map.set(id, queue)), Effect_dist_effectEffect.as([id, queue]));
-  }))));
-  const finalize = endTake =>
-  // Make sure that no queues are currently being added
-  queuesLock.withPermits(1)(Function_dist_effectFunction.pipe(Ref_dist_effectRef.set(newQueue, Function_dist_effectFunction.pipe(
-  // All newly created queues should end immediately
-  Queue_dist_effectQueue.bounded(1), Effect_dist_effectEffect.tap(queue => Queue_dist_effectQueue.offer(queue, endTake)), Effect_dist_effectEffect.flatMap(queue => {
-    const id = newDistributedWithDynamicId();
-    return Function_dist_effectFunction.pipe(Ref_dist_effectRef.update(queuesRef, map => map.set(id, queue)), Effect_dist_effectEffect.as([id, queue]));
-  }))), Effect_dist_effectEffect.zipRight(Function_dist_effectFunction.pipe(Ref_dist_effectRef.get(queuesRef), Effect_dist_effectEffect.flatMap(map => Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.fromIterable(map.values()), Effect_dist_effectEffect.forEach(queue => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.offer(queue, endTake), Effect_dist_effectEffect.catchSomeCause(cause => Cause_dist_effectCause.isInterrupted(cause) ? Option_dist_effectOption.some(Effect_dist_effectEffect.unit) : Option_dist_effectOption.none()))))))), Effect_dist_effectEffect.zipRight(done(endTake)), Effect_dist_effectEffect.asUnit));
-  yield* $(self, runForEachScoped(offer), Effect_dist_effectEffect.matchCauseEffect({
-    onFailure: cause => finalize(Exit_dist_effectExit.failCause(Function_dist_effectFunction.pipe(cause, Cause_dist_effectCause.map(Option_dist_effectOption.some)))),
-    onSuccess: () => finalize(Exit_dist_effectExit.fail(Option_dist_effectOption.none()))
-  }), Effect_dist_effectEffect.forkScoped);
-  return queuesLock.withPermits(1)(Effect_dist_effectEffect.flatten(Ref_dist_effectRef.get(newQueue)));
-}))));
-
-/** @internal */
-const drain = self => new StreamImpl(sink.drain(toChannel(self)));
-
-/** @internal */
-const drainFork = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(fromEffect(Deferred_dist_effectDeferred.make()), flatMap(backgroundDied => Function_dist_effectFunction.pipe(scoped(Function_dist_effectFunction.pipe(that, runForEachScoped(() => Effect_dist_effectEffect.unit), Effect_dist_effectEffect.catchAllCause(cause => Deferred_dist_effectDeferred.failCause(backgroundDied, cause)), Effect_dist_effectEffect.forkScoped)), crossRight(Function_dist_effectFunction.pipe(self, interruptWhenDeferred(backgroundDied)))))));
-
-/** @internal */
-const drop = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  const loop = r => sink.readWith({
-    onInput: input => {
-      const dropped = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(r));
-      const leftover = Math.max(0, r - input.length);
-      const more = Chunk_dist_effectChunk.isEmpty(input) || leftover > 0;
-      if (more) {
-        return loop(leftover);
-      }
-      return Function_dist_effectFunction.pipe(sink.write(dropped), sink.zipRight(sink.identityChannel()));
-    },
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop(n))));
-});
-
-/** @internal */
-const dropRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  if (n <= 0) {
-    return identityStream();
-  }
-  return suspend(() => {
-    const queue = new RingBuffer(n);
-    const reader = sink.readWith({
-      onInput: input => {
-        const outputs = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.filterMap(elem => {
-          const head = queue.head();
-          queue.put(elem);
-          return head;
-        }));
-        return Function_dist_effectFunction.pipe(sink.write(outputs), sink.flatMap(() => reader));
-      },
-      onFailure: sink.fail,
-      onDone: () => sink.unit
-    });
-    return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(reader)));
-  });
-});
-
-/** @internal */
-const dropUntil = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => drop(dropWhile(self, a => !predicate(a)), 1));
-
-/** @internal */
-const dropUntilEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.dropUntil(input, predicate), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray), Effect_dist_effectEffect.map(leftover => {
-      const more = Chunk_dist_effectChunk.isEmpty(leftover);
-      if (more) {
-        return sink.suspend(() => loop);
-      }
-      return Function_dist_effectFunction.pipe(sink.write(leftover), sink.zipRight(sink.identityChannel()));
-    }), sink.unwrap),
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
-});
-
-/** @internal */
-const dropWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => {
-      const output = Chunk_dist_effectChunk.dropWhile(input, predicate);
-      if (Chunk_dist_effectChunk.isEmpty(output)) {
-        return sink.suspend(() => loop);
-      }
-      return sink.zipRight(sink.write(output), sink.identityChannel());
-    },
-    onFailure: sink.fail,
-    onDone: sink.succeedNow
-  });
-  return new StreamImpl(sink.pipeToOrFail(toChannel(self), loop));
-});
-
-/** @internal */
-const dropWhileEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.dropWhile(input, predicate), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.unsafeFromArray), Effect_dist_effectEffect.map(leftover => {
-      const more = Chunk_dist_effectChunk.isEmpty(leftover);
-      if (more) {
-        return sink.suspend(() => loop);
-      }
-      return sink.zipRight(sink.write(leftover), sink.identityChannel());
-    }), sink.unwrap),
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(sink.pipeToOrFail(toChannel(self), loop));
-});
-
-/** @internal */
-const either = self => Function_dist_effectFunction.pipe(self, map(Either_dist_effectEither.right), catchAll(error => make(Either_dist_effectEither.left(error))));
-
-/** @internal */
-const empty = /*#__PURE__*/new StreamImpl( /*#__PURE__*/sink.write( /*#__PURE__*/Chunk_dist_effectChunk.empty()));
-
-/** @internal */
-const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.ensuring(finalizer))));
-
-/** @internal */
-const ensuringWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => new StreamImpl(sink.ensuringWith(toChannel(self), finalizer)));
-
-/** @internal */
-const context = () => fromEffect(Effect_dist_effectEffect.context());
-
-/** @internal */
-const contextWith = f => Function_dist_effectFunction.pipe(context(), map(f));
-
-/** @internal */
-const contextWithEffect = f => Function_dist_effectFunction.pipe(context(), mapEffectSequential(f));
-
-/** @internal */
-const contextWithStream = f => Function_dist_effectFunction.pipe(context(), flatMap(f));
-
-/** @internal */
-const execute = effect => drain(fromEffect(effect));
-
-/** @internal */
-const fail = error => fromEffectOption(Effect_dist_effectEffect.fail(Option_dist_effectOption.some(error)));
-
-/** @internal */
-const failSync = evaluate => fromEffectOption(Effect_dist_effectEffect.failSync(() => Option_dist_effectOption.some(evaluate())));
-
-/** @internal */
-const failCause = cause => fromEffect(Effect_dist_effectEffect.failCause(cause));
-
-/** @internal */
-const failCauseSync = evaluate => fromEffect(Effect_dist_effectEffect.failCauseSync(evaluate));
-
-/** @internal */
-const filter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => mapChunks(self, Chunk_dist_effectChunk.filter(predicate)));
-
-/** @internal */
-const filterEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const loop = iterator => {
-    const next = iterator.next();
-    if (next.done) {
-      return sink.readWithCause({
-        onInput: input => loop(input[Symbol.iterator]()),
-        onFailure: sink.failCause,
-        onDone: sink.succeed
-      });
-    } else {
-      return Function_dist_effectFunction.pipe(f(next.value), Effect_dist_effectEffect.map(bool => bool ? Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(next.value)), sink.flatMap(() => loop(iterator))) : loop(iterator)), sink.unwrap);
-    }
-  };
-  return new StreamImpl(sink.suspend(() => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]())))));
-});
-
-/** @internal */
-const filterMap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => mapChunks(self, Chunk_dist_effectChunk.filterMap(pf)));
-
-/** @internal */
-const filterMapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => suspend(() => {
-  const loop = iterator => {
-    const next = iterator.next();
-    if (next.done) {
-      return sink.readWithCause({
-        onInput: input => loop(input[Symbol.iterator]()),
-        onFailure: sink.failCause,
-        onDone: sink.succeed
-      });
-    } else {
-      return Function_dist_effectFunction.pipe(pf(next.value), Option_dist_effectOption.match({
-        onNone: () => Effect_dist_effectEffect.sync(() => loop(iterator)),
-        onSome: Effect_dist_effectEffect.map(a2 => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(a2)), () => loop(iterator)))
-      }), sink.unwrap);
-    }
-  };
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]()))));
-}));
-
-/** @internal */
-const filterMapWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => {
-  const loop = sink.readWith({
-    onInput: input => {
-      const mapped = Chunk_dist_effectChunk.filterMapWhile(input, pf);
-      if (mapped.length === input.length) {
-        return Function_dist_effectFunction.pipe(sink.write(mapped), sink.flatMap(() => loop));
-      }
-      return sink.write(mapped);
-    },
-    onFailure: sink.fail,
-    onDone: sink.succeed
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
-});
-
-/** @internal */
-const filterMapWhileEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => suspend(() => {
-  const loop = iterator => {
-    const next = iterator.next();
-    if (next.done) {
-      return sink.readWithCause({
-        onInput: input => loop(input[Symbol.iterator]()),
-        onFailure: sink.failCause,
-        onDone: sink.succeed
-      });
-    } else {
-      return sink.unwrap(Option_dist_effectOption.match(pf(next.value), {
-        onNone: () => Effect_dist_effectEffect.succeed(sink.unit),
-        onSome: Effect_dist_effectEffect.map(a2 => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(a2)), () => loop(iterator)))
-      }));
-    }
-  };
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]()))));
-}));
-
-/** @internal */
-const finalizer = finalizer => acquireRelease(Effect_dist_effectEffect.unit, () => finalizer);
-
-/** @internal */
-const find = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => Option_dist_effectOption.match(Chunk_dist_effectChunk.findFirst(input, predicate), {
-      onNone: () => loop,
-      onSome: n => sink.write(Chunk_dist_effectChunk.of(n))
-    }),
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop)));
-});
-
-/** @internal */
-const findEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.findFirst(input, predicate), Effect_dist_effectEffect.map(Option_dist_effectOption.match({
-      onNone: () => loop,
-      onSome: n => sink.write(Chunk_dist_effectChunk.of(n))
-    })), sink.unwrap),
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop)));
-});
-
-/** @internal */
-const flatMap = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "function", (self, f, options) => {
-  const bufferSize = options?.bufferSize ?? 16;
-  if (options?.switch) {
-    return matchConcurrency(options?.concurrency, () => flatMapParSwitchBuffer(self, 1, bufferSize, f), n => flatMapParSwitchBuffer(self, n, bufferSize, f));
-  }
-  return matchConcurrency(options?.concurrency, () => new StreamImpl(sink.concatMap(toChannel(self), as => Function_dist_effectFunction.pipe(as, Chunk_dist_effectChunk.map(a => toChannel(f(a))), Chunk_dist_effectChunk.reduce(sink.unit, (left, right) => Function_dist_effectFunction.pipe(left, sink.zipRight(right)))))), n => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mergeMap(out => toChannel(f(out)), {
-    concurrency: n,
-    bufferSize
-  }))));
-});
-
-/** @internal */
-const matchConcurrency = (concurrency, sequential, bounded) => {
-  switch (concurrency) {
-    case undefined:
-      return sequential();
-    case "unbounded":
-      return bounded(Number.POSITIVE_INFINITY);
-    default:
-      return concurrency > 1 ? bounded(concurrency) : sequential();
-  }
-};
-const flatMapParSwitchBuffer = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, n, bufferSize, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mergeMap(out => toChannel(f(out)), {
-  concurrency: n,
-  mergeStrategy: mergeStrategy.BufferSliding(),
-  bufferSize
-}))));
-
-/** @internal */
-const flatten = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => flatMap(self, Function_dist_effectFunction.identity, options));
-
-/** @internal */
-const flattenChunks = self => {
-  const flatten = sink.readWithCause({
-    onInput: chunks => sink.flatMap(sink.writeChunk(chunks), () => flatten),
-    onFailure: sink.failCause,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(flatten)));
-};
-
-/** @internal */
-const flattenEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => options?.unordered ? flatMap(self, a => fromEffect(a), {
-  concurrency: options.concurrency
-}) : matchConcurrency(options?.concurrency, () => mapEffectSequential(self, Function_dist_effectFunction.identity), n => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mapOutEffectPar(Function_dist_effectFunction.identity, n), sink.mapOut(Chunk_dist_effectChunk.of)))));
-
-/** @internal */
-const flattenExitOption = self => {
-  const processChunk = (chunk, cont) => {
-    const [toEmit, rest] = Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.splitWhere(exit => !Exit_dist_effectExit.isSuccess(exit)));
-    const next = Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.head(rest), Option_dist_effectOption.match({
-      onNone: () => cont,
-      onSome: Exit_dist_effectExit.match({
-        onFailure: cause => Option_dist_effectOption.match(Cause_dist_effectCause.flipCauseOption(cause), {
-          onNone: () => sink.unit,
-          onSome: sink.failCause
-        }),
-        onSuccess: () => sink.unit
-      })
-    }));
-    return Function_dist_effectFunction.pipe(sink.write(Function_dist_effectFunction.pipe(toEmit, Chunk_dist_effectChunk.filterMap(exit => Exit_dist_effectExit.isSuccess(exit) ? Option_dist_effectOption.some(exit.value) : Option_dist_effectOption.none()))), sink.flatMap(() => next));
-  };
-  const process = sink.readWithCause({
-    onInput: chunk => processChunk(chunk, process),
-    onFailure: cause => sink.failCause(cause),
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(process)));
-};
-
-/** @internal */
-const flattenIterables = self => Function_dist_effectFunction.pipe(self, map(Chunk_dist_effectChunk.fromIterable), flattenChunks);
-
-/** @internal */
-const flattenTake = self => flattenChunks(flattenExitOption(Function_dist_effectFunction.pipe(self, map(take => take.exit))));
-
-/** @internal */
-const forever = self => new StreamImpl(sink.repeated(toChannel(self)));
-
-/** @internal */
-const fromAsyncIterable = (iterable, onError) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => iterable[Symbol.asyncIterator]()), iterator => iterator.return ? Effect_dist_effectEffect.promise(async () => iterator.return()) : Effect_dist_effectEffect.unit), Effect_dist_effectEffect.map(iterator => repeatEffectOption(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.tryPromise({
-  try: async () => iterator.next(),
-  catch: reason => Option_dist_effectOption.some(onError(reason))
-}), Effect_dist_effectEffect.flatMap(result => result.done ? Effect_dist_effectEffect.fail(Option_dist_effectOption.none()) : Effect_dist_effectEffect.succeed(result.value))))), unwrapScoped);
-
-/** @internal */
-const fromChannel = channel => new StreamImpl(channel);
-
-/** @internal */
-const toChannel = stream => {
-  if (Effect_dist_effectEffect.isEffect(stream)) {
-    return toChannel(fromEffect(stream));
-  }
-  return stream.channel;
-};
-
-/** @internal */
-const fromChunk = chunk => new StreamImpl(Chunk_dist_effectChunk.isEmpty(chunk) ? sink.unit : sink.write(chunk));
-
-/** @internal */
-const fromChunkHub = (hub, options) => {
-  if (options?.scoped) {
-    const effect = Effect_dist_effectEffect.map(Hub_dist_effectHub.subscribe(hub), fromChunkQueue);
-    return options.shutdown ? Effect_dist_effectEffect.map(effect, ensuring(Hub_dist_effectHub.shutdown(hub))) : effect;
-  }
-  const stream = flatMap(scoped(Hub_dist_effectHub.subscribe(hub)), fromChunkQueue);
-  return options?.shutdown ? ensuring(stream, Hub_dist_effectHub.shutdown(hub)) : stream;
-};
-
-/** @internal */
-const fromChunkQueue = (queue, options) => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.take(queue), Effect_dist_effectEffect.catchAllCause(cause => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.isShutdown(queue), Effect_dist_effectEffect.flatMap(isShutdown => isShutdown && Cause_dist_effectCause.isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(Queue_dist_effectQueue.shutdown(queue)) : Function_dist_effectFunction.identity);
-
-/** @internal */
-const fromChunks = (...chunks) => Function_dist_effectFunction.pipe(fromIterable(chunks), flatMap(fromChunk));
-
-/** @internal */
-const fromEffect = effect => Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some), fromEffectOption);
-
-/** @internal */
-const fromEffectOption = effect => new StreamImpl(sink.unwrap(Effect_dist_effectEffect.match(effect, {
-  onFailure: Option_dist_effectOption.match({
-    onNone: () => sink.unit,
-    onSome: sink.fail
-  }),
-  onSuccess: a => sink.write(Chunk_dist_effectChunk.of(a))
-})));
-
-/** @internal */
-const fromHub = (hub, options) => {
-  const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize;
-  if (options?.scoped) {
-    const effect = Effect_dist_effectEffect.map(Hub_dist_effectHub.subscribe(hub), queue => fromQueue(queue, {
-      maxChunkSize,
-      shutdown: true
-    }));
-    return options.shutdown ? Effect_dist_effectEffect.map(effect, ensuring(Hub_dist_effectHub.shutdown(hub))) : effect;
-  }
-  const stream = flatMap(scoped(Hub_dist_effectHub.subscribe(hub)), queue => fromQueue(queue, {
-    maxChunkSize
-  }));
-  return options?.shutdown ? ensuring(stream, Hub_dist_effectHub.shutdown(hub)) : stream;
-};
-
-/** @internal */
-const fromIterable = iterable => suspend(() => Chunk_dist_effectChunk.isChunk(iterable) ? fromChunk(iterable) : fromIteratorSucceed(iterable[Symbol.iterator]()));
-
-/** @internal */
-const fromIterableEffect = effect => Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(fromIterable), unwrap);
-
-/** @internal */
-const fromIteratorSucceed = (iterator, maxChunkSize = DefaultChunkSize) => {
-  return Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => {
-    let builder = [];
-    const loop = iterator => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.sync(() => {
-      let next = iterator.next();
-      if (maxChunkSize === 1) {
-        if (next.done) {
-          return sink.unit;
-        }
-        return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(next.value)), sink.flatMap(() => loop(iterator)));
-      }
-      builder = [];
-      let count = 0;
-      while (count < maxChunkSize && !next.done) {
-        builder.push(next.value);
-        next = iterator.next();
-        count = count + 1;
-      }
-      if (count > 0) {
-        return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.unsafeFromArray(builder)), sink.flatMap(() => loop(iterator)));
-      }
-      return sink.unit;
-    }), sink.unwrap);
-    return new StreamImpl(loop(iterator));
-  }), unwrap);
-};
-
-/** @internal */
-const fromPull = effect => Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(repeatEffectChunkOption), unwrapScoped);
-
-/** @internal */
-const fromQueue = (queue, options) => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), Effect_dist_effectEffect.catchAllCause(cause => Function_dist_effectFunction.pipe(Queue_dist_effectQueue.isShutdown(queue), Effect_dist_effectEffect.flatMap(isShutdown => isShutdown && Cause_dist_effectCause.isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(Queue_dist_effectQueue.shutdown(queue)) : Function_dist_effectFunction.identity);
-
-/** @internal */
-const fromSchedule = schedule => Function_dist_effectFunction.pipe(Schedule_dist_effectSchedule.driver(schedule), Effect_dist_effectEffect.map(driver => repeatEffectOption(driver.next(void 0))), unwrap);
-
-/** @internal */
-const fromReadableStream = (evaluate, onError) => unwrapScoped(Effect_dist_effectEffect.map(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => evaluate().getReader()), reader => Effect_dist_effectEffect.promise(() => reader.cancel())), reader => repeatEffectOption(Effect_dist_effectEffect.flatMap(Effect_dist_effectEffect.tryPromise({
-  try: () => reader.read(),
-  catch: reason => Option_dist_effectOption.some(onError(reason))
-}), ({
-  done,
-  value
-}) => done ? Effect_dist_effectEffect.fail(Option_dist_effectOption.none()) : Effect_dist_effectEffect.succeed(value)))));
-
-/** @internal */
-const fromReadableStreamByob = (evaluate, onError, allocSize = 4096) => unwrapScoped(Effect_dist_effectEffect.map(Effect_dist_effectEffect.acquireRelease(Effect_dist_effectEffect.sync(() => evaluate().getReader({
-  mode: "byob"
-})), reader => Effect_dist_effectEffect.promise(() => reader.cancel())), reader => catchAll(forever(readChunkStreamByobReader(reader, onError, allocSize)), error => typeof error === "object" && error !== null && "_tag" in error && error._tag === "EOF" ? empty : fail(error))));
-const readChunkStreamByobReader = (reader, onError, size) => {
-  const buffer = new ArrayBuffer(size);
-  return paginateEffect(0, offset => Effect_dist_effectEffect.flatMap(Effect_dist_effectEffect.tryPromise({
-    try: () => reader.read(new Uint8Array(buffer, offset, buffer.byteLength - offset)),
-    catch: reason => onError(reason)
-  }), ({
-    done,
-    value
-  }) => {
-    if (done) {
-      return Effect_dist_effectEffect.fail({
-        _tag: "EOF"
-      });
-    }
-    const newOffset = offset + value.byteLength;
-    return Effect_dist_effectEffect.succeed([value, newOffset >= buffer.byteLength ? Option_dist_effectOption.none() : Option_dist_effectOption.some(newOffset)]);
-  }));
-};
-
-/** @internal */
-const groupAdjacentBy = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const groupAdjacentByChunk = (state, chunk) => {
-    if (Chunk_dist_effectChunk.isEmpty(chunk)) {
-      return [state, Chunk_dist_effectChunk.empty()];
-    }
-    const builder = [];
-    let from = 0;
-    let until = 0;
-    let key = undefined;
-    let previousChunk = Chunk_dist_effectChunk.empty();
-    switch (state._tag) {
-      case "Some":
-        {
-          const tuple = state.value;
-          key = tuple[0];
-          let loop = true;
-          while (loop && until < chunk.length) {
-            const input = Chunk_dist_effectChunk.unsafeGet(chunk, until);
-            const updatedKey = f(input);
-            if (!Equal_dist_effectEqual.equals(key, updatedKey)) {
-              builder.push([key, Chunk_dist_effectChunk.unsafeFromArray(Array.from(tuple[1]).slice(from, until))]);
-              key = updatedKey;
-              from = until;
-              loop = false;
-            }
-            until = until + 1;
-          }
-          if (loop) {
-            previousChunk = tuple[1];
-          }
-          break;
-        }
-      case "None":
-        {
-          key = f(Chunk_dist_effectChunk.unsafeGet(chunk, until));
-          until = until + 1;
-          break;
-        }
-    }
-    while (until < chunk.length) {
-      const input = Chunk_dist_effectChunk.unsafeGet(chunk, until);
-      const updatedKey = f(input);
-      if (!Equal_dist_effectEqual.equals(key, updatedKey)) {
-        builder.push([key, Chunk_dist_effectChunk.unsafeFromArray(Array.from(chunk).slice(from, until))]);
-        key = updatedKey;
-        from = until;
-      }
-      until = until + 1;
-    }
-    const nonEmptyChunk = Chunk_dist_effectChunk.appendAll(previousChunk, Chunk_dist_effectChunk.unsafeFromArray(Array.from(chunk).slice(from, until)));
-    const output = Chunk_dist_effectChunk.unsafeFromArray(builder);
-    return [Option_dist_effectOption.some([key, nonEmptyChunk]), output];
-  };
-  const groupAdjacent = state => sink.readWithCause({
-    onInput: input => {
-      const [updatedState, output] = groupAdjacentByChunk(state, input);
-      return Chunk_dist_effectChunk.isEmpty(output) ? groupAdjacent(updatedState) : sink.flatMap(sink.write(output), () => groupAdjacent(updatedState));
-    },
-    onFailure: cause => Option_dist_effectOption.match(state, {
-      onNone: () => sink.failCause(cause),
-      onSome: output => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(output)), () => sink.failCause(cause))
-    }),
-    onDone: done => Option_dist_effectOption.match(state, {
-      onNone: () => sink.succeedNow(done),
-      onSome: output => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(output)), () => sink.succeedNow(done))
-    })
-  });
-  return new StreamImpl(sink.pipeToOrFail(toChannel(self), groupAdjacent(Option_dist_effectOption.none())));
-});
-
-/** @internal */
-const grouped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chunkSize) => Function_dist_effectFunction.pipe(self, rechunk(chunkSize), chunks));
-
-/** @internal */
-const groupedWithin = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, chunkSize, duration) => aggregateWithin(self, sink.collectAllN(chunkSize), Schedule_dist_effectSchedule.spaced(duration)));
-
-/** @internal */
-const haltWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => {
-  const writer = fiber => Function_dist_effectFunction.pipe(Fiber_dist_effectFiber.poll(fiber), Effect_dist_effectEffect.map(Option_dist_effectOption.match({
-    onNone: () => sink.readWith({
-      onInput: input => sink.flatMap(sink.write(input), () => writer(fiber)),
-      onFailure: sink.fail,
-      onDone: () => sink.unit
-    }),
-    onSome: Exit_dist_effectExit.match({
-      onFailure: sink.failCause,
-      onSuccess: () => sink.unit
-    })
-  })), sink.unwrap);
-  return new StreamImpl(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.forkScoped(effect), Effect_dist_effectEffect.map(fiber => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer(fiber)))), sink.unwrapScoped));
-});
-
-/** @internal */
-const haltAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(self, haltWhen(Clock_dist_effectClock.sleep(duration))));
-
-/** @internal */
-const haltWhenDeferred = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, deferred) => {
-  const writer = Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.poll(deferred), Effect_dist_effectEffect.map(Option_dist_effectOption.match({
-    onNone: () => sink.readWith({
-      onInput: input => Function_dist_effectFunction.pipe(sink.write(input), sink.flatMap(() => writer)),
-      onFailure: sink.fail,
-      onDone: () => sink.unit
-    }),
-    onSome: effect => sink.unwrap(Effect_dist_effectEffect.match(effect, {
-      onFailure: sink.fail,
-      onSuccess: () => sink.unit
-    }))
-  })), sink.unwrap);
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer)));
-});
-
-/** @internal */
-const identityStream = () => new StreamImpl(sink.identityChannel());
-
-/** @internal */
-const interleave = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, interleaveWith(that, forever(make(true, false)))));
-
-/** @internal */
-const interleaveWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, decider) => {
-  const producer = handoff => sink.readWithCause({
-    onInput: value => sink.flatMap(sink.fromEffect(offer(handoff, take$2.of(value))), () => producer(handoff)),
-    onFailure: cause => sink.fromEffect(offer(handoff, take$2.failCause(cause))),
-    onDone: () => sink.fromEffect(offer(handoff, take$2.end))
-  });
-  return new StreamImpl(sink.unwrapScoped(Function_dist_effectFunction.pipe(make$1(), Effect_dist_effectEffect.zip(make$1()), Effect_dist_effectEffect.tap(([left]) => Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(left)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.tap(([_, right]) => Function_dist_effectFunction.pipe(toChannel(that), sink.concatMap(sink.writeChunk), sink.pipeTo(producer(right)), sink.runScoped, Effect_dist_effectEffect.forkScoped)), Effect_dist_effectEffect.map(([left, right]) => {
-    const process = (leftDone, rightDone) => sink.readWithCause({
-      onInput: bool => {
-        if (bool && !leftDone) {
-          return Function_dist_effectFunction.pipe(sink.fromEffect(take$1(left)), sink.flatMap(take$2.match({
-            onEnd: () => rightDone ? sink.unit : process(true, rightDone),
-            onFailure: sink.failCause,
-            onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => process(leftDone, rightDone)))
-          })));
-        }
-        if (!bool && !rightDone) {
-          return Function_dist_effectFunction.pipe(sink.fromEffect(take$1(right)), sink.flatMap(take$2.match({
-            onEnd: () => leftDone ? sink.unit : process(leftDone, true),
-            onFailure: sink.failCause,
-            onSuccess: chunk => Function_dist_effectFunction.pipe(sink.write(chunk), sink.flatMap(() => process(leftDone, rightDone)))
-          })));
-        }
-        return process(leftDone, rightDone);
-      },
-      onFailure: sink.failCause,
-      onDone: () => sink.unit
-    });
-    return Function_dist_effectFunction.pipe(toChannel(decider), sink.concatMap(sink.writeChunk), sink.pipeTo(process(false, false)));
-  }))));
-});
-
-/** @internal */
-const intersperse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, element) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.suspend(() => {
-  const writer = isFirst => sink.readWithCause({
-    onInput: chunk => {
-      const builder = [];
-      let flagResult = isFirst;
-      for (const output of chunk) {
-        if (flagResult) {
-          flagResult = false;
-          builder.push(output);
-        } else {
-          builder.push(element);
-          builder.push(output);
-        }
-      }
-      return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.unsafeFromArray(builder)), sink.flatMap(() => writer(flagResult)));
-    },
-    onFailure: sink.failCause,
-    onDone: () => sink.unit
-  });
-  return writer(true);
-})))));
-
-/** @internal */
-const intersperseAffixes = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  end,
-  middle,
-  start
-}) => Function_dist_effectFunction.pipe(make(start), concat(Function_dist_effectFunction.pipe(self, intersperse(middle))), concat(make(end))));
-
-/** @internal */
-const interruptAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(self, interruptWhen(Clock_dist_effectClock.sleep(duration))));
-
-/** @internal */
-const interruptWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.interruptWhen(effect))));
-
-/** @internal */
-const interruptWhenDeferred = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, deferred) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.interruptWhenDeferred(deferred))));
-
-/** @internal */
-const iterate = (value, next) => unfold(value, a => Option_dist_effectOption.some([a, next(a)]));
-
-/** @internal */
-const make = (...as) => fromIterable(as);
-
-/** @internal */
-const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapOut(Chunk_dist_effectChunk.map(f)))));
-
-/** @internal */
-const mapAccum = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => {
-  const accumulator = s => sink.readWith({
-    onInput: input => {
-      const [nextS, chunk] = Chunk_dist_effectChunk.mapAccum(input, s, f);
-      return sink.flatMap(sink.write(chunk), () => accumulator(nextS));
-    },
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(accumulator(s))));
-});
-
-/** @internal */
-const mapAccumEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => suspend(() => {
-  const accumulator = s => sink.readWith({
-    onInput: input => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => {
-      const outputs = [];
-      const emit = output => Effect_dist_effectEffect.sync(() => {
-        outputs.push(output);
-      });
-      return Function_dist_effectFunction.pipe(input, Effect_dist_effectEffect.reduce(s, (s, a) => Function_dist_effectFunction.pipe(f(s, a), Effect_dist_effectEffect.flatMap(([s, a]) => Function_dist_effectFunction.pipe(emit(a), Effect_dist_effectEffect.as(s))))), Effect_dist_effectEffect.match({
-        onFailure: error => {
-          if (outputs.length !== 0) {
-            return sink.zipRight(sink.write(Chunk_dist_effectChunk.unsafeFromArray(outputs)), sink.fail(error));
-          }
-          return sink.fail(error);
-        },
-        onSuccess: s => sink.flatMap(sink.write(Chunk_dist_effectChunk.unsafeFromArray(outputs)), () => accumulator(s))
-      }));
-    }), sink.unwrap),
-    onFailure: sink.fail,
-    onDone: () => sink.unit
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(accumulator(s))));
-}));
-
-/** @internal */
-const mapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => Function_dist_effectFunction.pipe(self, mapError(options.onFailure), map(options.onSuccess)));
-
-/** @internal */
-const mapChunks = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapOut(f))));
-
-/** @internal */
-const mapChunksEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapOutEffect(f))));
-
-/** @internal */
-const mapConcat = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapConcatChunk(a => Chunk_dist_effectChunk.fromIterable(f(a)))));
-
-/** @internal */
-const mapConcatChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapChunks(Chunk_dist_effectChunk.flatMap(f))));
-
-/** @internal */
-const mapConcatChunkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapEffectSequential(f), mapConcatChunk(Function_dist_effectFunction.identity)));
-
-/** @internal */
-const mapConcatEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapEffectSequential(a => Function_dist_effectFunction.pipe(f(a), Effect_dist_effectEffect.map(Chunk_dist_effectChunk.fromIterable))), mapConcatChunk(Function_dist_effectFunction.identity)));
-
-/** @internal */
-const mapEffectSequential = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const loop = iterator => {
-    const next = iterator.next();
-    if (next.done) {
-      return sink.readWithCause({
-        onInput: elem => loop(elem[Symbol.iterator]()),
-        onFailure: sink.failCause,
-        onDone: sink.succeed
-      });
-    } else {
-      const value = next.value;
-      return sink.unwrap(Effect_dist_effectEffect.map(f(value), a2 => sink.flatMap(sink.write(Chunk_dist_effectChunk.of(a2)), () => loop(iterator))));
-    }
-  };
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(sink.suspend(() => loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]())))));
-});
-
-/** @internal */
-const mapEffectPar = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, n, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.concatMap(sink.writeChunk), sink.mapOutEffectPar(f, n), sink.mapOut(Chunk_dist_effectChunk.of))));
-
-/** @internal */
-const mapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapError(f))));
-
-/** @internal */
-const mapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.mapErrorCause(f))));
-
-/** @internal */
-const merge = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[1]), (self, that, options) => mergeWith(self, that, {
-  onSelf: Function_dist_effectFunction.identity,
-  onOther: Function_dist_effectFunction.identity,
-  haltStrategy: options?.haltStrategy
-}));
-
-/** @internal */
-const mergeAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Symbol.iterator in args[0], (streams, options) => flatten(fromIterable(streams), options));
-
-/** @internal */
-const mergeEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => mergeWith(self, that, {
-  onSelf: Either_dist_effectEither.left,
-  onOther: Either_dist_effectEither.right
-}));
-
-/** @internal */
-const mergeLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, merge(drain(that))));
-
-/** @internal */
-const mergeRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(drain(self), merge(that)));
-
-/** @internal */
-const mergeWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, options) => {
-  const strategy = options.haltStrategy ? StreamHaltStrategy_dist_effectStreamHaltStrategy.fromInput(options.haltStrategy) : StreamHaltStrategy_dist_effectStreamHaltStrategy.Both;
-  const handler = terminate => exit => terminate || !Exit_dist_effectExit.isSuccess(exit) ?
-  // TODO: remove
-  ChannelMergeDecision_dist_effectChannelMergeDecision.Done(Effect_dist_effectEffect.suspend(() => exit)) : ChannelMergeDecision_dist_effectChannelMergeDecision.Await(exit => Effect_dist_effectEffect.suspend(() => exit));
-  return new StreamImpl(sink.mergeWith(toChannel(map(self, options.onSelf)), {
-    other: toChannel(map(other, options.onOther)),
-    onSelfDone: handler(strategy._tag === "Either" || strategy._tag === "Left"),
-    onOtherDone: handler(strategy._tag === "Either" || strategy._tag === "Right")
-  }));
-});
-
-/** @internal */
-const mkString = self => run(self, sink.mkString);
-
-/** @internal */
-const never = /*#__PURE__*/fromEffect(Effect_dist_effectEffect.never);
-
-/** @internal */
-const onError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cleanup) => Function_dist_effectFunction.pipe(self, catchAllCause(cause => fromEffect(Function_dist_effectFunction.pipe(cleanup(cause), Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.failCause(cause)))))));
-
-/** @internal */
-const onDone = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, cleanup) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.ensuringWith(exit => Exit_dist_effectExit.isSuccess(exit) ? cleanup() : Effect_dist_effectEffect.unit))));
-
-/** @internal */
-const orDie = self => Function_dist_effectFunction.pipe(self, orDieWith(Function_dist_effectFunction.identity));
-
-/** @internal */
-const orDieWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.orDieWith(f))));
-
-/** @internal */
-const orElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.orElse(() => toChannel(that())))));
-
-/** @internal */
-const orElseEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, map(Either_dist_effectEither.left), orElse(() => Function_dist_effectFunction.pipe(that(), map(Either_dist_effectEither.right)))));
-
-/** @internal */
-const orElseFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => Function_dist_effectFunction.pipe(self, orElse(() => failSync(error))));
-
-/** @internal */
-const orElseIfEmpty = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, element) => Function_dist_effectFunction.pipe(self, orElseIfEmptyChunk(() => Chunk_dist_effectChunk.of(element()))));
-
-/** @internal */
-const orElseIfEmptyChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chunk) => Function_dist_effectFunction.pipe(self, orElseIfEmptyStream(() => new StreamImpl(sink.write(chunk())))));
-
-/** @internal */
-const orElseIfEmptyStream = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, stream) => {
-  const writer = sink.readWith({
-    onInput: input => {
-      if (Chunk_dist_effectChunk.isEmpty(input)) {
-        return sink.suspend(() => writer);
-      }
-      return Function_dist_effectFunction.pipe(sink.write(input), sink.zipRight(sink.identityChannel()));
-    },
-    onFailure: sink.fail,
-    onDone: () => sink.suspend(() => toChannel(stream()))
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(writer)));
-});
-
-/** @internal */
-const orElseSucceed = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => Function_dist_effectFunction.pipe(self, orElse(() => sync(value))));
-
-/** @internal */
-const paginate = (s, f) => paginateChunk(s, s => {
-  const page = f(s);
-  return [Chunk_dist_effectChunk.of(page[0]), page[1]];
-});
-
-/** @internal */
-const paginateChunk = (s, f) => {
-  const loop = s => {
-    const page = f(s);
-    return Option_dist_effectOption.match(page[1], {
-      onNone: () => sink.zipRight(sink.write(page[0]), sink.unit),
-      onSome: s => sink.flatMap(sink.write(page[0]), () => loop(s))
-    });
-  };
-  return new StreamImpl(sink.suspend(() => loop(s)));
-};
-
-/** @internal */
-const paginateChunkEffect = (s, f) => {
-  const loop = s => sink.unwrap(Effect_dist_effectEffect.map(f(s), ([chunk, option]) => Option_dist_effectOption.match(option, {
-    onNone: () => sink.zipRight(sink.write(chunk), sink.unit),
-    onSome: s => sink.flatMap(sink.write(chunk), () => loop(s))
-  })));
-  return new StreamImpl(sink.suspend(() => loop(s)));
-};
-
-/** @internal */
-const paginateEffect = (s, f) => paginateChunkEffect(s, s => Function_dist_effectFunction.pipe(f(s), Effect_dist_effectEffect.map(([a, s]) => [Chunk_dist_effectChunk.of(a), s])));
-
-/** @internal */
-const peel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => {
-  const OP_EMIT = "Emit";
-  const OP_HALT = "Halt";
-  const OP_END = "End";
-  return Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred.make(), Effect_dist_effectEffect.flatMap(deferred => Function_dist_effectFunction.pipe(make$1(), Effect_dist_effectEffect.map(handoff => {
-    const consumer = sink.foldSink(sink.collectLeftover(sink$1), {
-      onFailure: error => sink.zipRight$1(sink.fromEffect$1(Deferred_dist_effectDeferred.fail(deferred, error)), sink.fail$1(error)),
-      onSuccess: ([z, leftovers]) => {
-        const loop = sink.readWithCause({
-          onInput: elements => sink.flatMap(sink.fromEffect(offer(handoff, {
-            _tag: OP_EMIT,
-            elements
-          })), () => loop),
-          onFailure: cause => sink.zipRight(sink.fromEffect(offer(handoff, {
-            _tag: OP_HALT,
-            cause
-          })), sink.failCause(cause)),
-          onDone: _ => sink.zipRight(sink.fromEffect(offer(handoff, {
-            _tag: OP_END
-          })), sink.unit)
-        });
-        return sink.fromChannel(Function_dist_effectFunction.pipe(sink.fromEffect(Deferred_dist_effectDeferred.succeed(deferred, z)), sink.zipRight(sink.fromEffect(Function_dist_effectFunction.pipe(handoff, offer({
-          _tag: OP_EMIT,
-          elements: leftovers
-        })))), sink.zipRight(loop)));
-      }
-    });
-    const producer = Function_dist_effectFunction.pipe(take$1(handoff), Effect_dist_effectEffect.map(signal => {
-      switch (signal._tag) {
-        case OP_EMIT:
-          {
-            return Function_dist_effectFunction.pipe(sink.write(signal.elements), sink.flatMap(() => producer));
-          }
-        case OP_HALT:
-          {
-            return sink.failCause(signal.cause);
-          }
-        case OP_END:
-          {
-            return sink.unit;
-          }
-      }
-    }), sink.unwrap);
-    return Function_dist_effectFunction.pipe(self, tapErrorCause(cause => Deferred_dist_effectDeferred.failCause(deferred, cause)), run(consumer), Effect_dist_effectEffect.forkScoped, Effect_dist_effectEffect.zipRight(Deferred_dist_effectDeferred._await(deferred)), Effect_dist_effectEffect.map(z => [z, new StreamImpl(producer)]));
-  }))), Effect_dist_effectEffect.flatten);
-});
-
-/** @internal */
-const partition = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[1] === "function", (self, predicate, options) => partitionEither(self, a => Effect_dist_effectEffect.succeed(predicate(a) ? Either_dist_effectEither.left(a) : Either_dist_effectEither.right(a)), options));
-
-/** @internal */
-const partitionEither = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[1] === "function", (self, predicate, options) => Function_dist_effectFunction.pipe(mapEffectSequential(self, predicate), distributedWith({
-  size: 2,
-  maximumLag: options?.bufferSize ?? 16,
-  decide: Either_dist_effectEither.match({
-    onLeft: () => Effect_dist_effectEffect.succeed(n => n === 0),
-    onRight: () => Effect_dist_effectEffect.succeed(n => n === 1)
-  })
-}), Effect_dist_effectEffect.flatMap(([queue1, queue2]) => Effect_dist_effectEffect.succeed([filterMap(flattenExitOption(fromQueue(queue1, {
-  shutdown: true
-})), _ => Either_dist_effectEither.match(_, {
-  onLeft: Option_dist_effectOption.some,
-  onRight: Option_dist_effectOption.none
-})), filterMap(flattenExitOption(fromQueue(queue2, {
-  shutdown: true
-})), _ => Either_dist_effectEither.match(_, {
-  onLeft: Option_dist_effectOption.none,
-  onRight: Option_dist_effectOption.some
-}))]))));
-
-/** @internal */
-const pipeThrough = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.toChannel(sink$1)))));
-
-/** @internal */
-const pipeThroughChannel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, channel) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(channel))));
-
-/** @internal */
-const pipeThroughChannelOrFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chan) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(chan))));
-
-/** @internal */
-const prepend = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, values) => new StreamImpl(sink.zipRight(sink.write(values), toChannel(self))));
-
-/** @internal */
-const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.provideContext(context))));
-
-/** @internal */
-const provideLayer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, layer) => new StreamImpl(sink.unwrapScoped(Function_dist_effectFunction.pipe(Layer_dist_effectLayer.build(layer), Effect_dist_effectEffect.map(env => Function_dist_effectFunction.pipe(toChannel(self), sink.provideContext(env)))))));
-
-/** @internal */
-const provideService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, resource) => provideServiceEffect(self, tag, Effect_dist_effectEffect.succeed(resource)));
-
-/** @internal */
-const provideServiceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, effect) => provideServiceStream(self, tag, fromEffect(effect)));
-
-/** @internal */
-const provideServiceStream = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, stream) => contextWithStream(env => flatMap(stream, service => Function_dist_effectFunction.pipe(self, provideContext(Context_dist_effectContext.add(env, tag, service))))));
-
-/** @internal */
-const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => contextWithStream(env => Function_dist_effectFunction.pipe(self, provideContext(f(env)))));
-
-/** @internal */
-const provideSomeLayer = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, layer) =>
-// @ts-expect-error
-Function_dist_effectFunction.pipe(self, provideLayer(Function_dist_effectFunction.pipe(Layer_dist_effectLayer.context(), Layer_dist_effectLayer.merge(layer)))));
-
-/** @internal */
-const range = (min, max, chunkSize = DefaultChunkSize) => suspend(() => {
-  if (min > max) {
-    return empty;
-  }
-  const go = (min, max, chunkSize) => {
-    const remaining = max - min + 1;
-    if (remaining > chunkSize) {
-      return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.range(min, min + chunkSize - 1)), sink.flatMap(() => go(min + chunkSize, max, chunkSize)));
-    }
-    return sink.write(Chunk_dist_effectChunk.range(min, min + remaining - 1));
-  };
-  return new StreamImpl(go(min, max, chunkSize));
-});
-
-/** @internal */
-const rechunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => suspend(() => {
-  const target = Math.max(n, 1);
-  const process = rechunkProcess(new StreamRechunker(target), target);
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(process)));
-}));
-
-/** @internal */
-const rechunkProcess = (rechunker, target) => sink.readWithCause({
-  onInput: chunk => {
-    if (chunk.length === target && rechunker.isEmpty()) {
-      return sink.flatMap(sink.write(chunk), () => rechunkProcess(rechunker, target));
-    }
-    if (chunk.length > 0) {
-      const chunks = [];
-      let result = undefined;
-      let index = 0;
-      while (index < chunk.length) {
-        while (index < chunk.length && result === undefined) {
-          result = rechunker.write(Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.unsafeGet(index)));
-          index = index + 1;
-        }
-        if (result !== undefined) {
-          chunks.push(result);
-          result = undefined;
-        }
-      }
-      return sink.flatMap(sink.writeAll(...chunks), () => rechunkProcess(rechunker, target));
-    }
-    return sink.suspend(() => rechunkProcess(rechunker, target));
-  },
-  onFailure: cause => sink.zipRight(rechunker.emitIfNotEmpty(), sink.failCause(cause)),
-  onDone: () => rechunker.emitIfNotEmpty()
-});
-
-/** @internal */
-class StreamRechunker {
-  builder = [];
-  pos = 0;
-  constructor(n) {
-    this.n = n;
-  }
-  isEmpty() {
-    return this.pos === 0;
-  }
-  write(elem) {
-    this.builder.push(elem);
-    this.pos += 1;
-    if (this.pos === this.n) {
-      const result = Chunk_dist_effectChunk.unsafeFromArray(this.builder);
-      this.builder = [];
-      this.pos = 0;
-      return result;
-    }
-    return undefined;
-  }
-  emitIfNotEmpty() {
-    if (this.pos !== 0) {
-      return sink.write(Chunk_dist_effectChunk.unsafeFromArray(this.builder));
-    }
-    return sink.unit;
-  }
-}
-
-/** @internal */
-const refineOrDie = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(self, refineOrDieWith(pf, Function_dist_effectFunction.identity)));
-
-/** @internal */
-const refineOrDieWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, pf, f) => new StreamImpl(sink.catchAll(toChannel(self), error => Option_dist_effectOption.match(pf(error), {
-  onNone: () => sink.failCause(Cause_dist_effectCause.die(f(error))),
-  onSome: sink.fail
-}))));
-
-/** @internal */
-const repeat = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => filterMap(repeatEither(self, schedule), _ => Either_dist_effectEither.match(_, {
-  onLeft: Option_dist_effectOption.none,
-  onRight: Option_dist_effectOption.some
-})));
-
-/** @internal */
-const repeatEffect = effect => repeatEffectOption(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some)));
-
-/** @internal */
-const repeatEffectChunk = effect => repeatEffectChunkOption(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some)));
-
-/** @internal */
-const repeatEffectChunkOption = effect => unfoldChunkEffect(effect, effect => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.map(effect, chunk => Option_dist_effectOption.some([chunk, effect])), Effect_dist_effectEffect.catchAll(Option_dist_effectOption.match({
-  onNone: () => Effect_dist_effectEffect.succeed(Option_dist_effectOption.none()),
-  onSome: Effect_dist_effectEffect.fail
-}))));
-
-/** @internal */
-const repeatEffectOption = effect => repeatEffectChunkOption(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(Chunk_dist_effectChunk.of)));
-
-/** @internal */
-const repeatEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatWith(self, schedule, {
-  onElement: a => Either_dist_effectEither.right(a),
-  onSchedule: Either_dist_effectEither.left
-}));
-
-/** @internal */
-const repeatElements = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => filterMap(repeatElementsWith(self, schedule, {
-  onElement: a => Option_dist_effectOption.some(a),
-  onSchedule: Option_dist_effectOption.none
-}), Function_dist_effectFunction.identity));
-
-/** @internal */
-const repeatElementsWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, options) => {
-  const driver = Function_dist_effectFunction.pipe(Schedule_dist_effectSchedule.driver(schedule), Effect_dist_effectEffect.map(driver => {
-    const feed = input => Option_dist_effectOption.match(Chunk_dist_effectChunk.head(input), {
-      onNone: () => loop,
-      onSome: a => sink.zipRight(sink.write(Chunk_dist_effectChunk.of(options.onElement(a))), step(Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(1)), a))
-    });
-    const step = (input, a) => {
-      const advance = Function_dist_effectFunction.pipe(driver.next(a), Effect_dist_effectEffect.as(Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(options.onElement(a))), sink.flatMap(() => step(input, a)))));
-      const reset = Function_dist_effectFunction.pipe(driver.last(), Effect_dist_effectEffect.orDie, Effect_dist_effectEffect.flatMap(b => Function_dist_effectFunction.pipe(driver.reset(), Effect_dist_effectEffect.map(() => Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(options.onSchedule(b))), sink.zipRight(feed(input)))))));
-      return Function_dist_effectFunction.pipe(advance, Effect_dist_effectEffect.orElse(() => reset), sink.unwrap);
-    };
-    const loop = sink.readWith({
-      onInput: feed,
-      onFailure: sink.fail,
-      onDone: () => sink.unit
-    });
-    return loop;
-  }), sink.unwrap);
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(driver)));
-});
-
-/** @internal */
-const repeatValue = value => new StreamImpl(sink.repeated(sink.write(Chunk_dist_effectChunk.of(value))));
-
-/** @internal */
-const repeatWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, options) => {
-  return Function_dist_effectFunction.pipe(Schedule_dist_effectSchedule.driver(schedule), Effect_dist_effectEffect.map(driver => {
-    const scheduleOutput = Function_dist_effectFunction.pipe(driver.last(), Effect_dist_effectEffect.orDie, Effect_dist_effectEffect.map(options.onSchedule));
-    const process = Function_dist_effectFunction.pipe(self, map(options.onElement), toChannel);
-    const loop = sink.unwrap(Effect_dist_effectEffect.match(driver.next(void 0), {
-      onFailure: () => sink.unit,
-      onSuccess: () => Function_dist_effectFunction.pipe(process, sink.zipRight(Function_dist_effectFunction.pipe(scheduleOutput, Effect_dist_effectEffect.map(c => Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(c)), sink.flatMap(() => loop))), sink.unwrap)))
-    }));
-    return new StreamImpl(Function_dist_effectFunction.pipe(process, sink.zipRight(loop)));
-  }), unwrap);
-});
-
-/** @internal */
-const repeatWithSchedule = (value, schedule) => repeatEffectWithSchedule(Effect_dist_effectEffect.succeed(value), schedule);
-
-/** @internal */
-const repeatEffectWithSchedule = (effect, schedule) => flatMap(fromEffect(Effect_dist_effectEffect.zip(effect, Schedule_dist_effectSchedule.driver(schedule))), ([a, driver]) => concat(succeed(a), unfoldEffect(a, s => Effect_dist_effectEffect.matchEffect(driver.next(s), {
-  onFailure: Effect_dist_effectEffect.succeed,
-  onSuccess: () => Effect_dist_effectEffect.map(effect, nextA => Option_dist_effectOption.some([nextA, nextA]))
-}))));
-
-/** @internal */
-const retry = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => unwrap(Effect_dist_effectEffect.map(Schedule_dist_effectSchedule.driver(schedule), driver => {
-  const loop = catchAll(self, error => unwrap(Effect_dist_effectEffect.matchEffect(driver.next(error), {
-    onFailure: () => Effect_dist_effectEffect.fail(error),
-    onSuccess: () => Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(loop, tap(() => driver.reset())))
-  })));
-  return loop;
-})));
-
-/** @internal */
-const run = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.toChannel(sink$1)), sink.runDrain));
-
-/** @internal */
-const runCollect = self => Function_dist_effectFunction.pipe(self, run(sink.collectAll()));
-
-/** @internal */
-const runCount = self => Function_dist_effectFunction.pipe(self, run(sink.count));
-
-/** @internal */
-const runDrain = self => Function_dist_effectFunction.pipe(self, run(sink.drain$1));
-
-/** @internal */
-const runFold = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScoped(s, Function_dist_effectFunction.constTrue, f), Effect_dist_effectEffect.scoped));
-
-/** @internal */
-const runFoldEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScopedEffect(s, Function_dist_effectFunction.constTrue, f), Effect_dist_effectEffect.scoped));
-
-/** @internal */
-const runFoldScoped = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScoped(s, Function_dist_effectFunction.constTrue, f)));
-
-/** @internal */
-const runFoldScopedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScopedEffect(s, Function_dist_effectFunction.constTrue, f)));
-
-/** @internal */
-const runFoldWhile = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScoped(s, cont, f), Effect_dist_effectEffect.scoped));
-
-/** @internal */
-const runFoldWhileEffect = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runFoldWhileScopedEffect(s, cont, f), Effect_dist_effectEffect.scoped));
-
-/** @internal */
-const runFoldWhileScoped = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.fold(s, cont, f))));
-
-/** @internal */
-const runFoldWhileScopedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(4, (self, s, cont, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.foldEffect(s, cont, f))));
-
-/** @internal */
-const runForEach = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, run(sink.forEach(f))));
-
-/** @internal */
-const runForEachChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, run(sink.forEachChunk(f))));
-
-/** @internal */
-const runForEachChunkScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.forEachChunk(f))));
-
-/** @internal */
-const runForEachScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.forEach(f))));
-
-/** @internal */
-const runForEachWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, run(sink.forEachWhile(f))));
-
-/** @internal */
-const runForEachWhileScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, runScoped(sink.forEachWhile(f))));
-
-/** @internal */
-const runHead = self => Function_dist_effectFunction.pipe(self, run(sink.head()));
-
-/** @internal */
-const runIntoHub = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, hub) => Function_dist_effectFunction.pipe(self, runIntoQueue(hub)));
-
-/** @internal */
-const runIntoHubScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, hub) => Function_dist_effectFunction.pipe(self, runIntoQueueScoped(hub)));
-
-/** @internal */
-const runIntoQueue = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, queue) => Function_dist_effectFunction.pipe(self, runIntoQueueScoped(queue), Effect_dist_effectEffect.scoped));
-
-/** @internal */
-const runIntoQueueElementsScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, queue) => {
-  const writer = sink.readWithCause({
-    onInput: input => sink.flatMap(sink.fromEffect(Queue_dist_effectQueue.offerAll(queue, Chunk_dist_effectChunk.map(input, Exit_dist_effectExit.succeed))), () => writer),
-    onFailure: cause => sink.fromEffect(Queue_dist_effectQueue.offer(queue, Exit_dist_effectExit.failCause(Cause_dist_effectCause.map(cause, Option_dist_effectOption.some)))),
-    onDone: () => sink.fromEffect(Queue_dist_effectQueue.offer(queue, Exit_dist_effectExit.fail(Option_dist_effectOption.none())))
-  });
-  return Function_dist_effectFunction.pipe(sink.pipeTo(toChannel(self), writer), sink.drain, sink.runScoped, Effect_dist_effectEffect.asUnit);
-});
-
-/** @internal */
-const runIntoQueueScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, queue) => {
-  const writer = sink.readWithCause({
-    onInput: input => sink.flatMap(sink.write(take$2.chunk(input)), () => writer),
-    onFailure: cause => sink.write(take$2.failCause(cause)),
-    onDone: () => sink.write(take$2.end)
-  });
-  return Function_dist_effectFunction.pipe(sink.pipeTo(toChannel(self), writer), sink.mapOutEffect(take => Queue_dist_effectQueue.offer(queue, take)), sink.drain, sink.runScoped, Effect_dist_effectEffect.asUnit);
-});
-
-/** @internal */
-const runLast = self => Function_dist_effectFunction.pipe(self, run(sink.last()));
-
-/** @internal */
-const runScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(sink.toChannel(sink$1)), sink.drain, sink.runScoped));
-
-/** @internal */
-const runSum = self => Function_dist_effectFunction.pipe(self, run(sink.sum));
-
-/** @internal */
-const scan = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => Function_dist_effectFunction.pipe(self, scanEffect(s, (s, a) => Effect_dist_effectEffect.succeed(f(s, a)))));
-
-/** @internal */
-const scanReduce = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, scanReduceEffect((a2, a) => Effect_dist_effectEffect.succeed(f(a2, a)))));
-
-/** @internal */
-const scanReduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => Function_dist_effectFunction.pipe(self, mapAccumEffect(Option_dist_effectOption.none(), (option, a) => {
-  switch (option._tag) {
-    case "None":
-      {
-        return Effect_dist_effectEffect.succeed([Option_dist_effectOption.some(a), a]);
-      }
-    case "Some":
-      {
-        return Function_dist_effectFunction.pipe(f(option.value, a), Effect_dist_effectEffect.map(b => [Option_dist_effectOption.some(b), b]));
-      }
-  }
-})));
-
-/** @internal */
-const schedule = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => filterMap(scheduleWith(self, schedule, {
-  onElement: Option_dist_effectOption.some,
-  onSchedule: Option_dist_effectOption.none
-}), Function_dist_effectFunction.identity));
-
-/** @internal */
-const scheduleWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, options) => {
-  const loop = (driver, iterator) => {
-    const next = iterator.next();
-    if (next.done) {
-      return sink.readWithCause({
-        onInput: chunk => loop(driver, chunk[Symbol.iterator]()),
-        onFailure: sink.failCause,
-        onDone: sink.succeedNow
-      });
-    }
-    return sink.unwrap(Effect_dist_effectEffect.matchEffect(driver.next(next.value), {
-      onFailure: () => Function_dist_effectFunction.pipe(driver.last(), Effect_dist_effectEffect.orDie, Effect_dist_effectEffect.map(b => Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.make(options.onElement(next.value), options.onSchedule(b))), sink.flatMap(() => loop(driver, iterator)))), Effect_dist_effectEffect.zipLeft(driver.reset())),
-      onSuccess: () => Effect_dist_effectEffect.succeed(Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(options.onElement(next.value))), sink.flatMap(() => loop(driver, iterator))))
-    }));
-  };
-  return new StreamImpl(Function_dist_effectFunction.pipe(sink.fromEffect(Schedule_dist_effectSchedule.driver(schedule)), sink.flatMap(driver => Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(driver, Chunk_dist_effectChunk.empty()[Symbol.iterator]()))))));
-});
-
-/** @internal */
-const scanEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, s, f) => new StreamImpl(Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(s)), sink.flatMap(() => toChannel(Function_dist_effectFunction.pipe(self, mapAccumEffect(s, (s, a) => Function_dist_effectFunction.pipe(f(s, a), Effect_dist_effectEffect.map(s => [s, s])))))))));
-
-/** @internal */
-const scoped = effect => new StreamImpl(sink.ensuring(sink.scoped(Function_dist_effectFunction.pipe(effect, Effect_dist_effectEffect.map(Chunk_dist_effectChunk.of))), Effect_dist_effectEffect.unit));
-
-/** @internal */
-const some = self => Function_dist_effectFunction.pipe(self, mapError(Option_dist_effectOption.some), someOrFail(() => Option_dist_effectOption.none()));
-
-/** @internal */
-const someOrElse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, fallback) => Function_dist_effectFunction.pipe(self, map(Option_dist_effectOption.getOrElse(fallback))));
-
-/** @internal */
-const someOrFail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => mapEffectSequential(self, Option_dist_effectOption.match({
-  onNone: () => Effect_dist_effectEffect.failSync(error),
-  onSome: Effect_dist_effectEffect.succeed
-})));
-
-/** @internal */
-const sliding = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, chunkSize) => slidingSize(self, chunkSize, 1));
-
-/** @internal */
-const slidingSize = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, chunkSize, stepSize) => {
-  if (chunkSize <= 0 || stepSize <= 0) {
-    return die(Cause_dist_effectCause.IllegalArgumentException("Invalid bounds - `chunkSize` and `stepSize` must be greater than zero"));
-  }
-  return new StreamImpl(sink.suspend(() => {
-    const queue = new RingBuffer(chunkSize);
-    const emitOnStreamEnd = (queueSize, channelEnd) => {
-      if (queueSize < chunkSize) {
-        const items = queue.toChunk();
-        const result = Chunk_dist_effectChunk.isEmpty(items) ? Chunk_dist_effectChunk.empty() : Chunk_dist_effectChunk.of(items);
-        return Function_dist_effectFunction.pipe(sink.write(result), sink.flatMap(() => channelEnd));
-      }
-      const lastEmitIndex = queueSize - (queueSize - chunkSize) % stepSize;
-      if (lastEmitIndex === queueSize) {
-        return channelEnd;
-      }
-      const leftovers = queueSize - (lastEmitIndex - chunkSize + stepSize);
-      const lastItems = Function_dist_effectFunction.pipe(queue.toChunk(), Chunk_dist_effectChunk.takeRight(leftovers));
-      const result = Chunk_dist_effectChunk.isEmpty(lastItems) ? Chunk_dist_effectChunk.empty() : Chunk_dist_effectChunk.of(lastItems);
-      return Function_dist_effectFunction.pipe(sink.write(result), sink.flatMap(() => channelEnd));
-    };
-    const reader = queueSize => sink.readWithCause({
-      onInput: input => sink.flatMap(sink.write(Chunk_dist_effectChunk.filterMap(input, (element, index) => {
-        queue.put(element);
-        const currentIndex = queueSize + index + 1;
-        if (currentIndex < chunkSize || (currentIndex - chunkSize) % stepSize > 0) {
-          return Option_dist_effectOption.none();
-        }
-        return Option_dist_effectOption.some(queue.toChunk());
-      })), () => reader(queueSize + input.length)),
-      onFailure: cause => emitOnStreamEnd(queueSize, sink.failCause(cause)),
-      onDone: () => emitOnStreamEnd(queueSize, sink.unit)
-    });
-    return Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(reader(0)));
-  }));
-});
-
-/** @internal */
-const split = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const split = (leftovers, input) => {
-    const [chunk, remaining] = Function_dist_effectFunction.pipe(leftovers, Chunk_dist_effectChunk.appendAll(input), Chunk_dist_effectChunk.splitWhere(predicate));
-    if (Chunk_dist_effectChunk.isEmpty(chunk) || Chunk_dist_effectChunk.isEmpty(remaining)) {
-      return loop(Function_dist_effectFunction.pipe(chunk, Chunk_dist_effectChunk.appendAll(Function_dist_effectFunction.pipe(remaining, Chunk_dist_effectChunk.drop(1)))));
-    }
-    return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(chunk)), sink.flatMap(() => split(Chunk_dist_effectChunk.empty(), Function_dist_effectFunction.pipe(remaining, Chunk_dist_effectChunk.drop(1)))));
-  };
-  const loop = leftovers => sink.readWith({
-    onInput: input => split(leftovers, input),
-    onFailure: sink.fail,
-    onDone: () => {
-      if (Chunk_dist_effectChunk.isEmpty(leftovers)) {
-        return sink.unit;
-      }
-      if (Option_dist_effectOption.isNone(Function_dist_effectFunction.pipe(leftovers, Chunk_dist_effectChunk.findFirst(predicate)))) {
-        return sink.zipRight(sink.write(Chunk_dist_effectChunk.of(leftovers)), sink.unit);
-      }
-      return sink.zipRight(split(Chunk_dist_effectChunk.empty(), leftovers), sink.unit);
-    }
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()))));
-});
-
-/** @internal */
-const splitOnChunk = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, delimiter) => {
-  const next = (leftover, delimiterIndex) => sink.readWithCause({
-    onInput: inputChunk => {
-      let buffer;
-      const [carry, delimiterCursor] = Function_dist_effectFunction.pipe(inputChunk, Chunk_dist_effectChunk.reduce([Function_dist_effectFunction.pipe(leftover, Option_dist_effectOption.getOrElse(() => Chunk_dist_effectChunk.empty())), delimiterIndex], ([carry, delimiterCursor], a) => {
-        const concatenated = Function_dist_effectFunction.pipe(carry, Chunk_dist_effectChunk.append(a));
-        if (delimiterCursor < delimiter.length && Equal_dist_effectEqual.equals(a, Function_dist_effectFunction.pipe(delimiter, Chunk_dist_effectChunk.unsafeGet(delimiterCursor)))) {
-          if (delimiterCursor + 1 === delimiter.length) {
-            if (buffer === undefined) {
-              buffer = [];
-            }
-            buffer.push(Function_dist_effectFunction.pipe(concatenated, Chunk_dist_effectChunk.take(concatenated.length - delimiter.length)));
-            return [Chunk_dist_effectChunk.empty(), 0];
-          }
-          return [concatenated, delimiterCursor + 1];
-        }
-        return [concatenated, Equal_dist_effectEqual.equals(a, Function_dist_effectFunction.pipe(delimiter, Chunk_dist_effectChunk.unsafeGet(0))) ? 1 : 0];
-      }));
-      const output = buffer === undefined ? Chunk_dist_effectChunk.empty() : Chunk_dist_effectChunk.unsafeFromArray(buffer);
-      return sink.flatMap(sink.write(output), () => next(Chunk_dist_effectChunk.isNonEmpty(carry) ? Option_dist_effectOption.some(carry) : Option_dist_effectOption.none(), delimiterCursor));
-    },
-    onFailure: cause => Option_dist_effectOption.match(leftover, {
-      onNone: () => sink.failCause(cause),
-      onSome: chunk => sink.zipRight(sink.write(Chunk_dist_effectChunk.of(chunk)), sink.failCause(cause))
-    }),
-    onDone: done => Option_dist_effectOption.match(leftover, {
-      onNone: () => sink.succeed(done),
-      onSome: chunk => sink.zipRight(sink.write(Chunk_dist_effectChunk.of(chunk)), sink.succeed(done))
-    })
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(next(Option_dist_effectOption.none(), 0))));
-});
-
-/** @internal */
-const splitLines = self => suspend(() => {
-  let stringBuilder = "";
-  let midCRLF = false;
-  const splitLinesChunk = chunk => {
-    const chunkBuilder = [];
-    Chunk_dist_effectChunk.map(chunk, str => {
-      if (str.length !== 0) {
-        let from = 0;
-        let indexOfCR = str.indexOf("\r");
-        let indexOfLF = str.indexOf("\n");
-        if (midCRLF) {
-          if (indexOfLF === 0) {
-            chunkBuilder.push(stringBuilder);
-            stringBuilder = "";
-            from = 1;
-            indexOfLF = str.indexOf("\n", from);
-          } else {
-            stringBuilder = stringBuilder + "\r";
-          }
-          midCRLF = false;
-        }
-        while (indexOfCR !== -1 || indexOfLF !== -1) {
-          if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {
-            if (stringBuilder.length === 0) {
-              chunkBuilder.push(str.substring(from, indexOfLF));
-            } else {
-              chunkBuilder.push(stringBuilder + str.substring(from, indexOfLF));
-              stringBuilder = "";
-            }
-            from = indexOfLF + 1;
-            indexOfLF = str.indexOf("\n", from);
-          } else {
-            if (str.length === indexOfCR + 1) {
-              midCRLF = true;
-              indexOfCR = -1;
-            } else {
-              if (indexOfLF === indexOfCR + 1) {
-                if (stringBuilder.length === 0) {
-                  chunkBuilder.push(str.substring(from, indexOfCR));
-                } else {
-                  stringBuilder = stringBuilder + str.substring(from, indexOfCR);
-                  chunkBuilder.push(stringBuilder);
-                  stringBuilder = "";
-                }
-                from = indexOfCR + 2;
-                indexOfCR = str.indexOf("\r", from);
-                indexOfLF = str.indexOf("\n", from);
-              } else {
-                indexOfCR = str.indexOf("\r", indexOfCR + 1);
-              }
-            }
-          }
-        }
-        if (midCRLF) {
-          stringBuilder = stringBuilder + str.substring(from, str.length - 1);
-        } else {
-          stringBuilder = stringBuilder + str.substring(from, str.length);
-        }
-      }
-    });
-    return Chunk_dist_effectChunk.unsafeFromArray(chunkBuilder);
-  };
-  const loop = sink.readWithCause({
-    onInput: input => {
-      const out = splitLinesChunk(input);
-      return Chunk_dist_effectChunk.isEmpty(out) ? loop : sink.flatMap(sink.write(out), () => loop);
-    },
-    onFailure: cause => stringBuilder.length === 0 ? sink.failCause(cause) : sink.flatMap(sink.write(Chunk_dist_effectChunk.of(stringBuilder)), () => sink.failCause(cause)),
-    onDone: done => stringBuilder.length === 0 ? sink.succeed(done) : sink.flatMap(sink.write(Chunk_dist_effectChunk.of(stringBuilder)), () => sink.succeed(done))
-  });
-  return new StreamImpl(sink.pipeTo(toChannel(self), loop));
-});
-
-/** @internal */
-const succeed = value => fromChunk(Chunk_dist_effectChunk.of(value));
-
-/** @internal */
-const sync = evaluate => suspend(() => fromChunk(Chunk_dist_effectChunk.of(evaluate())));
-
-/** @internal */
-const suspend = stream => new StreamImpl(sink.suspend(() => toChannel(stream())));
-
-/** @internal */
-const take = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  if (!Number.isInteger(n)) {
-    return die(Cause_dist_effectCause.IllegalArgumentException(`${n} must be an integer`));
-  }
-  const loop = n => sink.readWith({
-    onInput: input => {
-      const taken = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.take(Math.min(n, Number.POSITIVE_INFINITY)));
-      const leftover = Math.max(0, n - taken.length);
-      const more = leftover > 0;
-      if (more) {
-        return Function_dist_effectFunction.pipe(sink.write(taken), sink.flatMap(() => loop(leftover)));
-      }
-      return sink.write(taken);
-    },
-    onFailure: sink.fail,
-    onDone: sink.succeed
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(0 < n ? loop(n) : sink.unit)));
-});
-
-/** @internal */
-const takeRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => {
-  if (n <= 0) {
-    return empty;
-  }
-  return new StreamImpl(Function_dist_effectFunction.pipe(Effect_dist_effectEffect.succeed(new RingBuffer(n)), Effect_dist_effectEffect.map(queue => {
-    const reader = sink.readWith({
-      onInput: input => {
-        for (const element of input) {
-          queue.put(element);
-        }
-        return reader;
-      },
-      onFailure: sink.fail,
-      onDone: () => Function_dist_effectFunction.pipe(sink.write(queue.toChunk()), sink.zipRight(sink.unit))
-    });
-    return Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(reader));
-  }), sink.unwrap));
-});
-
-/** @internal */
-const takeUntil = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => {
-      const taken = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.takeWhile(a => !predicate(a)));
-      const last = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.drop(taken.length), Chunk_dist_effectChunk.take(1));
-      if (Chunk_dist_effectChunk.isEmpty(last)) {
-        return Function_dist_effectFunction.pipe(sink.write(taken), sink.flatMap(() => loop));
-      }
-      return sink.write(Function_dist_effectFunction.pipe(taken, Chunk_dist_effectChunk.appendAll(last)));
-    },
-    onFailure: sink.fail,
-    onDone: sink.succeed
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
-});
-
-/** @internal */
-const takeUntilEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = iterator => {
-    const next = iterator.next();
-    if (next.done) {
-      return sink.readWithCause({
-        onInput: elem => loop(elem[Symbol.iterator]()),
-        onFailure: sink.failCause,
-        onDone: sink.succeed
-      });
-    }
-    return Function_dist_effectFunction.pipe(predicate(next.value), Effect_dist_effectEffect.map(bool => bool ? sink.write(Chunk_dist_effectChunk.of(next.value)) : Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(next.value)), sink.flatMap(() => loop(iterator)))), sink.unwrap);
-  };
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop(Chunk_dist_effectChunk.empty()[Symbol.iterator]()))));
-});
-
-/** @internal */
-const takeWhile = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => {
-  const loop = sink.readWith({
-    onInput: input => {
-      const taken = Function_dist_effectFunction.pipe(input, Chunk_dist_effectChunk.takeWhile(predicate));
-      const more = taken.length === input.length;
-      if (more) {
-        return Function_dist_effectFunction.pipe(sink.write(taken), sink.flatMap(() => loop));
-      }
-      return sink.write(taken);
-    },
-    onFailure: sink.fail,
-    onDone: sink.succeed
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(loop)));
-});
-
-/** @internal */
-const tap = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapEffectSequential(self, a => Effect_dist_effectEffect.as(f(a), a)));
-
-/** @internal */
-const tapBoth = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
-  onFailure,
-  onSuccess
-}) => Function_dist_effectFunction.pipe(self, tapError(onFailure), tap(onSuccess)));
-
-/** @internal */
-const tapError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => catchAll(self, error => fromEffect(Effect_dist_effectEffect.zipRight(f(error), Effect_dist_effectEffect.fail(error)))));
-
-/** @internal */
-const tapErrorCause = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => {
-  const loop = sink.readWithCause({
-    onInput: chunk => sink.flatMap(sink.write(chunk), () => loop),
-    onFailure: cause => sink.fromEffect(Effect_dist_effectEffect.zipRight(f(cause), Effect_dist_effectEffect.failCause(cause))),
-    onDone: sink.succeedNow
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(loop)));
-});
-
-/** @internal */
-const tapSink = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => Function_dist_effectFunction.pipe(fromEffect(Effect_dist_effectEffect.all([Queue_dist_effectQueue.bounded(1), Deferred_dist_effectDeferred.make()])), flatMap(([queue, deferred]) => {
-  const right = flattenTake(fromQueue(queue, {
-    maxChunkSize: 1
-  }));
-  const loop = sink.readWithCause({
-    onInput: chunk => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.offer(queue, take$2.chunk(chunk))), sink.foldCauseChannel({
-      onFailure: () => sink.flatMap(sink.write(chunk), () => sink.identityChannel()),
-      onSuccess: () => sink.flatMap(sink.write(chunk), () => loop)
-    })),
-    onFailure: cause => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.offer(queue, take$2.failCause(cause))), sink.foldCauseChannel({
-      onFailure: () => sink.failCause(cause),
-      onSuccess: () => sink.failCause(cause)
-    })),
-    onDone: () => Function_dist_effectFunction.pipe(sink.fromEffect(Queue_dist_effectQueue.offer(queue, take$2.end)), sink.foldCauseChannel({
-      onFailure: () => sink.unit,
-      onSuccess: () => sink.unit
-    }))
-  });
-  return Function_dist_effectFunction.pipe(new StreamImpl(Function_dist_effectFunction.pipe(sink.pipeTo(toChannel(self), loop), sink.ensuring(Effect_dist_effectEffect.zipRight(Effect_dist_effectEffect.forkDaemon(Queue_dist_effectQueue.offer(queue, take$2.end)), Deferred_dist_effectDeferred._await(deferred))))), merge(execute(Function_dist_effectFunction.pipe(run(right, sink$1), Effect_dist_effectEffect.ensuring(Effect_dist_effectEffect.zipRight(Queue_dist_effectQueue.shutdown(queue), Deferred_dist_effectDeferred.succeed(deferred, void 0)))))));
-})));
-
-/** @internal */
-const throttle = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => throttleEffect(self, {
-  ...options,
-  cost: chunk => Effect_dist_effectEffect.succeed(options.cost(chunk))
-}));
-
-/** @internal */
-const throttleEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  if (options.strategy === "enforce") {
-    return throttleEnforceEffect(self, options.cost, options.units, options.duration, options.burst ?? 0);
-  }
-  return throttleShapeEffect(self, options.cost, options.units, options.duration, options.burst ?? 0);
-});
-const throttleEnforceEffect = (self, cost, units, duration, burst) => {
-  const loop = (tokens, timestampMillis) => sink.readWithCause({
-    onInput: input => Function_dist_effectFunction.pipe(cost(input), Effect_dist_effectEffect.zip(Clock_dist_effectClock.currentTimeMillis), Effect_dist_effectEffect.map(([weight, currentTimeMillis]) => {
-      const elapsed = currentTimeMillis - timestampMillis;
-      const cycles = elapsed / Duration_dist_effectDuration.toMillis(duration);
-      const sum = tokens + cycles * units;
-      const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
-      const available = sum < 0 ? max : Math.min(sum, max);
-      if (weight <= available) {
-        return Function_dist_effectFunction.pipe(sink.write(input), sink.flatMap(() => loop(available - weight, currentTimeMillis)));
-      }
-      return loop(tokens, timestampMillis);
-    }), sink.unwrap),
-    onFailure: sink.failCause,
-    onDone: () => sink.unit
-  });
-  const throttled = Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, Effect_dist_effectEffect.map(currentTimeMillis => loop(units, currentTimeMillis)), sink.unwrap);
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(throttled)));
-};
-const throttleShapeEffect = (self, costFn, units, duration, burst) => {
-  const loop = (tokens, timestampMillis) => sink.readWithCause({
-    onInput: input => Function_dist_effectFunction.pipe(costFn(input), Effect_dist_effectEffect.zip(Clock_dist_effectClock.currentTimeMillis), Effect_dist_effectEffect.map(([weight, currentTimeMillis]) => {
-      const elapsed = currentTimeMillis - timestampMillis;
-      const cycles = elapsed / Duration_dist_effectDuration.toMillis(duration);
-      const sum = tokens + cycles * units;
-      const max = units + burst < 0 ? Number.POSITIVE_INFINITY : units + burst;
-      const available = sum < 0 ? max : Math.min(sum, max);
-      const remaining = available - weight;
-      const waitCycles = remaining >= 0 ? 0 : -remaining / units;
-      const delay = Duration_dist_effectDuration.millis(Math.max(0, waitCycles * Duration_dist_effectDuration.toMillis(duration)));
-      if (Duration_dist_effectDuration.greaterThan(delay, Duration_dist_effectDuration.zero)) {
-        return Function_dist_effectFunction.pipe(sink.fromEffect(Clock_dist_effectClock.sleep(delay)), sink.zipRight(sink.write(input)), sink.flatMap(() => loop(remaining, currentTimeMillis)));
-      }
-      return sink.flatMap(sink.write(input), () => loop(remaining, currentTimeMillis));
-    }), sink.unwrap),
-    onFailure: sink.failCause,
-    onDone: () => sink.unit
-  });
-  const throttled = Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, Effect_dist_effectEffect.map(currentTimeMillis => loop(units, currentTimeMillis)), sink.unwrap);
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(throttled)));
-};
-
-/** @internal */
-const tick = interval => repeatWithSchedule(void 0, Schedule_dist_effectSchedule.spaced(interval));
-
-/** @internal */
-const timeout = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, duration) => Function_dist_effectFunction.pipe(toPull(self), Effect_dist_effectEffect.map(Effect_dist_effectEffect.timeoutFail({
-  onTimeout: () => Option_dist_effectOption.none(),
-  duration
-})), fromPull));
-
-/** @internal */
-const timeoutFail = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, error, duration) => Function_dist_effectFunction.pipe(self, timeoutTo(duration, failSync(error))));
-
-/** @internal */
-const timeoutFailCause = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, cause, duration) => Function_dist_effectFunction.pipe(toPull(self), Effect_dist_effectEffect.map(Effect_dist_effectEffect.timeoutFailCause({
-  onTimeout: () => Cause_dist_effectCause.map(cause(), Option_dist_effectOption.some),
-  duration
-})), fromPull));
-
-/** @internal */
-const timeoutTo = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, duration, that) => {
-  const StreamTimeout = Cause_dist_effectCause.RuntimeException("Stream Timeout");
-  return Function_dist_effectFunction.pipe(self, timeoutFailCause(() => Cause_dist_effectCause.die(StreamTimeout), duration), catchSomeCause(cause => Cause_dist_effectCause.isDieType(cause) && Cause_dist_effectCause.isRuntimeException(cause.defect) && cause.defect.message !== undefined && cause.defect.message === "Stream Timeout" ? Option_dist_effectOption.some(that) : Option_dist_effectOption.none()));
-});
-
-/** @internal */
-const toHub = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, capacity) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.acquireRelease(Hub_dist_effectHub.bounded(capacity), hub => Hub_dist_effectHub.shutdown(hub)), Effect_dist_effectEffect.tap(hub => Function_dist_effectFunction.pipe(self, runIntoHubScoped(hub), Effect_dist_effectEffect.forkScoped))));
-
-/** @internal */
-const toPull = self => Effect_dist_effectEffect.map(sink.toPull(toChannel(self)), pull => Function_dist_effectFunction.pipe(pull, Effect_dist_effectEffect.mapError(Option_dist_effectOption.some), Effect_dist_effectEffect.flatMap(Either_dist_effectEither.match({
-  onLeft: () => Effect_dist_effectEffect.fail(Option_dist_effectOption.none()),
-  onRight: Effect_dist_effectEffect.succeed
-}))));
-
-/** @internal */
-const toQueue = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => Effect_dist_effectEffect.tap(Effect_dist_effectEffect.acquireRelease(options?.strategy === "unbounded" ? Queue_dist_effectQueue.unbounded() : options?.strategy === "dropping" ? Queue_dist_effectQueue.dropping(options.capacity ?? 2) : options?.strategy === "sliding" ? Queue_dist_effectQueue.sliding(options.capacity ?? 2) : Queue_dist_effectQueue.bounded(options?.capacity ?? 2), queue => Queue_dist_effectQueue.shutdown(queue)), queue => Effect_dist_effectEffect.forkScoped(runIntoQueueScoped(self, queue))));
-
-/** @internal */
-const toQueueOfElements = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, options) => Effect_dist_effectEffect.tap(Effect_dist_effectEffect.acquireRelease(Queue_dist_effectQueue.bounded(options?.capacity ?? 2), queue => Queue_dist_effectQueue.shutdown(queue)), queue => Effect_dist_effectEffect.forkScoped(runIntoQueueElementsScoped(self, queue))));
-
-/** @internal */
-const toReadableStream = source => {
-  let pull;
-  let scope;
-  return new ReadableStream({
-    start(controller) {
-      scope = Effect_dist_effectEffect.runSync(Scope_dist_effectScope.make());
-      pull = Function_dist_effectFunction.pipe(toPull(source), Scope_dist_effectScope.use(scope), Effect_dist_effectEffect.runSync, Effect_dist_effectEffect.tap(chunk => Effect_dist_effectEffect.sync(() => {
-        Chunk_dist_effectChunk.map(chunk, a => {
-          controller.enqueue(a);
-        });
-      })), Effect_dist_effectEffect.tapErrorCause(() => Scope_dist_effectScope.close(scope, Exit_dist_effectExit.unit)), Effect_dist_effectEffect.catchTags({
-        "None": () => Effect_dist_effectEffect.sync(() => {
-          controller.close();
-        }),
-        "Some": error => Effect_dist_effectEffect.sync(() => {
-          controller.error(error.value);
-        })
-      }), Effect_dist_effectEffect.asUnit);
-    },
-    pull() {
-      return Effect_dist_effectEffect.runPromise(pull);
-    },
-    cancel() {
-      return Effect_dist_effectEffect.runPromise(Scope_dist_effectScope.close(scope, Exit_dist_effectExit.unit));
-    }
-  });
-};
-
-/** @internal */
-const transduce = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, sink$1) => {
-  const newChannel = sink.suspend(() => {
-    const leftovers = {
-      ref: Chunk_dist_effectChunk.empty()
-    };
-    const upstreamDone = {
-      ref: false
-    };
-    const buffer = sink.suspend(() => {
-      const leftover = leftovers.ref;
-      if (Chunk_dist_effectChunk.isEmpty(leftover)) {
-        return sink.readWith({
-          onInput: input => Function_dist_effectFunction.pipe(sink.write(input), sink.flatMap(() => buffer)),
-          onFailure: sink.fail,
-          onDone: sink.succeedNow
-        });
-      }
-      leftovers.ref = Chunk_dist_effectChunk.empty();
-      return Function_dist_effectFunction.pipe(sink.writeChunk(leftover), sink.flatMap(() => buffer));
-    });
-    const concatAndGet = chunk => {
-      const leftover = leftovers.ref;
-      const concatenated = Chunk_dist_effectChunk.appendAll(leftover, Chunk_dist_effectChunk.filter(chunk, chunk => chunk.length !== 0));
-      leftovers.ref = concatenated;
-      return concatenated;
-    };
-    const upstreamMarker = sink.readWith({
-      onInput: input => sink.flatMap(sink.write(input), () => upstreamMarker),
-      onFailure: sink.fail,
-      onDone: done => sink.zipRight(sink.sync(() => {
-        upstreamDone.ref = true;
-      }), sink.succeedNow(done))
-    });
-    const transducer = Function_dist_effectFunction.pipe(sink$1, sink.toChannel, sink.collectElements, sink.flatMap(([leftover, z]) => Function_dist_effectFunction.pipe(sink.succeed([upstreamDone.ref, concatAndGet(leftover)]), sink.flatMap(([done, newLeftovers]) => {
-      const nextChannel = done && Chunk_dist_effectChunk.isEmpty(newLeftovers) ? sink.unit : transducer;
-      return Function_dist_effectFunction.pipe(sink.write(Chunk_dist_effectChunk.of(z)), sink.flatMap(() => nextChannel));
-    }))));
-    return Function_dist_effectFunction.pipe(toChannel(self), sink.pipeTo(upstreamMarker), sink.pipeTo(buffer), sink.pipeToOrFail(transducer));
-  });
-  return new StreamImpl(newChannel);
-});
-
-/** @internal */
-const unfold = (s, f) => unfoldChunk(s, s => Function_dist_effectFunction.pipe(f(s), Option_dist_effectOption.map(([a, s]) => [Chunk_dist_effectChunk.of(a), s])));
-
-/** @internal */
-const unfoldChunk = (s, f) => {
-  const loop = s => Option_dist_effectOption.match(f(s), {
-    onNone: () => sink.unit,
-    onSome: ([chunk, s]) => sink.flatMap(sink.write(chunk), () => loop(s))
-  });
-  return new StreamImpl(sink.suspend(() => loop(s)));
-};
-
-/** @internal */
-const unfoldChunkEffect = (s, f) => suspend(() => {
-  const loop = s => sink.unwrap(Effect_dist_effectEffect.map(f(s), Option_dist_effectOption.match({
-    onNone: () => sink.unit,
-    onSome: ([chunk, s]) => sink.flatMap(sink.write(chunk), () => loop(s))
-  })));
-  return new StreamImpl(loop(s));
-});
-
-/** @internal */
-const unfoldEffect = (s, f) => unfoldChunkEffect(s, s => Function_dist_effectFunction.pipe(f(s), Effect_dist_effectEffect.map(Option_dist_effectOption.map(([a, s]) => [Chunk_dist_effectChunk.of(a), s]))));
-
-/** @internal */
-const unit = /*#__PURE__*/succeed(void 0);
-
-/** @internal */
-const unwrap = effect => flatten(fromEffect(effect));
-
-/** @internal */
-const unwrapScoped = effect => flatten(scoped(effect));
-
-/** @internal */
-const updateService = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => Function_dist_effectFunction.pipe(self, mapInputContext(context => Function_dist_effectFunction.pipe(context, Context_dist_effectContext.add(tag, f(Function_dist_effectFunction.pipe(context, Context_dist_effectContext.unsafeGet(tag))))))));
-
-/** @internal */
-const when = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, predicate) => Function_dist_effectFunction.pipe(self, whenEffect(Effect_dist_effectEffect.sync(predicate))));
-
-/** @internal */
-const whenCase = (evaluate, pf) => whenCaseEffect(pf)(Effect_dist_effectEffect.sync(evaluate));
-
-/** @internal */
-const whenCaseEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, pf) => Function_dist_effectFunction.pipe(fromEffect(self), flatMap(a => Function_dist_effectFunction.pipe(pf(a), Option_dist_effectOption.getOrElse(() => empty)))));
-
-/** @internal */
-const whenEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => Function_dist_effectFunction.pipe(fromEffect(effect), flatMap(bool => bool ? self : empty)));
-
-/** @internal */
-const withSpan = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, name, options) => unwrapScoped(Effect_dist_effectEffect.as(Effect_dist_effectEffect.withSpanScoped(name, options), self)));
-
-/** @internal */
-const zip = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWith(that, (a, a2) => [a, a2])));
-
-/** @internal */
-const zipFlatten = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWith(that, (a, a2) => [...a, a2])));
-
-/** @internal */
-const zipAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllWith(self, {
-  other: options.other,
-  onSelf: a => [a, options.defaultOther],
-  onOther: a2 => [options.defaultSelf, a2],
-  onBoth: (a, a2) => [a, a2]
-}));
-
-/** @internal */
-const zipAllLeft = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, defaultSelf) => zipAllWith(self, {
-  other,
-  onSelf: Function_dist_effectFunction.identity,
-  onOther: () => defaultSelf,
-  onBoth: a => a
-}));
-
-/** @internal */
-const zipAllRight = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, defaultRight) => zipAllWith(self, {
-  other,
-  onSelf: () => defaultRight,
-  onOther: Function_dist_effectFunction.identity,
-  onBoth: (_, a2) => a2
-}));
-
-/** @internal */
-const zipAllSortedByKey = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllSortedByKeyWith(self, {
-  other: options.other,
-  onSelf: a => [a, options.defaultOther],
-  onOther: a2 => [options.defaultSelf, a2],
-  onBoth: (a, a2) => [a, a2],
-  order: options.order
-}));
-
-/** @internal */
-const zipAllSortedByKeyLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllSortedByKeyWith(self, {
-  other: options.other,
-  onSelf: Function_dist_effectFunction.identity,
-  onOther: () => options.defaultSelf,
-  onBoth: a => a,
-  order: options.order
-}));
-
-/** @internal */
-const zipAllSortedByKeyRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => zipAllSortedByKeyWith(self, {
-  other: options.other,
-  onSelf: () => options.defaultOther,
-  onOther: Function_dist_effectFunction.identity,
-  onBoth: (_, a2) => a2,
-  order: options.order
-}));
-
-/** @internal */
-const zipAllSortedByKeyWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const pull = (state, pullLeft, pullRight) => {
-    switch (state._tag) {
-      case OP_DRAIN_LEFT:
-        {
-          return Function_dist_effectFunction.pipe(pullLeft, Effect_dist_effectEffect.match({
-            onFailure: Exit_dist_effectExit.fail,
-            onSuccess: leftChunk => Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])
-          }));
-        }
-      case OP_DRAIN_RIGHT:
-        {
-          return Function_dist_effectFunction.pipe(pullRight, Effect_dist_effectEffect.match({
-            onFailure: Exit_dist_effectExit.fail,
-            onSuccess: rightChunk => Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(rightChunk, ([k, a2]) => [k, options.onOther(a2)]), DrainRight])
-          }));
-        }
-      case OP_PULL_BOTH$1:
-        {
-          return Function_dist_effectFunction.pipe(unsome(pullLeft), Effect_dist_effectEffect.zip(unsome(pullRight), {
-            concurrent: true
-          }), Effect_dist_effectEffect.matchEffect({
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error))),
-            onSuccess: ([leftOption, rightOption]) => {
-              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value) && Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(PullBoth$1, pullLeft, pullRight);
-                }
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
-                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
-                }
-                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
-                }
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(merge(leftOption.value, rightOption.value)));
-              }
-              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isNone(rightOption)) {
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
-                  return pull(DrainLeft, pullLeft, pullRight);
-                }
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Function_dist_effectFunction.pipe(leftOption.value, Chunk_dist_effectChunk.map(([k, a]) => [k, options.onSelf(a)])), DrainLeft]));
-              }
-              if (Option_dist_effectOption.isNone(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
-                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(DrainRight, pullLeft, pullRight);
-                }
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Function_dist_effectFunction.pipe(rightOption.value, Chunk_dist_effectChunk.map(([k, a2]) => [k, options.onOther(a2)])), DrainRight]));
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.none()));
-            }
-          }));
-        }
-      case OP_PULL_LEFT$1:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullLeft, {
-            onFailure: Option_dist_effectOption.match({
-              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Function_dist_effectFunction.pipe(state.rightChunk, Chunk_dist_effectChunk.map(([k, a2]) => [k, options.onOther(a2)])), DrainRight])),
-              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
-            }),
-            onSuccess: leftChunk => Chunk_dist_effectChunk.isEmpty(leftChunk) ? pull(PullLeft$1(state.rightChunk), pullLeft, pullRight) : Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(merge(leftChunk, state.rightChunk)))
-          });
-        }
-      case OP_PULL_RIGHT$1:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullRight, {
-            onFailure: Option_dist_effectOption.match({
-              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(state.leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])),
-              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
-            }),
-            onSuccess: rightChunk => Chunk_dist_effectChunk.isEmpty(rightChunk) ? pull(PullRight$1(state.leftChunk), pullLeft, pullRight) : Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(merge(state.leftChunk, rightChunk)))
-          });
-        }
-    }
-  };
-  const merge = (leftChunk, rightChunk) => {
-    const hasNext = (chunk, index) => index < chunk.length - 1;
-    const builder = [];
-    let state = undefined;
-    let leftIndex = 0;
-    let rightIndex = 0;
-    let leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
-    let rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
-    let k1 = leftTuple[0];
-    let a = leftTuple[1];
-    let k2 = rightTuple[0];
-    let a2 = rightTuple[1];
-    let loop = true;
-    while (loop) {
-      const compare = options.order(k1, k2);
-      if (compare === 0) {
-        builder.push([k1, options.onBoth(a, a2)]);
-        if (hasNext(leftChunk, leftIndex) && hasNext(rightChunk, rightIndex)) {
-          leftIndex = leftIndex + 1;
-          rightIndex = rightIndex + 1;
-          leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
-          rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
-          k1 = leftTuple[0];
-          a = leftTuple[1];
-          k2 = rightTuple[0];
-          a2 = rightTuple[1];
-        } else if (hasNext(leftChunk, leftIndex)) {
-          state = PullRight$1(Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.drop(leftIndex + 1)));
-          loop = false;
-        } else if (hasNext(rightChunk, rightIndex)) {
-          state = PullLeft$1(Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.drop(rightIndex + 1)));
-          loop = false;
-        } else {
-          state = PullBoth$1;
-          loop = false;
-        }
-      } else if (compare < 0) {
-        builder.push([k1, options.onSelf(a)]);
-        if (hasNext(leftChunk, leftIndex)) {
-          leftIndex = leftIndex + 1;
-          leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
-          k1 = leftTuple[0];
-          a = leftTuple[1];
-        } else {
-          const rightBuilder = [];
-          rightBuilder.push(rightTuple);
-          while (hasNext(rightChunk, rightIndex)) {
-            rightIndex = rightIndex + 1;
-            rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
-            rightBuilder.push(rightTuple);
-          }
-          state = PullLeft$1(Chunk_dist_effectChunk.unsafeFromArray(rightBuilder));
-          loop = false;
-        }
-      } else {
-        builder.push([k2, options.onOther(a2)]);
-        if (hasNext(rightChunk, rightIndex)) {
-          rightIndex = rightIndex + 1;
-          rightTuple = Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.unsafeGet(rightIndex));
-          k2 = rightTuple[0];
-          a2 = rightTuple[1];
-        } else {
-          const leftBuilder = [];
-          leftBuilder.push(leftTuple);
-          while (hasNext(leftChunk, leftIndex)) {
-            leftIndex = leftIndex + 1;
-            leftTuple = Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.unsafeGet(leftIndex));
-            leftBuilder.push(leftTuple);
-          }
-          state = PullRight$1(Chunk_dist_effectChunk.unsafeFromArray(leftBuilder));
-          loop = false;
-        }
-      }
-    }
-    return [Chunk_dist_effectChunk.unsafeFromArray(builder), state];
-  };
-  return combineChunks(self, options.other, PullBoth$1, pull);
-});
-
-/** @internal */
-const zipAllWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, options) => {
-  const pull = (state, pullLeft, pullRight) => {
-    switch (state._tag) {
-      case OP_DRAIN_LEFT:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullLeft, {
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
-            onSuccess: leftChunk => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(leftChunk, options.onSelf), DrainLeft]))
-          });
-        }
-      case OP_DRAIN_RIGHT:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullRight, {
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
-            onSuccess: rightChunk => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(rightChunk, options.onOther), DrainRight]))
-          });
-        }
-      case OP_PULL_BOTH$1:
-        {
-          return Function_dist_effectFunction.pipe(unsome(pullLeft), Effect_dist_effectEffect.zip(unsome(pullRight), {
-            concurrent: true
-          }), Effect_dist_effectEffect.matchEffect({
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error))),
-            onSuccess: ([leftOption, rightOption]) => {
-              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value) && Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(PullBoth$1, pullLeft, pullRight);
-                }
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
-                  return pull(PullLeft$1(rightOption.value), pullLeft, pullRight);
-                }
-                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(PullRight$1(leftOption.value), pullLeft, pullRight);
-                }
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftOption.value, rightOption.value, options.onBoth)));
-              }
-              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isNone(rightOption)) {
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(leftOption.value, options.onSelf), DrainLeft]));
-              }
-              if (Option_dist_effectOption.isNone(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(rightOption.value, options.onOther), DrainRight]));
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.none()));
-            }
-          }));
-        }
-      case OP_PULL_LEFT$1:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullLeft, {
-            onFailure: Option_dist_effectOption.match({
-              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(state.rightChunk, options.onOther), DrainRight])),
-              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
-            }),
-            onSuccess: leftChunk => {
-              if (Chunk_dist_effectChunk.isEmpty(leftChunk)) {
-                return pull(PullLeft$1(state.rightChunk), pullLeft, pullRight);
-              }
-              if (Chunk_dist_effectChunk.isEmpty(state.rightChunk)) {
-                return pull(PullRight$1(leftChunk), pullLeft, pullRight);
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftChunk, state.rightChunk, options.onBoth)));
-            }
-          });
-        }
-      case OP_PULL_RIGHT$1:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullRight, {
-            onFailure: Option_dist_effectOption.match({
-              onNone: () => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed([Chunk_dist_effectChunk.map(state.leftChunk, options.onSelf), DrainLeft])),
-              onSome: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error)))
-            }),
-            onSuccess: rightChunk => {
-              if (Chunk_dist_effectChunk.isEmpty(rightChunk)) {
-                return pull(PullRight$1(state.leftChunk), pullLeft, pullRight);
-              }
-              if (Chunk_dist_effectChunk.isEmpty(state.leftChunk)) {
-                return pull(PullLeft$1(rightChunk), pullLeft, pullRight);
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(state.leftChunk, rightChunk, options.onBoth)));
-            }
-          });
-        }
-    }
-  };
-  const zip = (leftChunk, rightChunk, f) => {
-    const [output, either] = zipChunks(leftChunk, rightChunk, f);
-    switch (either._tag) {
-      case "Left":
-        {
-          if (Chunk_dist_effectChunk.isEmpty(either.left)) {
-            return [output, PullBoth$1];
-          }
-          return [output, PullRight$1(either.left)];
-        }
-      case "Right":
-        {
-          if (Chunk_dist_effectChunk.isEmpty(either.right)) {
-            return [output, PullBoth$1];
-          }
-          return [output, PullLeft$1(either.right)];
-        }
-    }
-  };
-  return combineChunks(self, options.other, PullBoth$1, pull);
-});
-
-/** @internal */
-const zipLatest = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipLatestWith(that, (a, a2) => [a, a2])));
-
-/** @internal */
-const zipLatestWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => {
-  const pullNonEmpty = pull => Function_dist_effectFunction.pipe(pull, Effect_dist_effectEffect.flatMap(chunk => Chunk_dist_effectChunk.isEmpty(chunk) ? pullNonEmpty(pull) : Effect_dist_effectEffect.succeed(chunk)));
-  return Function_dist_effectFunction.pipe(toPull(self), Effect_dist_effectEffect.map(pullNonEmpty), Effect_dist_effectEffect.zip(Function_dist_effectFunction.pipe(toPull(that), Effect_dist_effectEffect.map(pullNonEmpty))), Effect_dist_effectEffect.flatMap(([left, right]) => Function_dist_effectFunction.pipe(fromEffectOption(Effect_dist_effectEffect.raceWith(left, right, {
-    onSelfDone: (leftDone, rightFiber) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => leftDone), Effect_dist_effectEffect.zipWith(Fiber_dist_effectFiber.join(rightFiber), (l, r) => [l, r, true])),
-    onOtherDone: (rightDone, leftFiber) => Function_dist_effectFunction.pipe(Effect_dist_effectEffect.suspend(() => rightDone), Effect_dist_effectEffect.zipWith(Fiber_dist_effectFiber.join(leftFiber), (l, r) => [r, l, false]))
-  })), flatMap(([l, r, leftFirst]) => Function_dist_effectFunction.pipe(fromEffect(Ref_dist_effectRef.make([Chunk_dist_effectChunk.unsafeLast(l), Chunk_dist_effectChunk.unsafeLast(r)])), flatMap(latest => Function_dist_effectFunction.pipe(fromChunk(leftFirst ? Function_dist_effectFunction.pipe(r, Chunk_dist_effectChunk.map(a2 => f(Chunk_dist_effectChunk.unsafeLast(l), a2))) : Function_dist_effectFunction.pipe(l, Chunk_dist_effectChunk.map(a => f(a, Chunk_dist_effectChunk.unsafeLast(r))))), concat(Function_dist_effectFunction.pipe(repeatEffectOption(left), mergeEither(repeatEffectOption(right)), mapEffectSequential(Either_dist_effectEither.match({
-    onLeft: leftChunk => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(latest, ([_, rightLatest]) => [Function_dist_effectFunction.pipe(leftChunk, Chunk_dist_effectChunk.map(a => f(a, rightLatest))), [Chunk_dist_effectChunk.unsafeLast(leftChunk), rightLatest]])),
-    onRight: rightChunk => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(latest, ([leftLatest, _]) => [Function_dist_effectFunction.pipe(rightChunk, Chunk_dist_effectChunk.map(a2 => f(leftLatest, a2))), [leftLatest, Chunk_dist_effectChunk.unsafeLast(rightChunk)]]))
-  })), flatMap(fromChunk))))))), toPull)), fromPull);
-});
-
-/** @internal */
-const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWithChunks(that, (left, right) => {
-  if (left.length > right.length) {
-    return [Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length)), Either_dist_effectEither.left(Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length)))];
-  }
-  return [left, Either_dist_effectEither.right(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.drop(left.length)))];
-})));
-
-/** @internal */
-const zipRight = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => Function_dist_effectFunction.pipe(self, zipWithChunks(that, (left, right) => {
-  if (left.length > right.length) {
-    return [right, Either_dist_effectEither.left(Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length)))];
-  }
-  return [Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.take(left.length)), Either_dist_effectEither.right(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.drop(left.length)))];
-})));
-
-/** @internal */
-const zipWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => Function_dist_effectFunction.pipe(self, zipWithChunks(that, (leftChunk, rightChunk) => zipChunks(leftChunk, rightChunk, f))));
-
-/** @internal */
-const zipWithChunks = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => {
-  const pull = (state, pullLeft, pullRight) => {
-    switch (state._tag) {
-      case OP_PULL_BOTH:
-        {
-          return Function_dist_effectFunction.pipe(unsome(pullLeft), Effect_dist_effectEffect.zip(unsome(pullRight), {
-            concurrent: true
-          }), Effect_dist_effectEffect.matchEffect({
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.some(error))),
-            onSuccess: ([leftOption, rightOption]) => {
-              if (Option_dist_effectOption.isSome(leftOption) && Option_dist_effectOption.isSome(rightOption)) {
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value) && Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(PullBoth, pullLeft, pullRight);
-                }
-                if (Chunk_dist_effectChunk.isEmpty(leftOption.value)) {
-                  return pull(PullLeft(rightOption.value), pullLeft, pullRight);
-                }
-                if (Chunk_dist_effectChunk.isEmpty(rightOption.value)) {
-                  return pull(PullRight(leftOption.value), pullLeft, pullRight);
-                }
-                return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftOption.value, rightOption.value)));
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(Option_dist_effectOption.none()));
-            }
-          }));
-        }
-      case OP_PULL_LEFT:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullLeft, {
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
-            onSuccess: leftChunk => {
-              if (Chunk_dist_effectChunk.isEmpty(leftChunk)) {
-                return pull(PullLeft(state.rightChunk), pullLeft, pullRight);
-              }
-              if (Chunk_dist_effectChunk.isEmpty(state.rightChunk)) {
-                return pull(PullRight(leftChunk), pullLeft, pullRight);
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(leftChunk, state.rightChunk)));
-            }
-          });
-        }
-      case OP_PULL_RIGHT:
-        {
-          return Effect_dist_effectEffect.matchEffect(pullRight, {
-            onFailure: error => Effect_dist_effectEffect.succeed(Exit_dist_effectExit.fail(error)),
-            onSuccess: rightChunk => {
-              if (Chunk_dist_effectChunk.isEmpty(rightChunk)) {
-                return pull(PullRight(state.leftChunk), pullLeft, pullRight);
-              }
-              if (Chunk_dist_effectChunk.isEmpty(state.leftChunk)) {
-                return pull(PullLeft(rightChunk), pullLeft, pullRight);
-              }
-              return Effect_dist_effectEffect.succeed(Exit_dist_effectExit.succeed(zip(state.leftChunk, rightChunk)));
-            }
-          });
-        }
-    }
-  };
-  const zip = (leftChunk, rightChunk) => {
-    const [output, either] = f(leftChunk, rightChunk);
-    switch (either._tag) {
-      case "Left":
-        {
-          if (Chunk_dist_effectChunk.isEmpty(either.left)) {
-            return [output, PullBoth];
-          }
-          return [output, PullRight(either.left)];
-        }
-      case "Right":
-        {
-          if (Chunk_dist_effectChunk.isEmpty(either.right)) {
-            return [output, PullBoth];
-          }
-          return [output, PullLeft(either.right)];
-        }
-    }
-  };
-  return Function_dist_effectFunction.pipe(self, combineChunks(that, PullBoth, pull));
-});
-
-/** @internal */
-const zipWithIndex = self => Function_dist_effectFunction.pipe(self, mapAccum(0, (index, a) => [index + 1, [a, index]]));
-
-/** @internal */
-const zipWithNext = self => {
-  const process = last => sink.readWithCause({
-    onInput: input => {
-      const [newLast, chunk] = Chunk_dist_effectChunk.mapAccum(input, last, (prev, curr) => [Option_dist_effectOption.some(curr), Function_dist_effectFunction.pipe(prev, Option_dist_effectOption.map(a => [a, curr]))]);
-      const output = Chunk_dist_effectChunk.filterMap(chunk, option => Option_dist_effectOption.isSome(option) ? Option_dist_effectOption.some([option.value[0], Option_dist_effectOption.some(option.value[1])]) : Option_dist_effectOption.none());
-      return sink.flatMap(sink.write(output), () => process(newLast));
-    },
-    onFailure: sink.failCause,
-    onDone: () => Option_dist_effectOption.match(last, {
-      onNone: () => sink.unit,
-      onSome: value => sink.zipRight(sink.write(Chunk_dist_effectChunk.of([value, Option_dist_effectOption.none()])), sink.unit)
-    })
-  });
-  return new StreamImpl(Function_dist_effectFunction.pipe(toChannel(self), sink.pipeToOrFail(process(Option_dist_effectOption.none()))));
-};
-
-/** @internal */
-const zipWithPrevious = self => Function_dist_effectFunction.pipe(self, mapAccum(Option_dist_effectOption.none(), (prev, curr) => [Option_dist_effectOption.some(curr), [prev, curr]]));
-
-/** @internal */
-const zipWithPreviousAndNext = self => Function_dist_effectFunction.pipe(zipWithNext(zipWithPrevious(self)), map(([[prev, curr], next]) => [prev, curr, Function_dist_effectFunction.pipe(next, Option_dist_effectOption.map(tuple => tuple[1]))]));
-
-/** @internal */
-const zipChunks = (left, right, f) => {
-  if (left.length > right.length) {
-    return [Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.take(right.length), Chunk_dist_effectChunk.zipWith(right, f)), Either_dist_effectEither.left(Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.drop(right.length)))];
-  }
-  return [Function_dist_effectFunction.pipe(left, Chunk_dist_effectChunk.zipWith(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.take(left.length)), f)), Either_dist_effectEither.right(Function_dist_effectFunction.pipe(right, Chunk_dist_effectChunk.drop(left.length)))];
-};
-
-// Do notation
-
-/** @internal */
-const Do = /*#__PURE__*/succeed({});
-
-/** @internal */
-const bind = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "string", (self, tag, f, options) => flatMap(self, k => map(f(k), a => ({
-  ...k,
-  [tag]: a
-})), options));
-
-/* @internal */
-const bindTo = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, tag) => map(self, a => ({
-  [tag]: a
-})));
-
-/* @internal */
-const let_ = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, tag, f) => map(self, k => ({
-  ...k,
-  [tag]: f(k)
-})));
-
-// Circular with Channel
-
-/** @internal */
-const channelToStream = self => {
-  return new StreamImpl(self);
-};
-
-// =============================================================================
-// encoding
-// =============================================================================
-
-/** @internal */
-const decodeText = /*#__PURE__*/Function_dist_effectFunction.dual(args => isStream(args[0]), (self, encoding = "utf-8") => suspend(() => {
-  const decoder = new TextDecoder(encoding);
-  return map(self, s => decoder.decode(s));
-}));
-
-/** @internal */
-const encodeText = self => suspend(() => {
-  const encoder = new TextEncoder();
-  return map(self, s => encoder.encode(s));
-});
-
-exports.DefaultChunkSize = DefaultChunkSize;
-exports.Do = Do;
-exports.StreamTypeId = StreamTypeId;
-exports._async = _async;
-exports.acquireRelease = acquireRelease;
-exports.aggregate = aggregate;
-exports.aggregateWithin = aggregateWithin;
-exports.aggregateWithinEither = aggregateWithinEither;
-exports.as = as;
-exports.asyncEffect = asyncEffect;
-exports.asyncInterrupt = asyncInterrupt;
-exports.asyncOption = asyncOption;
-exports.asyncScoped = asyncScoped;
-exports.bind = bind;
-exports.bindTo = bindTo;
-exports.branchAfter = branchAfter;
-exports.broadcast = broadcast;
-exports.broadcastDynamic = broadcastDynamic;
-exports.broadcastedQueues = broadcastedQueues;
-exports.broadcastedQueuesDynamic = broadcastedQueuesDynamic;
-exports.buffer = buffer;
-exports.bufferChunks = bufferChunks;
-exports.catchAll = catchAll;
-exports.catchAllCause = catchAllCause;
-exports.catchSome = catchSome;
-exports.catchSomeCause = catchSomeCause;
-exports.catchTag = catchTag;
-exports.catchTags = catchTags;
-exports.changes = changes;
-exports.changesWith = changesWith;
-exports.changesWithEffect = changesWithEffect;
-exports.channelToStream = channelToStream;
-exports.chunks = chunks;
-exports.chunksWith = chunksWith;
-exports.combine = combine;
-exports.combineChunks = combineChunks;
-exports.concat = concat;
-exports.concatAll = concatAll;
-exports.context = context;
-exports.contextWith = contextWith;
-exports.contextWithEffect = contextWithEffect;
-exports.contextWithStream = contextWithStream;
-exports.cross = cross;
-exports.crossLeft = crossLeft;
-exports.crossRight = crossRight;
-exports.crossWith = crossWith;
-exports.debounce = debounce;
-exports.decodeText = decodeText;
-exports.die = die;
-exports.dieMessage = dieMessage;
-exports.dieSync = dieSync;
-exports.distributedWith = distributedWith;
-exports.distributedWithDynamic = distributedWithDynamic;
-exports.distributedWithDynamicCallback = distributedWithDynamicCallback;
-exports.drain = drain;
-exports.drainFork = drainFork;
-exports.drop = drop;
-exports.dropRight = dropRight;
-exports.dropUntil = dropUntil;
-exports.dropUntilEffect = dropUntilEffect;
-exports.dropWhile = dropWhile;
-exports.dropWhileEffect = dropWhileEffect;
-exports.either = either;
-exports.empty = empty;
-exports.encodeText = encodeText;
-exports.ensuring = ensuring;
-exports.ensuringWith = ensuringWith;
-exports.execute = execute;
-exports.fail = fail;
-exports.failCause = failCause;
-exports.failCauseSync = failCauseSync;
-exports.failSync = failSync;
-exports.filter = filter;
-exports.filterEffect = filterEffect;
-exports.filterMap = filterMap;
-exports.filterMapEffect = filterMapEffect;
-exports.filterMapWhile = filterMapWhile;
-exports.filterMapWhileEffect = filterMapWhileEffect;
-exports.finalizer = finalizer;
-exports.find = find;
-exports.findEffect = findEffect;
-exports.flatMap = flatMap;
-exports.flatten = flatten;
-exports.flattenChunks = flattenChunks;
-exports.flattenEffect = flattenEffect;
-exports.flattenExitOption = flattenExitOption;
-exports.flattenIterables = flattenIterables;
-exports.flattenTake = flattenTake;
-exports.forever = forever;
-exports.fromAsyncIterable = fromAsyncIterable;
-exports.fromChannel = fromChannel;
-exports.fromChunk = fromChunk;
-exports.fromChunkHub = fromChunkHub;
-exports.fromChunkQueue = fromChunkQueue;
-exports.fromChunks = fromChunks;
-exports.fromEffect = fromEffect;
-exports.fromEffectOption = fromEffectOption;
-exports.fromHub = fromHub;
-exports.fromIterable = fromIterable;
-exports.fromIterableEffect = fromIterableEffect;
-exports.fromIteratorSucceed = fromIteratorSucceed;
-exports.fromPull = fromPull;
-exports.fromQueue = fromQueue;
-exports.fromReadableStream = fromReadableStream;
-exports.fromReadableStreamByob = fromReadableStreamByob;
-exports.fromSchedule = fromSchedule;
-exports.groupAdjacentBy = groupAdjacentBy;
-exports.grouped = grouped;
-exports.groupedWithin = groupedWithin;
-exports.haltAfter = haltAfter;
-exports.haltWhen = haltWhen;
-exports.haltWhenDeferred = haltWhenDeferred;
-exports.identityStream = identityStream;
-exports.interleave = interleave;
-exports.interleaveWith = interleaveWith;
-exports.interruptAfter = interruptAfter;
-exports.interruptWhen = interruptWhen;
-exports.interruptWhenDeferred = interruptWhenDeferred;
-exports.intersperse = intersperse;
-exports.intersperseAffixes = intersperseAffixes;
-exports.iterate = iterate;
-exports.let_ = let_;
-exports.make = make;
-exports.map = map;
-exports.mapAccum = mapAccum;
-exports.mapAccumEffect = mapAccumEffect;
-exports.mapBoth = mapBoth;
-exports.mapChunks = mapChunks;
-exports.mapChunksEffect = mapChunksEffect;
-exports.mapConcat = mapConcat;
-exports.mapConcatChunk = mapConcatChunk;
-exports.mapConcatChunkEffect = mapConcatChunkEffect;
-exports.mapConcatEffect = mapConcatEffect;
-exports.mapEffectPar = mapEffectPar;
-exports.mapEffectSequential = mapEffectSequential;
-exports.mapError = mapError;
-exports.mapErrorCause = mapErrorCause;
-exports.mapInputContext = mapInputContext;
-exports.matchConcurrency = matchConcurrency;
-exports.merge = merge;
-exports.mergeAll = mergeAll;
-exports.mergeEither = mergeEither;
-exports.mergeLeft = mergeLeft;
-exports.mergeRight = mergeRight;
-exports.mergeWith = mergeWith;
-exports.mkString = mkString;
-exports.never = never;
-exports.onDone = onDone;
-exports.onError = onError;
-exports.orDie = orDie;
-exports.orDieWith = orDieWith;
-exports.orElse = orElse;
-exports.orElseEither = orElseEither;
-exports.orElseFail = orElseFail;
-exports.orElseIfEmpty = orElseIfEmpty;
-exports.orElseIfEmptyChunk = orElseIfEmptyChunk;
-exports.orElseIfEmptyStream = orElseIfEmptyStream;
-exports.orElseSucceed = orElseSucceed;
-exports.paginate = paginate;
-exports.paginateChunk = paginateChunk;
-exports.paginateChunkEffect = paginateChunkEffect;
-exports.paginateEffect = paginateEffect;
-exports.partition = partition;
-exports.partitionEither = partitionEither;
-exports.peel = peel;
-exports.pipeThrough = pipeThrough;
-exports.pipeThroughChannel = pipeThroughChannel;
-exports.pipeThroughChannelOrFail = pipeThroughChannelOrFail;
-exports.prepend = prepend;
-exports.provideContext = provideContext;
-exports.provideLayer = provideLayer;
-exports.provideService = provideService;
-exports.provideServiceEffect = provideServiceEffect;
-exports.provideServiceStream = provideServiceStream;
-exports.provideSomeLayer = provideSomeLayer;
-exports.range = range;
-exports.rechunk = rechunk;
-exports.refineOrDie = refineOrDie;
-exports.refineOrDieWith = refineOrDieWith;
-exports.repeat = repeat;
-exports.repeatEffect = repeatEffect;
-exports.repeatEffectChunk = repeatEffectChunk;
-exports.repeatEffectChunkOption = repeatEffectChunkOption;
-exports.repeatEffectOption = repeatEffectOption;
-exports.repeatEffectWithSchedule = repeatEffectWithSchedule;
-exports.repeatEither = repeatEither;
-exports.repeatElements = repeatElements;
-exports.repeatElementsWith = repeatElementsWith;
-exports.repeatValue = repeatValue;
-exports.repeatWith = repeatWith;
-exports.retry = retry;
-exports.run = run;
-exports.runCollect = runCollect;
-exports.runCount = runCount;
-exports.runDrain = runDrain;
-exports.runFold = runFold;
-exports.runFoldEffect = runFoldEffect;
-exports.runFoldScoped = runFoldScoped;
-exports.runFoldScopedEffect = runFoldScopedEffect;
-exports.runFoldWhile = runFoldWhile;
-exports.runFoldWhileEffect = runFoldWhileEffect;
-exports.runFoldWhileScoped = runFoldWhileScoped;
-exports.runFoldWhileScopedEffect = runFoldWhileScopedEffect;
-exports.runForEach = runForEach;
-exports.runForEachChunk = runForEachChunk;
-exports.runForEachChunkScoped = runForEachChunkScoped;
-exports.runForEachScoped = runForEachScoped;
-exports.runForEachWhile = runForEachWhile;
-exports.runForEachWhileScoped = runForEachWhileScoped;
-exports.runHead = runHead;
-exports.runIntoHub = runIntoHub;
-exports.runIntoHubScoped = runIntoHubScoped;
-exports.runIntoQueue = runIntoQueue;
-exports.runIntoQueueElementsScoped = runIntoQueueElementsScoped;
-exports.runIntoQueueScoped = runIntoQueueScoped;
-exports.runLast = runLast;
-exports.runScoped = runScoped;
-exports.runSum = runSum;
-exports.scan = scan;
-exports.scanEffect = scanEffect;
-exports.scanReduce = scanReduce;
-exports.scanReduceEffect = scanReduceEffect;
-exports.schedule = schedule;
-exports.scheduleWith = scheduleWith;
-exports.scoped = scoped;
-exports.sliding = sliding;
-exports.slidingSize = slidingSize;
-exports.some = some;
-exports.someOrElse = someOrElse;
-exports.someOrFail = someOrFail;
-exports.split = split;
-exports.splitLines = splitLines;
-exports.splitOnChunk = splitOnChunk;
-exports.succeed = succeed;
-exports.suspend = suspend;
-exports.sync = sync;
-exports.take = take;
-exports.takeRight = takeRight;
-exports.takeUntil = takeUntil;
-exports.takeUntilEffect = takeUntilEffect;
-exports.takeWhile = takeWhile;
-exports.tap = tap;
-exports.tapBoth = tapBoth;
-exports.tapError = tapError;
-exports.tapErrorCause = tapErrorCause;
-exports.tapSink = tapSink;
-exports.throttle = throttle;
-exports.throttleEffect = throttleEffect;
-exports.tick = tick;
-exports.timeout = timeout;
-exports.timeoutFail = timeoutFail;
-exports.timeoutFailCause = timeoutFailCause;
-exports.timeoutTo = timeoutTo;
-exports.toChannel = toChannel;
-exports.toHub = toHub;
-exports.toPull = toPull;
-exports.toQueue = toQueue;
-exports.toQueueOfElements = toQueueOfElements;
-exports.toReadableStream = toReadableStream;
-exports.transduce = transduce;
-exports.unfold = unfold;
-exports.unfoldChunk = unfoldChunk;
-exports.unfoldChunkEffect = unfoldChunkEffect;
-exports.unfoldEffect = unfoldEffect;
-exports.unit = unit;
-exports.unwrap = unwrap;
-exports.unwrapScoped = unwrapScoped;
-exports.updateService = updateService;
-exports.when = when;
-exports.whenCase = whenCase;
-exports.whenCaseEffect = whenCaseEffect;
-exports.whenEffect = whenEffect;
-exports.withSpan = withSpan;
-exports.zip = zip;
-exports.zipAll = zipAll;
-exports.zipAllLeft = zipAllLeft;
-exports.zipAllRight = zipAllRight;
-exports.zipAllSortedByKey = zipAllSortedByKey;
-exports.zipAllSortedByKeyLeft = zipAllSortedByKeyLeft;
-exports.zipAllSortedByKeyRight = zipAllSortedByKeyRight;
-exports.zipAllSortedByKeyWith = zipAllSortedByKeyWith;
-exports.zipAllWith = zipAllWith;
-exports.zipFlatten = zipFlatten;
-exports.zipLatest = zipLatest;
-exports.zipLatestWith = zipLatestWith;
-exports.zipLeft = zipLeft;
-exports.zipRight = zipRight;
-exports.zipWith = zipWith;
-exports.zipWithChunks = zipWithChunks;
-exports.zipWithIndex = zipWithIndex;
-exports.zipWithNext = zipWithNext;
-exports.zipWithPrevious = zipWithPrevious;
-exports.zipWithPreviousAndNext = zipWithPreviousAndNext;