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

package/dist/stream-9270c6b1.esm.js

@@ -0,0 +1,3355 @@
+import { m as map$1, g as flipCauseOption, a as failureOrCause, b as isInterrupted, d as die$2, I as IllegalArgumentException, R as RuntimeException, c as isDieType, h as isRuntimeException, s as squash } from './Cause-8be0b9a6.esm.js';
+import { D as Done, A as Await } from './ChannelMergeDecision-4488ba22.esm.js';
+import { f as fromIterable$1, o as of, e as empty$1, h as isNonEmpty, s as map$3, D as range$1, l as unsafeFromArray, E as reduceRight, p as prepend$1, i as isEmpty, A as dropWhile$1, g as filter$1, F as filterMap$1, G as filterMapWhile$1, H as findFirst, I as flatMap$3, J as takeWhile$1, K as take$3, d as drop$1, b as appendAll, w as unsafeLast, L as zipWith$2, y as reduce, c as append, C as last$1, x as splitWhere, k as head$1, M as mapAccum$1, m as make$7, u as unsafeGet$1, z as flatten$2, N as isChunk, B as splitAt, O as takeRight$1 } from './Chunk-98371336.esm.js';
+import { s as sleep, a as currentTimeMillis } from './Clock-ab907687.esm.js';
+import { b as add, u as unsafeGet } from './Context-48179faa.esm.js';
+import { m as make$4, _ as _await, s as succeed$2, f as failCause$5, p as poll, a as fail$4 } from './Deferred-554d3588.esm.js';
+import { t as toMillis, m as millis, c as greaterThan, z as zero } from './Duration-5e9f2327.esm.js';
+import { w as succeed$1, a4 as die$1, F as dieMessage$1, l as suspend$1, a5 as fail$1, a6 as mapBoth$2, a7 as mapError$1, f as failCause$2, r as map$2, k as flatMap$1, d as flatten$1, j as zipRight$1, b as as$1, N as acquireRelease$1, D as all, V as when$1, A as forkScoped, y as scope, a8 as runtime, a9 as match$1, s as sync$1, e as unit$2, aa as onError$1, J as tap$1, M as gen, ab as transplant, ac as dieSync$1, O as makeSemaphore, m as matchCauseEffect, v as forEach, c as catchAllCause$2, a1 as dropUntil$1, a2 as dropWhile$2, K as context$1, ad as failSync$1, ae as failCauseSync$1, af as findFirst$1, ag as tryPromise, ah as promise, i as isEffect, t as zip$1, X as never$1, ai as orDie$1, aj as matchEffect, x as scoped$1, Q as asUnit, n as forkDaemon, o as ensuring$2, ak as timeoutFail$1, al as timeoutFailCause$1, am as runSync, an as catchTags$1, I as tapErrorCause$1, ao as runPromise, Y as withSpanScoped, T as raceWith, z as zipWith$1, ap as forkIn, aq as reduce$1, a3 as catchSomeCause$1, ar as orElse$2, C as zipLeft$1, as as catchAll$2, at as asSome, au as succeedNone, av as fork } from './Effect-d5910dae.esm.js';
+import { b as match, l as left, r as right } from './Either-09270bbc.esm.js';
+import { e as equals } from './Equal-7d4ae7e7.esm.js';
+import { n as mapBoth$1, m as match$3, a as failCause$4, f as fail$3, c as isSuccess, s as succeed$4, u as unit$3, e as isFailure } from './Exit-e31718e3.esm.js';
+import { j as join, i as interrupt, p as poll$1 } from './Fiber-38517971.esm.js';
+import { f as constUndefined, p as pipe, d as dual, i as identity, c as constTrue } from './Function-52fb7d21.esm.js';
+import { b as bounded$1, s as subscribe, a as shutdown$1 } from './Hub-9f3d5c5d.esm.js';
+import { b as build, c as context$2, m as merge$1 } from './Layer-f7be72db.esm.js';
+import { e as fromNullable, s as some$1, n as none, b as match$2, g as getOrElse, m as map$4, i as isSome, a as isNone } from './Option-1d073850.esm.js';
+import { p as pipeArguments } from './Pipeable-fe51dc02.esm.js';
+import { t as take$2, s as shutdown, b as bounded, m as dropping, n as sliding$1, i as isShutdown, k as takeBetween, c as offerAll, o as offer$1, u as unbounded } from './Queue-bbebbeda.esm.js';
+import { m as make$3, a as modify, b as getAndSet, s as set, g as get, u as update } from './Ref-9a9de951.esm.js';
+import { r as runPromiseExit } from './Runtime-4f6fc384.esm.js';
+import { f as forever$1, d as driver, s as spaced } from './Schedule-da001b13.esm.js';
+import { m as make$6, c as close, u as use } from './Scope-0ffde3bb.esm.js';
+import { f as fromInput, B as Both } from './StreamHaltStrategy-9864a080.esm.js';
+import { a as readWithCause, f as flatMap$2, b as fromEffect$1, w as write, u as unwrap$1, c as failCause$3, z as zipRight$2, e as unit$1, p as pipeTo, g as run$1, h as pipeToOrFail, t as toChannel$1, i as collectElements, j as unwrapScoped$1, k as fail$2, r as runScoped$1, l as catchAllCause$1, m as concatMap, n as writeChunk, d as drain$1, o as readWith, s as suspend$2, q as identityChannel, v as succeedNow, x as ensuring$1, y as ensuringWith$1, A as succeed$3, B as mapOut, D as mapOutEffectPar, E as repeated, F as collectAllN, G as interruptWhen$1, H as interruptWhenDeferred$1, I as mapOutEffect, J as mapError$2, K as mapErrorCause$1, L as mergeWith$1, M as mkString$1, N as orDieWith$1, O as orElse$1, P as foldSink, Q as collectLeftover, R as zipRight$3, T as fromEffect$2, U as fail$5, V as fromChannel$1, W as provideContext$1, X as catchAll$1, Y as runDrain$1, Z as collectAll, _ as count, $ as drain$2, a0 as fold, a1 as foldEffect, a2 as forEach$1, a3 as forEachChunk, a4 as forEachWhile, a5 as head, a6 as last, a7 as sum, a8 as scoped$2, a9 as foldCauseChannel, aa as toPull$1, ab as fromInput$1, ac as embedInput, ad as mergeMap, ae as sync$2, af as writeAll } from './sink-3f26fc31.esm.js';
+import { a as BufferSliding } from './mergeStrategy-84dd9011.esm.js';
+import { m as make$5 } from './singleProducerAsyncInput-c67ef1c6.esm.js';
+import './GlobalValue-c5f1e8e5.esm.js';
+import './Effectable-a76b6aa1.esm.js';
+import './Differ-3be1df41.esm.js';
+import './timeout-4180303d.esm.js';
+import { d as done, m as match$4, c as chunk, f as failCause$6, e as end$2, a as fromPull$1, o as of$1 } from './take-7c168e8e.esm.js';
+
+/** @internal */
+class RingBuffer {
+  size = 0;
+  current = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.array = Array.from({
+      length: capacity
+    }, constUndefined);
+  }
+  head() {
+    return fromNullable(this.array[this.current]);
+  }
+  lastOrNull() {
+    if (this.size === 0) {
+      return undefined;
+    }
+    const index = this.current === 0 ? this.array.length - 1 : this.current - 1;
+    return this.array[index] ?? undefined;
+  }
+  put(value) {
+    this.array[this.current] = value;
+    this.increment();
+  }
+  dropLast() {
+    if (this.size > 0) {
+      this.decrement();
+      this.array[this.current] = undefined;
+    }
+  }
+  toChunk() {
+    const begin = this.current - this.size;
+    const newArray = begin < 0 ? [...this.array.slice(this.capacity + begin, this.capacity), ...this.array.slice(0, this.current)] : this.array.slice(begin, this.current);
+    return fromIterable$1(newArray);
+  }
+  increment() {
+    if (this.size < this.capacity) {
+      this.size += 1;
+    }
+    this.current = (this.current + 1) % this.capacity;
+  }
+  decrement() {
+    this.size -= 1;
+    if (this.current > 0) {
+      this.current -= 1;
+    } else {
+      this.current = this.capacity - 1;
+    }
+  }
+}
+
+/** @internal */
+
+/** @internal */
+const OP_NOT_STARTED = "NotStarted";
+
+/** @internal */
+
+/** @internal */
+const OP_PREVIOUS = "Previous";
+
+/** @internal */
+
+/** @internal */
+const OP_CURRENT = "Current";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const notStarted = {
+  _tag: OP_NOT_STARTED
+};
+
+/** @internal */
+const previous = fiber => ({
+  _tag: OP_PREVIOUS,
+  fiber
+});
+
+/** @internal */
+const current = fiber => ({
+  _tag: OP_CURRENT,
+  fiber
+});
+
+/** @internal */
+const make$2 = emit => {
+  const ops = {
+    chunk(as) {
+      return this(succeed$1(as));
+    },
+    die(defect) {
+      return this(die$1(defect));
+    },
+    dieMessage(message) {
+      return this(dieMessage$1(message));
+    },
+    done(exit) {
+      return this(suspend$1(() => mapBoth$1(exit, {
+        onFailure: some$1,
+        onSuccess: of
+      })));
+    },
+    end() {
+      return this(fail$1(none()));
+    },
+    fail(e) {
+      return this(fail$1(some$1(e)));
+    },
+    fromEffect(effect) {
+      return this(mapBoth$2(effect, {
+        onFailure: some$1,
+        onSuccess: of
+      }));
+    },
+    fromEffectChunk(effect) {
+      return this(pipe(effect, mapError$1(some$1)));
+    },
+    halt(cause) {
+      return this(failCause$2(pipe(cause, map$1(some$1))));
+    },
+    single(value) {
+      return this(succeed$1(of(value)));
+    }
+  };
+  return Object.assign(emit, ops);
+};
+
+/** @internal */
+const HandoffTypeId = /*#__PURE__*/Symbol.for("effect/Stream/Handoff");
+
+/** @internal */
+
+/**
+ * A synchronous queue-like abstraction that allows a producer to offer an
+ * element and wait for it to be taken, and allows a consumer to wait for an
+ * element to be available.
+ *
+ * @internal
+ */
+
+/** @internal */
+const OP_HANDOFF_STATE_EMPTY = "Empty";
+
+/** @internal */
+
+/** @internal */
+const OP_HANDOFF_STATE_FULL = "Full";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const handoffStateEmpty = notifyConsumer => ({
+  _tag: OP_HANDOFF_STATE_EMPTY,
+  notifyConsumer
+});
+
+/** @internal */
+const handoffStateFull = (value, notifyProducer) => ({
+  _tag: OP_HANDOFF_STATE_FULL,
+  value,
+  notifyProducer
+});
+
+/** @internal */
+const handoffStateMatch = (onEmpty, onFull) => {
+  return self => {
+    switch (self._tag) {
+      case OP_HANDOFF_STATE_EMPTY:
+        {
+          return onEmpty(self.notifyConsumer);
+        }
+      case OP_HANDOFF_STATE_FULL:
+        {
+          return onFull(self.value, self.notifyProducer);
+        }
+    }
+  };
+};
+
+/** @internal */
+const handoffVariance = {
+  _A: _ => _
+};
+
+/** @internal */
+const make$1 = () => pipe(make$4(), flatMap$1(deferred => make$3(handoffStateEmpty(deferred))), map$2(ref => ({
+  [HandoffTypeId]: handoffVariance,
+  ref
+})));
+
+/** @internal */
+const offer = /*#__PURE__*/dual(2, (self, value) => {
+  return flatMap$1(make$4(), deferred => flatten$1(modify(self.ref, state => pipe(state, handoffStateMatch(notifyConsumer => [zipRight$1(succeed$2(notifyConsumer, void 0), _await(deferred)), handoffStateFull(value, deferred)], (_, notifyProducer) => [flatMap$1(_await(notifyProducer), () => pipe(self, offer(value))), state])))));
+});
+
+/** @internal */
+const take$1 = self => flatMap$1(make$4(), deferred => flatten$1(modify(self.ref, state => pipe(state, handoffStateMatch(notifyConsumer => [flatMap$1(_await(notifyConsumer), () => take$1(self)), state], (value, notifyProducer) => [as$1(succeed$2(notifyProducer, void 0), value), handoffStateEmpty(deferred)])))));
+
+/** @internal */
+
+/** @internal */
+const OP_EMIT = "Emit";
+
+/** @internal */
+
+/** @internal */
+const OP_HALT = "Halt";
+
+/** @internal */
+
+/** @internal */
+const OP_END = "End";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const emit = elements => ({
+  _tag: OP_EMIT,
+  elements
+});
+
+/** @internal */
+const halt = cause => ({
+  _tag: OP_HALT,
+  cause
+});
+
+/** @internal */
+const end$1 = reason => ({
+  _tag: OP_END,
+  reason
+});
+
+/** @internal */
+const end = () => fail$1(none());
+
+/** @internal */
+const failCause$1 = cause => mapError$1(failCause$2(cause), some$1);
+
+/** @internal */
+
+/** @internal */
+const OP_SCHEDULE_END = "ScheduleEnd";
+
+/** @internal */
+
+/** @internal */
+const OP_UPSTREAM_END = "UpstreamEnd";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const ScheduleEnd = {
+  _tag: OP_SCHEDULE_END
+};
+
+/** @internal */
+const UpstreamEnd = {
+  _tag: OP_UPSTREAM_END
+};
+
+/** @internal */
+
+/** @internal */
+const OP_DRAIN_LEFT = "DrainLeft";
+
+/** @internal */
+
+/** @internal */
+const OP_DRAIN_RIGHT = "DrainRight";
+
+/** @internal */
+
+/** @internal */
+const OP_PULL_BOTH$1 = "PullBoth";
+
+/** @internal */
+
+/** @internal */
+const OP_PULL_LEFT$1 = "PullLeft";
+
+/** @internal */
+
+/** @internal */
+const OP_PULL_RIGHT$1 = "PullRight";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const DrainLeft = {
+  _tag: OP_DRAIN_LEFT
+};
+
+/** @internal */
+const DrainRight = {
+  _tag: OP_DRAIN_RIGHT
+};
+
+/** @internal */
+const PullBoth$1 = {
+  _tag: OP_PULL_BOTH$1
+};
+
+/** @internal */
+const PullLeft$1 = rightChunk => ({
+  _tag: OP_PULL_LEFT$1,
+  rightChunk
+});
+
+/** @internal */
+const PullRight$1 = leftChunk => ({
+  _tag: OP_PULL_RIGHT$1,
+  leftChunk
+});
+
+/** @internal */
+
+/** @internal */
+const OP_PULL_BOTH = "PullBoth";
+
+/** @internal */
+
+/** @internal */
+const OP_PULL_LEFT = "PullLet";
+
+/** @internal */
+
+/** @internal */
+const OP_PULL_RIGHT = "PullRight";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const PullBoth = {
+  _tag: OP_PULL_BOTH
+};
+
+/** @internal */
+const PullLeft = rightChunk => ({
+  _tag: OP_PULL_LEFT,
+  rightChunk
+});
+
+/** @internal */
+const PullRight = leftChunk => ({
+  _tag: OP_PULL_RIGHT,
+  leftChunk
+});
+
+/** @internal */
+const StreamSymbolKey = "effect/Stream";
+
+/** @internal */
+const StreamTypeId = /*#__PURE__*/Symbol.for(StreamSymbolKey);
+
+/** @internal */
+const streamVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class StreamImpl {
+  [StreamTypeId] = streamVariance;
+  constructor(channel) {
+    this.channel = channel;
+  }
+  pipe() {
+    return 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$3(ScheduleEnd), make$3(empty$1()), driver(schedule), make$3(false), make$3(false)]);
+  return pipe(fromEffect(layer), flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed, endAfterEmit]) => {
+    const handoffProducer = readWithCause({
+      onInput: input => flatMap$2(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$1(UpstreamEnd)))
+    });
+    const handoffConsumer = pipe(getAndSet(sinkLeftovers, empty$1()), flatMap$1(leftovers => {
+      if (isNonEmpty(leftovers)) {
+        return pipe(set(consumed, true), zipRight$1(succeed$1(pipe(write(leftovers), flatMap$2(() => handoffConsumer)))));
+      }
+      return pipe(take$1(handoff), map$2(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$2(bool => bool ? unit$1 : handoffConsumer));
+            }
+          case OP_HALT:
+            {
+              return failCause$3(signal.cause);
+            }
+          case OP_END:
+            {
+              if (signal.reason._tag === OP_SCHEDULE_END) {
+                return pipe(get(consumed), map$2(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$2(() => 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$2(get(sinkEndReason), reason => {
+        switch (reason._tag) {
+          case OP_SCHEDULE_END:
+            {
+              return pipe(all([get(consumed), forkSink, pipe(timeout(some$1(b)), forkIn(scope))]), map$2(([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$2(() => scheduledAggregator(sinkFiber, scheduleFiber, scope)));
+                }
+                return scheduledAggregator(sinkFiber, scheduleFiber, scope);
+              }), unwrap$1);
+            }
+          case OP_UPSTREAM_END:
+            {
+              return pipe(get(consumed), map$2(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$2(([leftovers, b]) => handleSide(leftovers, b, none()))))),
+        onOtherDone: (scheduleExit, _) => matchCauseEffect(suspend$1(() => scheduleExit), {
+          onFailure: cause => match(failureOrCause(cause), {
+            onLeft: () => pipe(handoff, offer(end$1(ScheduleEnd)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$2(([leftovers, b]) => handleSide(leftovers, b, none()))))),
+            onRight: cause => pipe(handoff, offer(halt(cause)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$2(([leftovers, b]) => handleSide(leftovers, b, none())))))
+          }),
+          onSuccess: c => pipe(handoff, offer(end$1(ScheduleEnd)), forkDaemon, zipRight$1(pipe(join(sinkFiber), map$2(([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$1(sinkFiber => pipe(forkScoped(timeout(none())), flatMap$1(scheduleFiber => pipe(scope, map$2(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$1(output => pipe(runtime(), flatMap$1(runtime => pipe(register(make$2(k => pipe(fromPull$1(k), flatMap$1(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
+  if (isFailure(exit)) {
+    if (!isInterrupted(exit.cause)) {
+      throw squash(exit.cause);
+    }
+  }
+}))), map$2(() => {
+  const loop = pipe(take$2(output), flatMap$1(done), match$1({
+    onFailure: maybeError => pipe(fromEffect$1(shutdown(output)), zipRight$2(match$2(maybeError, {
+      onNone: () => unit$1,
+      onSome: fail$2
+    }))),
+    onSuccess: chunk => pipe(write(chunk), flatMap$2(() => loop))
+  }), unwrap$1);
+  return loop;
+}))))), unwrapScoped$1, fromChannel);
+
+/** @internal */
+const asyncInterrupt = (register, outputBuffer = 16) => pipe(acquireRelease$1(bounded(outputBuffer), queue => shutdown(queue)), flatMap$1(output => pipe(runtime(), flatMap$1(runtime => pipe(sync$1(() => register(make$2(k => pipe(fromPull$1(k), flatMap$1(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
+  if (isFailure(exit)) {
+    if (!isInterrupted(exit.cause)) {
+      throw squash(exit.cause);
+    }
+  }
+})))), map$2(match({
+  onLeft: canceler => {
+    const loop = pipe(take$2(output), flatMap$1(done), match$1({
+      onFailure: maybeError => zipRight$2(fromEffect$1(shutdown(output)), match$2(maybeError, {
+        onNone: () => unit$1,
+        onSome: fail$2
+      })),
+      onSuccess: chunk => pipe(write(chunk), flatMap$2(() => 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$1(output => pipe(runtime(), flatMap$1(runtime => pipe(register(make$2(k => pipe(fromPull$1(k), flatMap$1(take => offer$1(output, take)), asUnit, runPromiseExit(runtime)).then(exit => {
+  if (isFailure(exit)) {
+    if (!isInterrupted(exit.cause)) {
+      throw squash(exit.cause);
+    }
+  }
+}))), zipRight$1(make$3(false)), flatMap$1(ref => pipe(get(ref), map$2(isDone => isDone ? end() : pipe(take$2(output), flatMap$1(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$2,
+    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$2(tuple => tuple.map(queue => flattenTake(fromQueue(queue, {
+  shutdown: true
+}))))));
+
+/** @internal */
+const broadcastDynamic = /*#__PURE__*/dual(2, (self, maximumLag) => pipe(self, broadcastedQueuesDynamic(maximumLag), map$2(effect => flattenTake(flatMap(scoped(effect), fromQueue)))));
+
+/** @internal */
+const broadcastedQueues = /*#__PURE__*/dual(3, (self, n, maximumLag) => flatMap$1(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$2(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$2(queue, queue => {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(match$3({
+      onFailure: cause => pipe(flipCauseOption(cause), match$2({
+        onNone: () => unit$1,
+        onSome: failCause$3
+      })),
+      onSuccess: value => flatMap$2(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$2(queue, queue => {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(match$4({
+      onEnd: () => unit$1,
+      onFailure: failCause$3,
+      onSuccess: value => pipe(write(value), flatMap$2(() => 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$2(queue, queue => {
+    const process = pipe(fromEffect$1(take$2(queue)), flatMap$2(match$4({
+      onEnd: () => unit$1,
+      onFailure: failCause$3,
+      onSuccess: value => flatMap$2(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$1(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$1(deferred => pipe(offer$1(queue, [chunk(input), deferred]), flatMap$1(added => pipe(set(ref, deferred), when$1(() => added))))), asUnit, fromEffect$1, flatMap$2(() => 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$2(([take, deferred]) => zipRight$2(fromEffect$1(succeed$2(deferred, void 0)), match$4(take, {
+      onEnd: () => unit$1,
+      onFailure: failCause$3,
+      onSuccess: value => pipe(write(value), flatMap$2(() => process))
+    }))));
+    return process;
+  };
+  return unwrapScoped$1(pipe(scoped, flatMap$1(queue => pipe(make$4(), tap$1(start => succeed$2(start, void 0)), flatMap$1(start => pipe(make$3(start), flatMap$1(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$2(write(newChunk), () => writer(newLast));
+    },
+    onFailure: failCause$3,
+    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$2(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$2(([newLast, newChunk]) => pipe(write(newChunk), flatMap$2(() => writer(newLast))))),
+    onFailure: failCause$3,
+    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$1(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$2(fromEffect$1(pipe(handoff, offer(succeed$4(input)))), () => producer(handoff, latch)),
+    onFailure: cause => fromEffect$1(offer(handoff, failCause$4(pipe(cause, map$1(some$1))))),
+    onDone: () => flatMap$2(fromEffect$1(offer(handoff, fail$3(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$1(exit => suspend$1(() => exit)))));
+    const pullRight = pipe(latchR, offer(void 0),
+    // TODO: remove
+    zipRight$1(pipe(take$1(right), flatMap$1(exit => suspend$1(() => exit)))));
+    return toChannel(unfoldEffect(s, s => flatMap$1(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$2(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$2(([left, right, latchL, latchR]) => {
+    const pullLeft = pipe(latchL, offer(void 0), zipRight$1(pipe(take$1(left), flatMap$1(done))));
+    const pullRight = pipe(latchR, offer(void 0), zipRight$1(pipe(take$1(right), flatMap$1(done))));
+    return toChannel(unfoldChunkEffect(s, s => flatMap$1(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$1(input => transplant(grafter => pipe(make$1(), map$2(handoff => {
+  const enqueue = last => pipe(sleep(duration), as$1(last), fork, grafter, map$2(fiber => consumer(previous(fiber))));
+  const producer = readWithCause({
+    onInput: input => match$2(last$1(input), {
+      onNone: () => producer,
+      onSome: last => flatMap$2(fromEffect$1(offer(handoff, emit(of(last)))), () => producer)
+    }),
+    onFailure: cause => fromEffect$1(offer(handoff, halt(cause))),
+    onDone: () => fromEffect$1(offer(handoff, end$1(UpstreamEnd)))
+  });
+  const consumer = state => {
+    switch (state._tag) {
+      case OP_NOT_STARTED:
+        {
+          return pipe(take$1(handoff), map$2(signal => {
+            switch (signal._tag) {
+              case OP_EMIT:
+                {
+                  return unwrap$1(enqueue(signal.elements));
+                }
+              case OP_HALT:
+                {
+                  return failCause$3(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$3(cause))),
+              onSuccess: chunk => succeed$1(pipe(write(chunk), flatMap$2(() => consumer(current(current$1)))))
+            }),
+            onOtherDone: (rightExit, previous) => match$3(rightExit, {
+              onFailure: cause => pipe(interrupt(previous), as$1(failCause$3(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$3(signal.cause)));
+                    }
+                  case OP_END:
+                    {
+                      return pipe(join(previous), map$2(chunk => pipe(write(chunk), zipRight$2(unit$1))));
+                    }
+                }
+              }
+            })
+          }));
+        }
+      case OP_CURRENT:
+        {
+          return pipe(join(state.fiber), map$2(signal => {
+            switch (signal._tag) {
+              case OP_EMIT:
+                {
+                  return unwrap$1(enqueue(signal.elements));
+                }
+              case OP_HALT:
+                {
+                  return failCause$3(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$1(deferred => pipe(self, distributedWithDynamic({
+  maximumLag: options.maximumLag,
+  decide: a => flatMap$1(_await(deferred), f => f(a))
+}), flatMap$1(next => pipe(all(map$3(range$1(0, options.size - 1), id => map$2(next, ([key, queue]) => [[key, id], queue]))), map$2(unsafeFromArray), flatMap$1(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$2(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$3(new Map()), (ref, _) => pipe(get(ref), flatMap$1(queues => pipe(queues.values(), forEach(shutdown))))), flatMap$1(queuesRef => gen(function* ($) {
+  const offer = a => pipe(decide(a), flatMap$1(shouldProcess => pipe(get(queuesRef), flatMap$1(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$2(cause),
+        onSuccess: () => succeed$1(acc)
+      }));
+    }
+    return succeed$1(acc);
+  }), flatMap$1(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$3(pipe(bounded(maximumLag), flatMap$1(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$1(queue => {
+    const id = newDistributedWithDynamicId();
+    return pipe(update(queuesRef, map => map.set(id, queue)), as$1([id, queue]));
+  }))), zipRight$1(pipe(get(queuesRef), flatMap$1(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$4(pipe(cause, map$1(some$1)))),
+    onSuccess: () => finalize(fail$3(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$5(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$2,
+    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$2(() => reader));
+      },
+      onFailure: fail$2,
+      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$2(unsafeFromArray), map$2(leftover => {
+      const more = isEmpty(leftover);
+      if (more) {
+        return suspend$2(() => loop);
+      }
+      return pipe(write(leftover), zipRight$2(identityChannel()));
+    }), unwrap$1),
+    onFailure: fail$2,
+    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$2,
+    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$2(unsafeFromArray), map$2(leftover => {
+      const more = isEmpty(leftover);
+      if (more) {
+        return suspend$2(() => loop);
+      }
+      return zipRight$2(write(leftover), identityChannel());
+    }), unwrap$1),
+    onFailure: fail$2,
+    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$1(some$1(error)));
+
+/** @internal */
+const failSync = evaluate => fromEffectOption(failSync$1(() => some$1(evaluate())));
+
+/** @internal */
+const failCause = cause => fromEffect(failCause$2(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$3,
+        onDone: succeed$3
+      });
+    } else {
+      return pipe(f(next.value), map$2(bool => bool ? pipe(write(of(next.value)), flatMap$2(() => 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$3,
+        onDone: succeed$3
+      });
+    } else {
+      return pipe(pf(next.value), match$2({
+        onNone: () => sync$1(() => loop(iterator)),
+        onSome: map$2(a2 => flatMap$2(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$2(() => loop));
+      }
+      return write(mapped);
+    },
+    onFailure: fail$2,
+    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$3,
+        onDone: succeed$3
+      });
+    } else {
+      return unwrap$1(match$2(pf(next.value), {
+        onNone: () => succeed$1(unit$1),
+        onSome: map$2(a2 => flatMap$2(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$2,
+    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$2(match$2({
+      onNone: () => loop,
+      onSome: n => write(of(n))
+    })), unwrap$1),
+    onFailure: fail$2,
+    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$3(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$2(writeChunk(chunks), () => flatten),
+    onFailure: failCause$3,
+    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$3
+        }),
+        onSuccess: () => unit$1
+      })
+    }));
+    return pipe(write(pipe(toEmit, filterMap$1(exit => isSuccess(exit) ? some$1(exit.value) : none()))), flatMap$2(() => next));
+  };
+  const process = readWithCause({
+    onInput: chunk => processChunk(chunk, process),
+    onFailure: cause => failCause$3(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$2(iterator => repeatEffectOption(pipe(tryPromise({
+  try: async () => iterator.next(),
+  catch: reason => some$1(onError(reason))
+}), flatMap$1(result => result.done ? fail$1(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$2(subscribe(hub), fromChunkQueue);
+    return options.shutdown ? map$2(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$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause$1(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$2
+  }),
+  onSuccess: a => write(of(a))
+})));
+
+/** @internal */
+const fromHub = (hub, options) => {
+  const maxChunkSize = options?.maxChunkSize ?? DefaultChunkSize;
+  if (options?.scoped) {
+    const effect = map$2(subscribe(hub), queue => fromQueue(queue, {
+      maxChunkSize,
+      shutdown: true
+    }));
+    return options.shutdown ? map$2(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$2(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$2(() => 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$2(() => loop(iterator)));
+      }
+      return unit$1;
+    }), unwrap$1);
+    return new StreamImpl(loop(iterator));
+  }), unwrap);
+};
+
+/** @internal */
+const fromPull = effect => pipe(effect, map$2(repeatEffectChunkOption), unwrapScoped);
+
+/** @internal */
+const fromQueue = (queue, options) => pipe(takeBetween(queue, 1, options?.maxChunkSize ?? DefaultChunkSize), catchAllCause$2(cause => pipe(isShutdown(queue), flatMap$1(isShutdown => isShutdown && isInterrupted(cause) ? end() : failCause$1(cause)))), repeatEffectChunkOption, options?.shutdown ? ensuring(shutdown(queue)) : identity);
+
+/** @internal */
+const fromSchedule = schedule => pipe(driver(schedule), map$2(driver => repeatEffectOption(driver.next(void 0))), unwrap);
+
+/** @internal */
+const fromReadableStream = (evaluate, onError) => unwrapScoped(map$2(acquireRelease$1(sync$1(() => evaluate().getReader()), reader => promise(() => reader.cancel())), reader => repeatEffectOption(flatMap$1(tryPromise({
+  try: () => reader.read(),
+  catch: reason => some$1(onError(reason))
+}), ({
+  done,
+  value
+}) => done ? fail$1(none()) : succeed$1(value)))));
+
+/** @internal */
+const fromReadableStreamByob = (evaluate, onError, allocSize = 4096) => unwrapScoped(map$2(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$1(tryPromise({
+    try: () => reader.read(new Uint8Array(buffer, offset, buffer.byteLength - offset)),
+    catch: reason => onError(reason)
+  }), ({
+    done,
+    value
+  }) => {
+    if (done) {
+      return fail$1({
+        _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$2(write(output), () => groupAdjacent(updatedState));
+    },
+    onFailure: cause => match$2(state, {
+      onNone: () => failCause$3(cause),
+      onSome: output => flatMap$2(write(of(output)), () => failCause$3(cause))
+    }),
+    onDone: done => match$2(state, {
+      onNone: () => succeedNow(done),
+      onSome: output => flatMap$2(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$2(match$2({
+    onNone: () => readWith({
+      onInput: input => flatMap$2(write(input), () => writer(fiber)),
+      onFailure: fail$2,
+      onDone: () => unit$1
+    }),
+    onSome: match$3({
+      onFailure: failCause$3,
+      onSuccess: () => unit$1
+    })
+  })), unwrap$1);
+  return new StreamImpl(pipe(forkScoped(effect), map$2(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$2(match$2({
+    onNone: () => readWith({
+      onInput: input => pipe(write(input), flatMap$2(() => writer)),
+      onFailure: fail$2,
+      onDone: () => unit$1
+    }),
+    onSome: effect => unwrap$1(match$1(effect, {
+      onFailure: fail$2,
+      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$2(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$2(([left, right]) => {
+    const process = (leftDone, rightDone) => readWithCause({
+      onInput: bool => {
+        if (bool && !leftDone) {
+          return pipe(fromEffect$1(take$1(left)), flatMap$2(match$4({
+            onEnd: () => rightDone ? unit$1 : process(true, rightDone),
+            onFailure: failCause$3,
+            onSuccess: chunk => pipe(write(chunk), flatMap$2(() => process(leftDone, rightDone)))
+          })));
+        }
+        if (!bool && !rightDone) {
+          return pipe(fromEffect$1(take$1(right)), flatMap$2(match$4({
+            onEnd: () => leftDone ? unit$1 : process(leftDone, true),
+            onFailure: failCause$3,
+            onSuccess: chunk => pipe(write(chunk), flatMap$2(() => process(leftDone, rightDone)))
+          })));
+        }
+        return process(leftDone, rightDone);
+      },
+      onFailure: failCause$3,
+      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$2(() => writer(flagResult)));
+    },
+    onFailure: failCause$3,
+    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$3(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$2(write(chunk), () => accumulator(nextS));
+    },
+    onFailure: fail$2,
+    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$1(([s, a]) => pipe(emit(a), as$1(s))))), match$1({
+        onFailure: error => {
+          if (outputs.length !== 0) {
+            return zipRight$2(write(unsafeFromArray(outputs)), fail$2(error));
+          }
+          return fail$2(error);
+        },
+        onSuccess: s => flatMap$2(write(unsafeFromArray(outputs)), () => accumulator(s))
+      }));
+    }), unwrap$1),
+    onFailure: fail$2,
+    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$2(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$3,
+        onDone: succeed$3
+      });
+    } else {
+      const value = next.value;
+      return unwrap$1(map$2(f(value), a2 => flatMap$2(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$2(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$2,
+    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$2(write(page[0]), () => loop(s))
+    });
+  };
+  return new StreamImpl(suspend$2(() => loop(s)));
+};
+
+/** @internal */
+const paginateChunkEffect = (s, f) => {
+  const loop = s => unwrap$1(map$2(f(s), ([chunk, option]) => match$2(option, {
+    onNone: () => zipRight$2(write(chunk), unit$1),
+    onSome: s => flatMap$2(write(chunk), () => loop(s))
+  })));
+  return new StreamImpl(suspend$2(() => loop(s)));
+};
+
+/** @internal */
+const paginateEffect = (s, f) => paginateChunkEffect(s, s => pipe(f(s), map$2(([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$1(deferred => pipe(make$1(), map$2(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$2(fromEffect$1(offer(handoff, {
+            _tag: OP_EMIT,
+            elements
+          })), () => loop),
+          onFailure: cause => zipRight$2(fromEffect$1(offer(handoff, {
+            _tag: OP_HALT,
+            cause
+          })), failCause$3(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$2(signal => {
+      switch (signal._tag) {
+        case OP_EMIT:
+          {
+            return pipe(write(signal.elements), flatMap$2(() => producer));
+          }
+        case OP_HALT:
+          {
+            return failCause$3(signal.cause);
+          }
+        case OP_END:
+          {
+            return unit$1;
+          }
+      }
+    }), unwrap$1);
+    return pipe(self, tapErrorCause(cause => failCause$5(deferred, cause)), run(consumer), forkScoped, zipRight$1(_await(deferred)), map$2(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$1(([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$2(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$2(() => 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$2(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$2(writeAll(...chunks), () => rechunkProcess(rechunker, target));
+    }
+    return suspend$2(() => rechunkProcess(rechunker, target));
+  },
+  onFailure: cause => zipRight$2(rechunker.emitIfNotEmpty(), failCause$3(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$3(die$2(f(error))),
+  onSome: fail$2
+}))));
+
+/** @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$2(effect, chunk => some$1([chunk, effect])), catchAll$2(match$2({
+  onNone: () => succeed$1(none()),
+  onSome: fail$1
+}))));
+
+/** @internal */
+const repeatEffectOption = effect => repeatEffectChunkOption(pipe(effect, map$2(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$2(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$2(() => step(input, a)))));
+      const reset = pipe(driver.last(), orDie$1, flatMap$1(b => pipe(driver.reset(), map$2(() => 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$2,
+      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$2(driver => {
+    const scheduleOutput = pipe(driver.last(), orDie$1, map$2(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$2(c => pipe(write(of(c)), flatMap$2(() => 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$2(effect, nextA => some$1([nextA, nextA]))
+}))));
+
+/** @internal */
+const retry = /*#__PURE__*/dual(2, (self, schedule) => unwrap(map$2(driver(schedule), driver => {
+  const loop = catchAll(self, error => unwrap(matchEffect(driver.next(error), {
+    onFailure: () => fail$1(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$2(fromEffect$1(offerAll(queue, map$3(input, succeed$4))), () => writer),
+    onFailure: cause => fromEffect$1(offer$1(queue, failCause$4(map$1(cause, some$1)))),
+    onDone: () => fromEffect$1(offer$1(queue, fail$3(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$2(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$2(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$3,
+        onDone: succeedNow
+      });
+    }
+    return unwrap$1(matchEffect(driver.next(next.value), {
+      onFailure: () => pipe(driver.last(), orDie$1, map$2(b => pipe(write(make$7(options.onElement(next.value), options.onSchedule(b))), flatMap$2(() => loop(driver, iterator)))), zipLeft$1(driver.reset())),
+      onSuccess: () => succeed$1(pipe(write(of(options.onElement(next.value))), flatMap$2(() => loop(driver, iterator))))
+    }));
+  };
+  return new StreamImpl(pipe(fromEffect$1(driver(schedule)), flatMap$2(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$2(() => toChannel(pipe(self, mapAccumEffect(s, (s, a) => pipe(f(s, a), map$2(s => [s, s])))))))));
+
+/** @internal */
+const scoped = effect => new StreamImpl(ensuring$1(scoped$2(pipe(effect, map$2(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$2(() => 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$2(() => channelEnd));
+    };
+    const reader = queueSize => readWithCause({
+      onInput: input => flatMap$2(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$3(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$2(() => split(empty$1(), pipe(remaining, drop$1(1)))));
+  };
+  const loop = leftovers => readWith({
+    onInput: input => split(leftovers, input),
+    onFailure: fail$2,
+    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$2(write(output), () => next(isNonEmpty(carry) ? some$1(carry) : none(), delimiterCursor));
+    },
+    onFailure: cause => match$2(leftover, {
+      onNone: () => failCause$3(cause),
+      onSome: chunk => zipRight$2(write(of(chunk)), failCause$3(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$3(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$2(write(out), () => loop);
+    },
+    onFailure: cause => stringBuilder.length === 0 ? failCause$3(cause) : flatMap$2(write(of(stringBuilder)), () => failCause$3(cause)),
+    onDone: done => stringBuilder.length === 0 ? succeed$3(done) : flatMap$2(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$2(() => loop(leftover)));
+      }
+      return write(taken);
+    },
+    onFailure: fail$2,
+    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$2(queue => {
+    const reader = readWith({
+      onInput: input => {
+        for (const element of input) {
+          queue.put(element);
+        }
+        return reader;
+      },
+      onFailure: fail$2,
+      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$2(() => loop));
+      }
+      return write(pipe(taken, appendAll(last)));
+    },
+    onFailure: fail$2,
+    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$3,
+        onDone: succeed$3
+      });
+    }
+    return pipe(predicate(next.value), map$2(bool => bool ? write(of(next.value)) : pipe(write(of(next.value)), flatMap$2(() => 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$2(() => loop));
+      }
+      return write(taken);
+    },
+    onFailure: fail$2,
+    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$1(error)))));
+
+/** @internal */
+const tapErrorCause = /*#__PURE__*/dual(2, (self, f) => {
+  const loop = readWithCause({
+    onInput: chunk => flatMap$2(write(chunk), () => loop),
+    onFailure: cause => fromEffect$1(zipRight$1(f(cause), failCause$2(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$2(write(chunk$1), () => identityChannel()),
+      onSuccess: () => flatMap$2(write(chunk$1), () => loop)
+    })),
+    onFailure: cause => pipe(fromEffect$1(offer$1(queue, failCause$6(cause))), foldCauseChannel({
+      onFailure: () => failCause$3(cause),
+      onSuccess: () => failCause$3(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$2(([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$2(() => loop(available - weight, currentTimeMillis)));
+      }
+      return loop(tokens, timestampMillis);
+    }), unwrap$1),
+    onFailure: failCause$3,
+    onDone: () => unit$1
+  });
+  const throttled = pipe(currentTimeMillis, map$2(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$2(([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$2(() => loop(remaining, currentTimeMillis)));
+      }
+      return flatMap$2(write(input), () => loop(remaining, currentTimeMillis));
+    }), unwrap$1),
+    onFailure: failCause$3,
+    onDone: () => unit$1
+  });
+  const throttled = pipe(currentTimeMillis, map$2(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$2(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$2(timeoutFailCause$1({
+  onTimeout: () => map$1(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$2(toPull$1(toChannel(self)), pull => pipe(pull, mapError$1(some$1), flatMap$1(match({
+  onLeft: () => fail$1(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$3(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$2(() => buffer)),
+          onFailure: fail$2,
+          onDone: succeedNow
+        });
+      }
+      leftovers.ref = empty$1();
+      return pipe(writeChunk(leftover), flatMap$2(() => 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$2(write(input), () => upstreamMarker),
+      onFailure: fail$2,
+      onDone: done => zipRight$2(sync$2(() => {
+        upstreamDone.ref = true;
+      }), succeedNow(done))
+    });
+    const transducer = pipe(sink, toChannel$1, collectElements, flatMap$2(([leftover, z]) => pipe(succeed$3([upstreamDone.ref, concatAndGet(leftover)]), flatMap$2(([done, newLeftovers]) => {
+      const nextChannel = done && isEmpty(newLeftovers) ? unit$1 : transducer;
+      return pipe(write(of(z)), flatMap$2(() => 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$2(write(chunk), () => loop(s))
+  });
+  return new StreamImpl(suspend$2(() => loop(s)));
+};
+
+/** @internal */
+const unfoldChunkEffect = (s, f) => suspend(() => {
+  const loop = s => unwrap$1(map$2(f(s), match$2({
+    onNone: () => unit$1,
+    onSome: ([chunk, s]) => flatMap$2(write(chunk), () => loop(s))
+  })));
+  return new StreamImpl(loop(s));
+});
+
+/** @internal */
+const unfoldEffect = (s, f) => unfoldChunkEffect(s, s => pipe(f(s), map$2(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$3,
+            onSuccess: leftChunk => succeed$4([map$3(leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])
+          }));
+        }
+      case OP_DRAIN_RIGHT:
+        {
+          return pipe(pullRight, match$1({
+            onFailure: fail$3,
+            onSuccess: rightChunk => succeed$4([map$3(rightChunk, ([k, a2]) => [k, options.onOther(a2)]), DrainRight])
+          }));
+        }
+      case OP_PULL_BOTH$1:
+        {
+          return pipe(unsome(pullLeft), zip$1(unsome(pullRight), {
+            concurrent: true
+          }), matchEffect({
+            onFailure: error => succeed$1(fail$3(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(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$3(([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$3(([k, a2]) => [k, options.onOther(a2)])), DrainRight]));
+              }
+              return succeed$1(fail$3(none()));
+            }
+          }));
+        }
+      case OP_PULL_LEFT$1:
+        {
+          return matchEffect(pullLeft, {
+            onFailure: match$2({
+              onNone: () => succeed$1(succeed$4([pipe(state.rightChunk, map$3(([k, a2]) => [k, options.onOther(a2)])), DrainRight])),
+              onSome: error => succeed$1(fail$3(some$1(error)))
+            }),
+            onSuccess: leftChunk => isEmpty(leftChunk) ? pull(PullLeft$1(state.rightChunk), pullLeft, pullRight) : succeed$1(succeed$4(merge(leftChunk, state.rightChunk)))
+          });
+        }
+      case OP_PULL_RIGHT$1:
+        {
+          return matchEffect(pullRight, {
+            onFailure: match$2({
+              onNone: () => succeed$1(succeed$4([map$3(state.leftChunk, ([k, a]) => [k, options.onSelf(a)]), DrainLeft])),
+              onSome: error => succeed$1(fail$3(some$1(error)))
+            }),
+            onSuccess: rightChunk => isEmpty(rightChunk) ? pull(PullRight$1(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$1(pipe(leftChunk, drop$1(leftIndex + 1)));
+          loop = false;
+        } else if (hasNext(rightChunk, rightIndex)) {
+          state = PullLeft$1(pipe(rightChunk, drop$1(rightIndex + 1)));
+          loop = false;
+        } else {
+          state = PullBoth$1;
+          loop = false;
+        }
+      } else if (compare < 0) {
+        builder.push([k1, options.onSelf(a)]);
+        if (hasNext(leftChunk, leftIndex)) {
+          leftIndex = leftIndex + 1;
+          leftTuple = 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$1(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$1(unsafeFromArray(leftBuilder));
+          loop = false;
+        }
+      }
+    }
+    return [unsafeFromArray(builder), state];
+  };
+  return combineChunks(self, options.other, PullBoth$1, 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$3(error)),
+            onSuccess: leftChunk => succeed$1(succeed$4([map$3(leftChunk, options.onSelf), DrainLeft]))
+          });
+        }
+      case OP_DRAIN_RIGHT:
+        {
+          return matchEffect(pullRight, {
+            onFailure: error => succeed$1(fail$3(error)),
+            onSuccess: rightChunk => succeed$1(succeed$4([map$3(rightChunk, options.onOther), DrainRight]))
+          });
+        }
+      case OP_PULL_BOTH$1:
+        {
+          return pipe(unsome(pullLeft), zip$1(unsome(pullRight), {
+            concurrent: true
+          }), matchEffect({
+            onFailure: error => succeed$1(fail$3(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, options.onBoth)));
+              }
+              if (isSome(leftOption) && isNone(rightOption)) {
+                return succeed$1(succeed$4([map$3(leftOption.value, options.onSelf), DrainLeft]));
+              }
+              if (isNone(leftOption) && isSome(rightOption)) {
+                return succeed$1(succeed$4([map$3(rightOption.value, options.onOther), DrainRight]));
+              }
+              return succeed$1(fail$3(none()));
+            }
+          }));
+        }
+      case OP_PULL_LEFT$1:
+        {
+          return matchEffect(pullLeft, {
+            onFailure: match$2({
+              onNone: () => succeed$1(succeed$4([map$3(state.rightChunk, options.onOther), DrainRight])),
+              onSome: error => succeed$1(fail$3(some$1(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, options.onBoth)));
+            }
+          });
+        }
+      case OP_PULL_RIGHT$1:
+        {
+          return matchEffect(pullRight, {
+            onFailure: match$2({
+              onNone: () => succeed$1(succeed$4([map$3(state.leftChunk, options.onSelf), DrainLeft])),
+              onSome: error => succeed$1(fail$3(some$1(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, 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$1];
+          }
+          return [output, PullRight$1(either.left)];
+        }
+      case "Right":
+        {
+          if (isEmpty(either.right)) {
+            return [output, PullBoth$1];
+          }
+          return [output, PullLeft$1(either.right)];
+        }
+    }
+  };
+  return combineChunks(self, options.other, PullBoth$1, pull);
+});
+
+/** @internal */
+const zipLatest = /*#__PURE__*/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$1(chunk => isEmpty(chunk) ? pullNonEmpty(pull) : succeed$1(chunk)));
+  return pipe(toPull(self), map$2(pullNonEmpty), zip$1(pipe(toPull(that), map$2(pullNonEmpty))), flatMap$1(([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$3([unsafeLast(l), unsafeLast(r)])), flatMap(latest => pipe(fromChunk(leftFirst ? pipe(r, map$3(a2 => f(unsafeLast(l), a2))) : pipe(l, map$3(a => f(a, unsafeLast(r))))), concat(pipe(repeatEffectOption(left), mergeEither(repeatEffectOption(right)), mapEffectSequential(match({
+    onLeft: leftChunk => pipe(modify(latest, ([_, rightLatest]) => [pipe(leftChunk, map$3(a => f(a, rightLatest))), [unsafeLast(leftChunk), rightLatest]])),
+    onRight: rightChunk => pipe(modify(latest, ([leftLatest, _]) => [pipe(rightChunk, map$3(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:
+        {
+          return pipe(unsome(pullLeft), zip$1(unsome(pullRight), {
+            concurrent: true
+          }), matchEffect({
+            onFailure: error => succeed$1(fail$3(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)));
+              }
+              return succeed$1(fail$3(none()));
+            }
+          }));
+        }
+      case OP_PULL_LEFT:
+        {
+          return matchEffect(pullLeft, {
+            onFailure: error => succeed$1(fail$3(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)));
+            }
+          });
+        }
+      case OP_PULL_RIGHT:
+        {
+          return matchEffect(pullRight, {
+            onFailure: error => succeed$1(fail$3(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)));
+            }
+          });
+        }
+    }
+  };
+  const zip = (leftChunk, rightChunk) => {
+    const [output, either] = f(leftChunk, rightChunk);
+    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 pipe(self, combineChunks(that, PullBoth, 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$2(write(output), () => process(newLast));
+    },
+    onFailure: failCause$3,
+    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 { empty as $, chunksWith as A, combine as B, combineChunks as C, DefaultChunkSize as D, concat as E, concatAll as F, cross as G, crossLeft as H, crossRight as I, crossWith as J, debounce as K, die as L, dieSync as M, dieMessage as N, distributedWith as O, distributedWithDynamic as P, drain as Q, drainFork as R, StreamTypeId as S, drop as T, dropRight as U, dropUntil as V, dropUntilEffect as W, dropWhile as X, dropWhileEffect as Y, either as Z, _async as _, acquireRelease as a, mapAccum as a$, ensuring as a0, ensuringWith as a1, context as a2, contextWith as a3, contextWithEffect as a4, contextWithStream as a5, execute as a6, fail as a7, failSync as a8, failCause as a9, fromEffectOption as aA, fromHub as aB, fromIterable as aC, fromIterableEffect as aD, fromIteratorSucceed as aE, fromPull as aF, fromQueue as aG, fromReadableStream as aH, fromReadableStreamByob as aI, fromSchedule as aJ, groupAdjacentBy as aK, grouped as aL, groupedWithin as aM, haltAfter as aN, haltWhen as aO, haltWhenDeferred as aP, identityStream as aQ, interleave as aR, interleaveWith as aS, intersperse as aT, intersperseAffixes as aU, interruptAfter as aV, interruptWhen as aW, interruptWhenDeferred as aX, iterate as aY, make as aZ, map as a_, failCauseSync as aa, filter as ab, filterEffect as ac, filterMap as ad, filterMapEffect as ae, filterMapWhile as af, filterMapWhileEffect as ag, finalizer as ah, find as ai, findEffect as aj, flatMap as ak, flatten as al, flattenChunks as am, flattenEffect as an, flattenExitOption as ao, flattenIterables as ap, flattenTake as aq, forever as ar, fromAsyncIterable as as, fromChannel as at, toChannel as au, fromChunk as av, fromChunkHub as aw, fromChunkQueue as ax, fromChunks as ay, fromEffect as az, aggregate as b, run as b$, mapAccumEffect as b0, mapBoth as b1, mapChunks as b2, mapChunksEffect as b3, mapConcat as b4, mapConcatChunk as b5, mapConcatChunkEffect as b6, mapConcatEffect as b7, mapError as b8, mapErrorCause as b9, pipeThrough as bA, pipeThroughChannel as bB, pipeThroughChannelOrFail as bC, prepend as bD, provideContext as bE, provideLayer as bF, provideService as bG, provideServiceEffect as bH, provideServiceStream as bI, mapInputContext as bJ, provideSomeLayer as bK, range as bL, rechunk as bM, refineOrDie as bN, refineOrDieWith as bO, repeat as bP, repeatEffect as bQ, repeatEffectChunk as bR, repeatEffectChunkOption as bS, repeatEffectOption as bT, repeatEffectWithSchedule as bU, repeatEither as bV, repeatElements as bW, repeatElementsWith as bX, repeatValue as bY, repeatWith as bZ, retry as b_, merge as ba, mergeAll as bb, mergeWith as bc, mergeEither as bd, mergeLeft as be, mergeRight as bf, mkString as bg, never as bh, onError as bi, onDone as bj, orDie as bk, orDieWith as bl, orElse as bm, orElseEither as bn, orElseFail as bo, orElseIfEmpty as bp, orElseIfEmptyChunk as bq, orElseIfEmptyStream as br, orElseSucceed as bs, paginate as bt, paginateChunk as bu, paginateChunkEffect as bv, paginateEffect as bw, partition as bx, partitionEither as by, peel as bz, aggregateWithin as c, toQueue as c$, runCollect as c0, runCount as c1, runDrain as c2, runFold as c3, runFoldEffect as c4, runFoldScoped as c5, runFoldScopedEffect as c6, runFoldWhile as c7, runFoldWhileEffect as c8, runFoldWhileScoped as c9, someOrElse as cA, someOrFail as cB, split as cC, splitOnChunk as cD, splitLines as cE, succeed as cF, sync as cG, suspend as cH, take as cI, takeRight as cJ, takeUntil as cK, takeUntilEffect as cL, takeWhile as cM, tap as cN, tapBoth as cO, tapError as cP, tapErrorCause as cQ, tapSink as cR, throttle as cS, throttleEffect as cT, tick as cU, timeout as cV, timeoutFail as cW, timeoutFailCause as cX, timeoutTo as cY, toHub as cZ, toPull as c_, runFoldWhileScopedEffect as ca, runForEach as cb, runForEachChunk as cc, runForEachChunkScoped as cd, runForEachScoped as ce, runForEachWhile as cf, runForEachWhileScoped as cg, runHead as ch, runIntoHub as ci, runIntoHubScoped as cj, runIntoQueue as ck, runIntoQueueElementsScoped as cl, runIntoQueueScoped as cm, runLast as cn, runScoped as co, runSum as cp, scan as cq, scanEffect as cr, scanReduce as cs, scanReduceEffect as ct, schedule as cu, scheduleWith as cv, scoped as cw, sliding as cx, slidingSize as cy, some as cz, aggregateWithinEither as d, toQueueOfElements as d0, toReadableStream as d1, transduce as d2, unfold as d3, unfoldChunk as d4, unfoldChunkEffect as d5, unfoldEffect as d6, unit as d7, unwrap as d8, unwrapScoped as d9, zipWithIndex as dA, Do as dB, bind as dC, bindTo as dD, let_ as dE, decodeText as dF, encodeText as dG, mapEffectSequential as dH, distributedWithDynamicCallback as dI, matchConcurrency as dJ, mapEffectPar as dK, channelToStream as dL, updateService as da, when as db, whenCase as dc, whenCaseEffect as dd, whenEffect as de, withSpan as df, zip as dg, zipFlatten as dh, zipAll as di, zipAllLeft as dj, zipAllRight as dk, zipAllSortedByKey as dl, zipAllSortedByKeyLeft as dm, zipAllSortedByKeyRight as dn, zipAllSortedByKeyWith as dp, zipAllWith as dq, zipLatest as dr, zipLatestWith as ds, zipLeft as dt, zipRight as du, zipWith as dv, zipWithChunks as dw, zipWithNext as dx, zipWithPrevious as dy, zipWithPreviousAndNext as dz, as as e, asyncEffect as f, asyncInterrupt as g, asyncOption as h, asyncScoped as i, branchAfter as j, broadcast as k, broadcastDynamic as l, broadcastedQueues as m, broadcastedQueuesDynamic as n, buffer as o, bufferChunks as p, catchAll as q, catchAllCause as r, catchSome as s, catchTag as t, catchTags as u, catchSomeCause as v, changes as w, changesWith as x, changesWithEffect as y, chunks as z };