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

package/internal/stream.esm.js

@@ -0,0 +1,2984 @@
+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, mapAccum as mapAccum$1, make as make$7, unsafeGet as unsafeGet$1, flatten as flatten$2, isChunk, splitAt, 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, context as context$1, 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, withSpanScoped, raceWith, zipWith as zipWith$1, forkIn, reduce as reduce$1, catchSomeCause as catchSomeCause$1, 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 { bounded as bounded$1, subscribe, shutdown as shutdown$1 } from '../Hub/dist/effect-Hub.esm.js';
+import { build, context as context$2, 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 { 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, 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 { readWithCause, flatMap as flatMap$1, fromEffect as fromEffect$1, write, failCause as failCause$1, unit as unit$1, pipeTo, 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, embedInput, sync as sync$2 } 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 => typeof u === "object" && u != null && StreamTypeId in u || isEffect(u);
+
+/** @internal */
+const DefaultChunkSize = 4096;
+
+/** @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), hub => pipe(all(Array.from({
+  length: n
+}, () => subscribe(hub))), tap$1(() => forkScoped(runIntoHubScoped(self, hub))))));
+
+/** @internal */
+const broadcastedQueuesDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => map$1(toHub(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$1());
+
+/** @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)))))), n => new StreamImpl(pipe(toChannel(self), concatMap(writeChunk), mergeMap(out => toChannel(f(out)), {
+    concurrency: n,
+    bufferSize
+  }))));
+});
+
+/** @internal */
+const matchConcurrency = (concurrency, sequential, bounded) => {
+  switch (concurrency) {
+    case undefined:
+      return sequential();
+    case "unbounded":
+      return bounded(Number.POSITIVE_INFINITY);
+    default:
+      return concurrency > 1 ? bounded(concurrency) : sequential();
+  }
+};
+const flatMapParSwitchBuffer = /*#__PURE__*/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 (isEffect(stream)) {
+    return toChannel(fromEffect(stream));
+  }
+  return stream.channel;
+};
+
+/** @internal */
+const fromChunk = chunk => new StreamImpl(isEmpty(chunk) ? unit$1 : write(chunk));
+
+/** @internal */
+const fromChunkHub = (hub, options) => {
+  if (options?.scoped) {
+    const effect = map$1(subscribe(hub), fromChunkQueue);
+    return options.shutdown ? map$1(effect, ensuring(shutdown$1(hub))) : effect;
+  }
+  const stream = flatMap(scoped(subscribe(hub)), fromChunkQueue);
+  return options?.shutdown ? ensuring(stream, shutdown$1(hub)) : 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 fromHub = (hub, options) => {
+  const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize;
+  if (options?.scoped) {
+    const effect = map$1(subscribe(hub), queue => fromQueue(queue, {
+      maxChunkSize,
+      shutdown: true
+    }));
+    return options.shutdown ? map$1(effect, ensuring(shutdown$1(hub))) : effect;
+  }
+  const stream = flatMap(scoped(subscribe(hub)), queue => fromQueue(queue, {
+    maxChunkSize
+  }));
+  return options?.shutdown ? ensuring(stream, shutdown$1(hub)) : 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 (count < maxChunkSize && !next.done) {
+        builder.push(next.value);
+        next = iterator.next();
+        count = count + 1;
+      }
+      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 => typeof error === "object" && error !== null && "_tag" in error && error._tag === "EOF" ? empty : fail(error))));
+const readChunkStreamByobReader = (reader, onError, size) => {
+  const buffer = new ArrayBuffer(size);
+  return paginateEffect(0, offset => 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)) {
+              builder.push([key, unsafeFromArray(Array.from(tuple[1]).slice(from, until))]);
+              key = updatedKey;
+              from = until;
+              loop = false;
+            }
+            until = until + 1;
+          }
+          if (loop) {
+            previousChunk = tuple[1];
+          }
+          break;
+        }
+      case "None":
+        {
+          key = f(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$2(), 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 runIntoHub = /*#__PURE__*/dual(2, (self, hub) => pipe(self, runIntoQueue(hub)));
+
+/** @internal */
+const runIntoHubScoped = /*#__PURE__*/dual(2, (self, hub) => pipe(self, runIntoQueueScoped(hub)));
+
+/** @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 toHub = /*#__PURE__*/dual(2, (self, capacity) => pipe(acquireRelease$1(bounded$1(capacity), hub => shutdown$1(hub)), tap$1(hub => pipe(self, runIntoHubScoped(hub), 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) => unwrapScoped(as$1(withSpanScoped(name, options), self)));
+
+/** @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, 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, fromChunkHub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromHub, fromIterable, fromIterableEffect, fromIteratorSucceed, 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, runIntoHub, runIntoHubScoped, 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, toHub, 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 };