effect 2.0.0-next.53 → 2.0.0-next.55

package/internal/stream.esm.js

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