effect 2.0.0-next.4 → 2.0.0-next.41

package/Stream/dist/effect-Stream.esm.js

@@ -0,0 +1,2879 @@
+import { groupBy as groupBy$1, groupByKey as groupByKey$1, mapEffectOptions, bindEffect as bindEffect$1 } from '../../internal/groupBy.esm.js';
+import { StreamTypeId as StreamTypeId$1, DefaultChunkSize as DefaultChunkSize$1, acquireRelease as acquireRelease$1, aggregate as aggregate$1, aggregateWithin as aggregateWithin$1, aggregateWithinEither as aggregateWithinEither$1, as as as$1, _async as _async$1, asyncEffect as asyncEffect$1, asyncInterrupt as asyncInterrupt$1, asyncOption as asyncOption$1, asyncScoped as asyncScoped$1, branchAfter as branchAfter$1, broadcast as broadcast$1, broadcastDynamic as broadcastDynamic$1, broadcastedQueues as broadcastedQueues$1, broadcastedQueuesDynamic as broadcastedQueuesDynamic$1, buffer as buffer$1, bufferChunks as bufferChunks$1, catchAll as catchAll$1, catchAllCause as catchAllCause$1, catchSome as catchSome$1, catchTag as catchTag$1, catchTags as catchTags$1, catchSomeCause as catchSomeCause$1, changes as changes$1, changesWith as changesWith$1, changesWithEffect as changesWithEffect$1, chunks as chunks$1, chunksWith as chunksWith$1, combine as combine$1, combineChunks as combineChunks$1, concat as concat$1, concatAll as concatAll$1, cross as cross$1, crossLeft as crossLeft$1, crossRight as crossRight$1, crossWith as crossWith$1, debounce as debounce$1, die as die$1, dieSync as dieSync$1, dieMessage as dieMessage$1, distributedWith as distributedWith$1, distributedWithDynamic as distributedWithDynamic$1, drain as drain$1, drainFork as drainFork$1, drop as drop$1, dropRight as dropRight$1, dropUntil as dropUntil$1, dropUntilEffect as dropUntilEffect$1, dropWhile as dropWhile$1, dropWhileEffect as dropWhileEffect$1, either as either$1, empty as empty$1, ensuring as ensuring$1, ensuringWith as ensuringWith$1, context as context$1, contextWith as contextWith$1, contextWithEffect as contextWithEffect$1, contextWithStream as contextWithStream$1, execute as execute$1, fail as fail$1, failSync as failSync$1, failCause as failCause$1, failCauseSync as failCauseSync$1, filter as filter$1, filterEffect as filterEffect$1, filterMap as filterMap$1, filterMapEffect as filterMapEffect$1, filterMapWhile as filterMapWhile$1, filterMapWhileEffect as filterMapWhileEffect$1, finalizer as finalizer$1, find as find$1, findEffect as findEffect$1, flatMap as flatMap$1, flatten as flatten$1, flattenChunks as flattenChunks$1, flattenEffect as flattenEffect$1, flattenExitOption as flattenExitOption$1, flattenIterables as flattenIterables$1, flattenTake as flattenTake$1, forever as forever$1, fromAsyncIterable as fromAsyncIterable$1, fromChannel as fromChannel$1, toChannel as toChannel$1, fromChunk as fromChunk$1, fromChunkHub as fromChunkHub$1, fromChunkQueue as fromChunkQueue$1, fromChunks as fromChunks$1, fromEffect as fromEffect$1, fromEffectOption as fromEffectOption$1, fromHub as fromHub$1, fromIterable as fromIterable$1, fromIterableEffect as fromIterableEffect$1, fromIteratorSucceed as fromIteratorSucceed$1, fromPull as fromPull$1, fromQueue as fromQueue$1, fromReadableStream as fromReadableStream$1, fromReadableStreamByob as fromReadableStreamByob$1, fromSchedule as fromSchedule$1, groupAdjacentBy as groupAdjacentBy$1, grouped as grouped$1, groupedWithin as groupedWithin$1, haltAfter as haltAfter$1, haltWhen as haltWhen$1, haltWhenDeferred as haltWhenDeferred$1, identityStream, interleave as interleave$1, interleaveWith as interleaveWith$1, intersperse as intersperse$1, intersperseAffixes as intersperseAffixes$1, interruptAfter as interruptAfter$1, interruptWhen as interruptWhen$1, interruptWhenDeferred as interruptWhenDeferred$1, iterate as iterate$1, make as make$1, map as map$1, mapAccum as mapAccum$1, mapAccumEffect as mapAccumEffect$1, mapBoth as mapBoth$1, mapChunks as mapChunks$1, mapChunksEffect as mapChunksEffect$1, mapConcat as mapConcat$1, mapConcatChunk as mapConcatChunk$1, mapConcatChunkEffect as mapConcatChunkEffect$1, mapConcatEffect as mapConcatEffect$1, mapError as mapError$1, mapErrorCause as mapErrorCause$1, merge as merge$1, mergeAll as mergeAll$1, mergeWith as mergeWith$1, mergeEither as mergeEither$1, mergeLeft as mergeLeft$1, mergeRight as mergeRight$1, mkString as mkString$1, never as never$1, onError as onError$1, onDone as onDone$1, orDie as orDie$1, orDieWith as orDieWith$1, orElse as orElse$1, orElseEither as orElseEither$1, orElseFail as orElseFail$1, orElseIfEmpty as orElseIfEmpty$1, orElseIfEmptyChunk as orElseIfEmptyChunk$1, orElseIfEmptyStream as orElseIfEmptyStream$1, orElseSucceed as orElseSucceed$1, paginate as paginate$1, paginateChunk as paginateChunk$1, paginateChunkEffect as paginateChunkEffect$1, paginateEffect as paginateEffect$1, partition as partition$1, partitionEither as partitionEither$1, peel as peel$1, pipeThrough as pipeThrough$1, pipeThroughChannel as pipeThroughChannel$1, pipeThroughChannelOrFail as pipeThroughChannelOrFail$1, prepend as prepend$1, provideContext as provideContext$1, provideLayer as provideLayer$1, provideService as provideService$1, provideServiceEffect as provideServiceEffect$1, provideServiceStream as provideServiceStream$1, mapInputContext as mapInputContext$1, provideSomeLayer as provideSomeLayer$1, range as range$1, rechunk as rechunk$1, refineOrDie as refineOrDie$1, refineOrDieWith as refineOrDieWith$1, repeat as repeat$1, repeatEffect as repeatEffect$1, repeatEffectChunk as repeatEffectChunk$1, repeatEffectChunkOption as repeatEffectChunkOption$1, repeatEffectOption as repeatEffectOption$1, repeatEffectWithSchedule as repeatEffectWithSchedule$1, repeatEither as repeatEither$1, repeatElements as repeatElements$1, repeatElementsWith as repeatElementsWith$1, repeatValue as repeatValue$1, repeatWith as repeatWith$1, retry as retry$1, run as run$1, runCollect as runCollect$1, runCount as runCount$1, runDrain as runDrain$1, runFold as runFold$1, runFoldEffect as runFoldEffect$1, runFoldScoped as runFoldScoped$1, runFoldScopedEffect as runFoldScopedEffect$1, runFoldWhile as runFoldWhile$1, runFoldWhileEffect as runFoldWhileEffect$1, runFoldWhileScoped as runFoldWhileScoped$1, runFoldWhileScopedEffect as runFoldWhileScopedEffect$1, runForEach as runForEach$1, runForEachChunk as runForEachChunk$1, runForEachChunkScoped as runForEachChunkScoped$1, runForEachScoped as runForEachScoped$1, runForEachWhile as runForEachWhile$1, runForEachWhileScoped as runForEachWhileScoped$1, runHead as runHead$1, runIntoHub as runIntoHub$1, runIntoHubScoped as runIntoHubScoped$1, runIntoQueue as runIntoQueue$1, runIntoQueueElementsScoped as runIntoQueueElementsScoped$1, runIntoQueueScoped as runIntoQueueScoped$1, runLast as runLast$1, runScoped as runScoped$1, runSum as runSum$1, scan as scan$1, scanEffect as scanEffect$1, scanReduce as scanReduce$1, scanReduceEffect as scanReduceEffect$1, schedule as schedule$1, scheduleWith as scheduleWith$1, scoped as scoped$1, sliding as sliding$1, slidingSize as slidingSize$1, some as some$1, someOrElse as someOrElse$1, someOrFail as someOrFail$1, split as split$1, splitOnChunk as splitOnChunk$1, splitLines as splitLines$1, succeed as succeed$1, sync as sync$1, suspend as suspend$1, take as take$1, takeRight as takeRight$1, takeUntil as takeUntil$1, takeUntilEffect as takeUntilEffect$1, takeWhile as takeWhile$1, tap as tap$1, tapBoth as tapBoth$1, tapError as tapError$1, tapErrorCause as tapErrorCause$1, tapSink as tapSink$1, throttle as throttle$1, throttleEffect as throttleEffect$1, tick as tick$1, timeout as timeout$1, timeoutFail as timeoutFail$1, timeoutFailCause as timeoutFailCause$1, timeoutTo as timeoutTo$1, toHub as toHub$1, toPull as toPull$1, toQueue as toQueue$1, toQueueOfElements as toQueueOfElements$1, toReadableStream as toReadableStream$1, transduce as transduce$1, unfold as unfold$1, unfoldChunk as unfoldChunk$1, unfoldChunkEffect as unfoldChunkEffect$1, unfoldEffect as unfoldEffect$1, unit as unit$1, unwrap as unwrap$1, unwrapScoped as unwrapScoped$1, updateService as updateService$1, when as when$1, whenCase as whenCase$1, whenCaseEffect as whenCaseEffect$1, whenEffect as whenEffect$1, withSpan as withSpan$1, zip as zip$1, zipFlatten as zipFlatten$1, zipAll as zipAll$1, zipAllLeft as zipAllLeft$1, zipAllRight as zipAllRight$1, zipAllSortedByKey as zipAllSortedByKey$1, zipAllSortedByKeyLeft as zipAllSortedByKeyLeft$1, zipAllSortedByKeyRight as zipAllSortedByKeyRight$1, zipAllSortedByKeyWith as zipAllSortedByKeyWith$1, zipAllWith as zipAllWith$1, zipLatest as zipLatest$1, zipLatestWith as zipLatestWith$1, zipLeft as zipLeft$1, zipRight as zipRight$1, zipWith as zipWith$1, zipWithChunks as zipWithChunks$1, zipWithNext as zipWithNext$1, zipWithPrevious as zipWithPrevious$1, zipWithPreviousAndNext as zipWithPreviousAndNext$1, zipWithIndex as zipWithIndex$1, Do as Do$1, bind as bind$1, bindTo as bindTo$1, let_ as let_$1, decodeText as decodeText$1, encodeText as encodeText$1 } from '../../internal/stream.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const StreamTypeId = StreamTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Stream<R, E, A>` is a description of a program that, when evaluated, may
+ * emit zero or more values of type `A`, may fail with errors of type `E`, and
+ * uses an context of type `R`. One way to think of `Stream` is as a
+ * `Effect` program that could emit multiple values.
+ *
+ * `Stream` is a purely functional *pull* based stream. Pull based streams offer
+ * inherent laziness and backpressure, relieving users of the need to manage
+ * buffers between operators. As an optimization, `Stream` does not emit
+ * single values, but rather an array of values. This allows the cost of effect
+ * evaluation to be amortized.
+ *
+ * `Stream` forms a monad on its `A` type parameter, and has error management
+ * facilities for its `E` type parameter, modeled similarly to `Effect` (with
+ * some adjustments for the multiple-valued nature of `Stream`). These aspects
+ * allow for rich and expressive composition of streams.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * The default chunk size used by the various combinators and constructors of
+ * `Stream`.
+ *
+ * @since 2.0.0
+ * @category constants
+ */
+const DefaultChunkSize = DefaultChunkSize$1;
+
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireRelease = acquireRelease$1;
+
+/**
+ * Aggregates elements of this stream using the provided sink for as long as
+ * the downstream operators on the stream are busy.
+ *
+ * This operator divides the stream into two asynchronous "islands". Operators
+ * upstream of this operator run on one fiber, while downstream operators run
+ * on another. Whenever the downstream fiber is busy processing elements, the
+ * upstream fiber will feed elements into the sink until it signals
+ * completion.
+ *
+ * Any sink can be used here, but see `Sink.foldWeightedEffect` and
+ * `Sink.foldUntilEffect` for sinks that cover the common usecases.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const aggregate = aggregate$1;
+
+/**
+ * Like `aggregateWithinEither`, but only returns the `Right` results.
+ *
+ * @param sink A `Sink` used to perform the aggregation.
+ * @param schedule A `Schedule` used to signal when to stop the aggregation.
+ * @since 2.0.0
+ * @category utils
+ */
+const aggregateWithin = aggregateWithin$1;
+
+/**
+ * Aggregates elements using the provided sink until it completes, or until
+ * the delay signalled by the schedule has passed.
+ *
+ * This operator divides the stream into two asynchronous islands. Operators
+ * upstream of this operator run on one fiber, while downstream operators run
+ * on another. Elements will be aggregated by the sink until the downstream
+ * fiber pulls the aggregated value, or until the schedule's delay has passed.
+ *
+ * Aggregated elements will be fed into the schedule to determine the delays
+ * between pulls.
+ *
+ * @param sink A `Sink` used to perform the aggregation.
+ * @param schedule A `Schedule` used to signal when to stop the aggregation.
+ * @since 2.0.0
+ * @category utils
+ */
+const aggregateWithinEither = aggregateWithinEither$1;
+
+/**
+ * Maps the success values of this stream to the specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = as$1;
+const _async = _async$1;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times The registration of the callback itself returns an effect. The
+ * optionality of the error type `E` can be used to signal the end of the
+ * stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncEffect = asyncEffect$1;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback returns either a canceler or
+ * synchronously returns a stream. The optionality of the error type `E` can
+ * be used to signal the end of the stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncInterrupt = asyncInterrupt$1;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback can possibly return the stream
+ * synchronously. The optionality of the error type `E` can be used to signal
+ * the end of the stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncOption = asyncOption$1;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback itself returns an a scoped
+ * resource. The optionality of the error type `E` can be used to signal the
+ * end of the stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncScoped = asyncScoped$1;
+
+/**
+ * Returns a `Stream` that first collects `n` elements from the input `Stream`,
+ * and then creates a new `Stream` using the specified function, and sends all
+ * the following elements through that.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const branchAfter = branchAfter$1;
+
+/**
+ * Fan out the stream, producing a list of streams that have the same elements
+ * as this stream. The driver stream will only ever advance the `maximumLag`
+ * chunks before the slowest downstream stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcast = broadcast$1;
+
+/**
+ * Fan out the stream, producing a dynamic number of streams that have the
+ * same elements as this stream. The driver stream will only ever advance the
+ * `maximumLag` chunks before the slowest downstream stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcastDynamic = broadcastDynamic$1;
+
+/**
+ * Converts the stream to a scoped list of queues. Every value will be
+ * replicated to every queue with the slowest queue being allowed to buffer
+ * `maximumLag` chunks before the driver is back pressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcastedQueues = broadcastedQueues$1;
+
+/**
+ * Converts the stream to a scoped dynamic amount of queues. Every chunk will
+ * be replicated to every queue with the slowest queue being allowed to buffer
+ * `maximumLag` chunks before the driver is back pressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcastedQueuesDynamic = broadcastedQueuesDynamic$1;
+
+/**
+ * Allows a faster producer to progress independently of a slower consumer by
+ * buffering up to `capacity` elements in a queue.
+ *
+ * @note This combinator destroys the chunking structure. It's recommended to
+ *       use rechunk afterwards. Additionally, prefer capacities that are powers
+ *       of 2 for better performance.
+ * @since 2.0.0
+ * @category utils
+ */
+const buffer = buffer$1;
+
+/**
+ * Allows a faster producer to progress independently of a slower consumer by
+ * buffering up to `capacity` chunks in a queue.
+ *
+ * @note Prefer capacities that are powers of 2 for better performance.
+ * @since 2.0.0
+ * @category utils
+ */
+const bufferChunks = bufferChunks$1;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with a typed error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = catchAll$1;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails. Allows recovery from all causes of failure, including
+ * interruption if the stream is uninterruptible.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAllCause = catchAllCause$1;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with some typed error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSome = catchSome$1;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with an error matching the given `_tag`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTag = catchTag$1;
+
+/**
+ * Switches over to the stream produced by one of the provided functions, in
+ * case this one fails with an error matching one of the given `_tag`'s.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTags = catchTags$1;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with some errors. Allows recovery from all causes of failure,
+ * including interruption if the stream is uninterruptible.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSomeCause = catchSomeCause$1;
+
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using natural equality to determine whether two
+ * elements are equal.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const changes = changes$1;
+
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified function to determine whether
+ * two elements are equal.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const changesWith = changesWith$1;
+
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified effectual function to
+ * determine whether two elements are equal.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const changesWithEffect = changesWithEffect$1;
+
+/**
+ * Exposes the underlying chunks of the stream as a stream of chunks of
+ * elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const chunks = chunks$1;
+
+/**
+ * Performs the specified stream transformation with the chunk structure of
+ * the stream exposed.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const chunksWith = chunksWith$1;
+
+/**
+ * Combines the elements from this stream and the specified stream by
+ * repeatedly applying the function `f` to extract an element using both sides
+ * and conceptually "offer" it to the destination stream. `f` can maintain
+ * some internal state to control the combining process, with the initial
+ * state being specified by `s`.
+ *
+ * Where possible, prefer `Stream.combineChunks` for a more efficient
+ * implementation.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const combine = combine$1;
+
+/**
+ * Combines the chunks from this stream and the specified stream by repeatedly
+ * applying the function `f` to extract a chunk using both sides and
+ * conceptually "offer" it to the destination stream. `f` can maintain some
+ * internal state to control the combining process, with the initial state
+ * being specified by `s`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const combineChunks = combineChunks$1;
+
+/**
+ * Concatenates the specified stream with this stream, resulting in a stream
+ * that emits the elements from this stream and then the elements from the
+ * specified stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const concat = concat$1;
+
+/**
+ * Concatenates all of the streams in the chunk to one stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const concatAll = concatAll$1;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements. The `that` stream would be run multiple times, for
+ * every element in the `this` stream.
+ *
+ * See also `Stream.zip` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const cross = cross$1;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements, but keeps only elements from this stream. The `that`
+ * stream would be run multiple times, for every element in the `this` stream.
+ *
+ * See also `Stream.zipLeft` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const crossLeft = crossLeft$1;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements, but keeps only elements from the other stream. The
+ * `that` stream would be run multiple times, for every element in the `this`
+ * stream.
+ *
+ * See also `Stream.zipRight` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const crossRight = crossRight$1;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements with a specified function. The `that` stream would be
+ * run multiple times, for every element in the `this` stream.
+ *
+ * See also `Stream.zipWith` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const crossWith = crossWith$1;
+
+/**
+ * Delays the emission of values by holding new values for a set duration. If
+ * no new values arrive during that time the value is emitted, however if a
+ * new value is received during the holding period the previous value is
+ * discarded and the process is repeated with the new value.
+ *
+ * This operator is useful if you have a stream of "bursty" events which
+ * eventually settle down and you only need the final event of the burst. For
+ * example, a search engine may only want to initiate a search after a user
+ * has paused typing so as to not prematurely recommend results.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const debounce = debounce$1;
+
+/**
+ * The stream that dies with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = die$1;
+
+/**
+ * The stream that dies with the specified lazily evaluated defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = dieSync$1;
+
+/**
+ * The stream that dies with an exception described by `message`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = dieMessage$1;
+
+/**
+ * More powerful version of `Stream.broadcast`. Allows to provide a function
+ * that determines what queues should receive which elements. The decide
+ * function will receive the indices of the queues in the resulting list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const distributedWith = distributedWith$1;
+
+/**
+ * More powerful version of `Stream.distributedWith`. This returns a function
+ * that will produce new queues and corresponding indices. You can also
+ * provide a function that will be executed after the final events are
+ * enqueued in all queues. Shutdown of the queues is handled by the driver.
+ * Downstream users can also shutdown queues manually. In this case the driver
+ * will continue but no longer backpressure on them.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const distributedWithDynamic = distributedWithDynamic$1;
+
+/**
+ * Converts this stream to a stream that executes its effects but emits no
+ * elements. Useful for sequencing effects using streams:
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drain = drain$1;
+
+/**
+ * Drains the provided stream in the background for as long as this stream is
+ * running. If this stream ends before `other`, `other` will be interrupted.
+ * If `other` fails, this stream will fail with that error.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drainFork = drainFork$1;
+
+/**
+ * Drops the specified number of elements from this stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drop = drop$1;
+
+/**
+ * Drops the last specified number of elements from this stream.
+ *
+ * @note This combinator keeps `n` elements in memory. Be careful with big
+ *       numbers.
+ * @since 2.0.0
+ * @category utils
+ */
+const dropRight = dropRight$1;
+
+/**
+ * Drops all elements of the stream until the specified predicate evaluates to
+ * `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropUntil = dropUntil$1;
+
+/**
+ * Drops all elements of the stream until the specified effectful predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropUntilEffect = dropUntilEffect$1;
+
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropWhile = dropWhile$1;
+
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * produces an effect that evalutates to `true`
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropWhileEffect = dropWhileEffect$1;
+
+/**
+ * Returns a stream whose failures and successes have been lifted into an
+ * `Either`. The resulting stream cannot fail, because the failures have been
+ * exposed as part of the `Either` success case.
+ *
+ * @note The stream will end as soon as the first error occurs.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const either = either$1;
+
+/**
+ * The empty stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = empty$1;
+
+/**
+ * Executes the provided finalizer after this stream's finalizers run.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ensuring = ensuring$1;
+
+/**
+ * Executes the provided finalizer after this stream's finalizers run.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ensuringWith = ensuringWith$1;
+
+/**
+ * Accesses the whole context of the stream.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const context = context$1;
+
+/**
+ * Accesses the context of the stream.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWith = contextWith$1;
+
+/**
+ * Accesses the context of the stream in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithEffect = contextWithEffect$1;
+
+/**
+ * Accesses the context of the stream in the context of a stream.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithStream = contextWithStream$1;
+
+/**
+ * Creates a stream that executes the specified effect but emits no elements.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const execute = execute$1;
+
+/**
+ * Terminates with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * Terminates with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = failSync$1;
+
+/**
+ * The stream that always fails with the specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = failCause$1;
+
+/**
+ * The stream that always fails with the specified lazily evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = failCauseSync$1;
+
+/**
+ * Filters the elements emitted by this stream using the provided function.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filter = filter$1;
+
+/**
+ * Effectfully filters the elements emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterEffect = filterEffect$1;
+
+/**
+ * Performs a filter and map in a single step.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMap = filterMap$1;
+
+/**
+ * Performs an effectful filter and map in a single step.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMapEffect = filterMapEffect$1;
+
+/**
+ * Transforms all elements of the stream for as long as the specified partial
+ * function is defined.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMapWhile = filterMapWhile$1;
+
+/**
+ * Effectfully transforms all elements of the stream for as long as the
+ * specified partial function is defined.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMapWhileEffect = filterMapWhileEffect$1;
+
+/**
+ * Creates a one-element stream that never fails and executes the finalizer
+ * when it ends.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const finalizer = finalizer$1;
+
+/**
+ * Finds the first element emitted by this stream that satisfies the provided
+ * predicate.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const find = find$1;
+
+/**
+ * Finds the first element emitted by this stream that satisfies the provided
+ * effectful predicate.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const findEffect = findEffect$1;
+
+/**
+ * Returns a stream made of the concatenation in strict order of all the
+ * streams produced by passing each element of this stream to `f0`
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = flatMap$1;
+
+/**
+ * Flattens this stream-of-streams into a stream made of the concatenation in
+ * strict order of all the streams.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = flatten$1;
+
+/**
+ * Submerges the chunks carried by this stream into the stream's structure,
+ * while still preserving them.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenChunks = flattenChunks$1;
+
+/**
+ * Flattens `Effect` values into the stream's structure, preserving all
+ * information about the effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenEffect = flattenEffect$1;
+
+/**
+ * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
+ *
+ * For `Exit` values that do not signal end-of-stream, prefer:
+ *
+ * ```ts
+ * stream.mapZIO(ZIO.done(_))
+ * ```
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenExitOption = flattenExitOption$1;
+
+/**
+ * Submerges the iterables carried by this stream into the stream's structure,
+ * while still preserving them.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenIterables = flattenIterables$1;
+
+/**
+ * Unwraps `Exit` values and flatten chunks that also signify end-of-stream
+ * by failing with `None`.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenTake = flattenTake$1;
+
+/**
+ * Repeats this stream forever.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const forever = forever$1;
+
+/**
+ * Creates a stream from an `AsyncIterable`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromAsyncIterable = fromAsyncIterable$1;
+
+/**
+ * Creates a stream from a `Channel`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChannel = fromChannel$1;
+
+/**
+ * Creates a channel from a `Stream`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const toChannel = toChannel$1;
+
+/**
+ * Creates a stream from a `Chunk` of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunk = fromChunk$1;
+
+/**
+ * Creates a stream from a subscription to a `Hub`.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunkHub = fromChunkHub$1;
+
+/**
+ * Creates a stream from a `Queue` of values.
+ *
+ * @param shutdown If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunkQueue = fromChunkQueue$1;
+
+/**
+ * Creates a stream from an arbitrary number of chunks.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunks = fromChunks$1;
+
+/**
+ * Either emits the success value of this effect or terminates the stream
+ * with the failure value of this effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = fromEffect$1;
+
+/**
+ * Creates a stream from an effect producing a value of type `A` or an empty
+ * `Stream`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffectOption = fromEffectOption$1;
+
+/**
+ * Creates a stream from a subscription to a `Hub`.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromHub = fromHub$1;
+
+/**
+ * Creates a stream from an `Iterable` collection of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterable = fromIterable$1;
+
+/**
+ * Creates a stream from an effect producing a value of type `Iterable<A>`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterableEffect = fromIterableEffect$1;
+
+/**
+ * Creates a stream from an iterator
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIteratorSucceed = fromIteratorSucceed$1;
+
+/**
+ * Creates a stream from an effect that pulls elements from another stream.
+ *
+ * See `Stream.toPull` for reference.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPull = fromPull$1;
+
+/**
+ * Creates a stream from a queue of values
+ *
+ * @param maxChunkSize The maximum number of queued elements to put in one chunk in the stream
+ * @param shutdown If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromQueue = fromQueue$1;
+
+/**
+ * Creates a stream from a `ReadableStream`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromReadableStream = fromReadableStream$1;
+
+/**
+ * Creates a stream from a `ReadableStreamBYOBReader`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader.
+ *
+ * @param allocSize Controls the size of the underlying `ArrayBuffer` (defaults to `4096`).
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromReadableStreamByob = fromReadableStreamByob$1;
+
+/**
+ * Creates a stream from a `Schedule` that does not require any further
+ * input. The stream will emit an element for each value output from the
+ * schedule, continuing for as long as the schedule continues.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromSchedule = fromSchedule$1;
+
+/**
+ * Creates a pipeline that groups on adjacent keys, calculated by the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category grouping
+ */
+const groupAdjacentBy = groupAdjacentBy$1;
+
+/**
+ * More powerful version of `Stream.groupByKey`.
+ *
+ * @since 2.0.0
+ * @category grouping
+ */
+const groupBy = groupBy$1;
+
+/**
+ * Partition a stream using a function and process each stream individually.
+ * This returns a data structure that can be used to further filter down which
+ * groups shall be processed.
+ *
+ * After calling apply on the GroupBy object, the remaining groups will be
+ * processed in parallel and the resulting streams merged in a
+ * nondeterministic fashion.
+ *
+ * Up to `buffer` elements may be buffered in any group stream before the
+ * producer is backpressured. Take care to consume from all streams in order
+ * to prevent deadlocks.
+ *
+ * For example, to collect the first 2 words for every starting letter from a
+ * stream of words:
+ *
+ * ```ts
+ * import * as GroupBy from "./GroupBy"
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.fromIterable(["hello", "world", "hi", "holla"]),
+ *   Stream.groupByKey((word) => word[0]),
+ *   GroupBy.evaluate((key, stream) =>
+ *     pipe(
+ *       stream,
+ *       Stream.take(2),
+ *       Stream.map((words) => [key, words] as const)
+ *     )
+ *   )
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const groupByKey = groupByKey$1;
+
+/**
+ * Partitions the stream with specified `chunkSize`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const grouped = grouped$1;
+
+/**
+ * Partitions the stream with the specified `chunkSize` or until the specified
+ * `duration` has passed, whichever is satisfied first.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const groupedWithin = groupedWithin$1;
+
+/**
+ * Specialized version of haltWhen which halts the evaluation of this stream
+ * after the given duration.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * given duration completes. See `interruptAfter` for this behavior.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const haltAfter = haltAfter$1;
+
+/**
+ * Halts the evaluation of this stream when the provided effect completes. The
+ * given effect will be forked as part of the returned stream, and its success
+ * will be discarded.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * effect completes. See `interruptWhen` for this behavior.
+ *
+ * If the effect completes with a failure, the stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const haltWhen = haltWhen$1;
+
+/**
+ * Halts the evaluation of this stream when the provided promise resolves.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const haltWhenDeferred = haltWhenDeferred$1;
+
+/**
+ * The identity pipeline, which does not modify streams in any way.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const identity = identityStream;
+
+/**
+ * Interleaves this stream and the specified stream deterministically by
+ * alternating pulling values from this stream and the specified stream. When
+ * one stream is exhausted all remaining values in the other stream will be
+ * pulled.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interleave = interleave$1;
+
+/**
+ * Combines this stream and the specified stream deterministically using the
+ * stream of boolean values `pull` to control which stream to pull from next.
+ * A value of `true` indicates to pull from this stream and a value of `false`
+ * indicates to pull from the specified stream. Only consumes as many elements
+ * as requested by the `pull` stream. If either this stream or the specified
+ * stream are exhausted further requests for values from that stream will be
+ * ignored.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interleaveWith = interleaveWith$1;
+
+/**
+ * Intersperse stream with provided `element`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const intersperse = intersperse$1;
+
+/**
+ * Intersperse the specified element, also adding a prefix and a suffix.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const intersperseAffixes = intersperseAffixes$1;
+
+/**
+ * Specialized version of `Stream.interruptWhen` which interrupts the
+ * evaluation of this stream after the given `Duration`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptAfter = interruptAfter$1;
+
+/**
+ * Interrupts the evaluation of this stream when the provided effect
+ * completes. The given effect will be forked as part of this stream, and its
+ * success will be discarded. This combinator will also interrupt any
+ * in-progress element being pulled from upstream.
+ *
+ * If the effect completes with a failure before the stream completes, the
+ * returned stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptWhen = interruptWhen$1;
+
+/**
+ * Interrupts the evaluation of this stream when the provided promise
+ * resolves. This combinator will also interrupt any in-progress element being
+ * pulled from upstream.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptWhenDeferred = interruptWhenDeferred$1;
+
+/**
+ * The infinite stream of iterative function application: a, f(a), f(f(a)),
+ * f(f(f(a))), ...
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const iterate = iterate$1;
+
+/**
+ * Creates a stream from an sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Transforms the elements of this stream using the supplied function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Statefully maps over the elements of this stream to produce new elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapAccum = mapAccum$1;
+
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * new elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapAccumEffect = mapAccumEffect$1;
+
+/**
+ * Returns a stream whose failure and success channels have been mapped by the
+ * specified `onFailure` and `onSuccess` functions.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapBoth = mapBoth$1;
+
+/**
+ * Transforms the chunks emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapChunks = mapChunks$1;
+
+/**
+ * Effectfully transforms the chunks emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapChunksEffect = mapChunksEffect$1;
+
+/**
+ * Maps each element to an iterable, and flattens the iterables into the
+ * output of this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcat = mapConcat$1;
+
+/**
+ * Maps each element to a chunk, and flattens the chunks into the output of
+ * this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcatChunk = mapConcatChunk$1;
+
+/**
+ * Effectfully maps each element to a chunk, and flattens the chunks into the
+ * output of this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcatChunkEffect = mapConcatChunkEffect$1;
+
+/**
+ * Effectfully maps each element to an iterable, and flattens the iterables
+ * into the output of this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcatEffect = mapConcatEffect$1;
+
+/**
+ * Maps over elements of the stream with the specified effectful function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = mapEffectOptions;
+
+/**
+ * Transforms the errors emitted by this stream using `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = mapError$1;
+
+/**
+ * Transforms the full causes of failures emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapErrorCause = mapErrorCause$1;
+
+/**
+ * Merges this stream and the specified stream together.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const merge = merge$1;
+
+/**
+ * Merges a variable list of streams in a non-deterministic fashion. Up to `n`
+ * streams may be consumed in parallel and up to `outputBuffer` chunks may be
+ * buffered by this operator.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAll = mergeAll$1;
+
+/**
+ * Merges this stream and the specified stream together to a common element
+ * type with the specified mapping functions.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeWith = mergeWith$1;
+
+/**
+ * Merges this stream and the specified stream together to produce a stream of
+ * eithers.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeEither = mergeEither$1;
+
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the right stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeLeft = mergeLeft$1;
+
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeRight = mergeRight$1;
+
+/**
+ * Returns a combined string resulting from concatenating each of the values
+ * from the stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mkString = mkString$1;
+
+/**
+ * The stream that never produces any value or fails with any error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = never$1;
+
+/**
+ * Runs the specified effect if this stream fails, providing the error to the
+ * effect if it exists.
+ *
+ * Note: Unlike `Effect.onError` there is no guarantee that the provided
+ * effect will not be interrupted.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const onError = onError$1;
+
+/**
+ * Runs the specified effect if this stream ends.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const onDone = onDone$1;
+
+/**
+ * Translates any failure into a stream termination, making the stream
+ * infallible and all failures unchecked.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDie = orDie$1;
+
+/**
+ * Keeps none of the errors, and terminates the stream with them, using the
+ * specified function to convert the `E` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDieWith = orDieWith$1;
+
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = orElse$1;
+
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseEither = orElseEither$1;
+
+/**
+ * Fails with given error in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseFail = orElseFail$1;
+
+/**
+ * Produces the specified element if this stream is empty.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseIfEmpty = orElseIfEmpty$1;
+
+/**
+ * Produces the specified chunk if this stream is empty.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseIfEmptyChunk = orElseIfEmptyChunk$1;
+
+/**
+ * Switches to the provided stream in case this one is empty.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseIfEmptyStream = orElseIfEmptyStream$1;
+
+/**
+ * Succeeds with the specified value if this one fails with a typed error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseSucceed = orElseSucceed$1;
+
+/**
+ * Like `Stream.unfold`, but allows the emission of values to end one step further
+ * than the unfolding of the state. This is useful for embedding paginated
+ * APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginate = paginate$1;
+
+/**
+ * Like `Stream.unfoldChunk`, but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginateChunk = paginateChunk$1;
+
+/**
+ * Like `Stream.unfoldChunkEffect`, but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginateChunkEffect = paginateChunkEffect$1;
+
+/**
+ * Like `Stream.unfoldEffect` but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginateEffect = paginateEffect$1;
+
+/**
+ * Partition a stream using a predicate. The first stream will contain all
+ * element evaluated to true and the second one will contain all element
+ * evaluated to false. The faster stream may advance by up to buffer elements
+ * further than the slower one.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const partition = partition$1;
+
+/**
+ * Split a stream by an effectful predicate. The faster stream may advance by
+ * up to buffer elements further than the slower one.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const partitionEither = partitionEither$1;
+
+/**
+ * Peels off enough material from the stream to construct a `Z` using the
+ * provided `Sink` and then returns both the `Z` and the rest of the
+ * `Stream` in a scope. Like all scoped values, the provided stream is
+ * valid only within the scope.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const peel = peel$1;
+
+/**
+ * Pipes all of the values from this stream through the provided sink.
+ *
+ * See also `Stream.transduce`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeThrough = pipeThrough$1;
+
+/**
+ * Pipes all the values from this stream through the provided channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeThroughChannel = pipeThroughChannel$1;
+
+/**
+ * Pipes all values from this stream through the provided channel, passing
+ * through any error emitted by this stream unchanged.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeThroughChannelOrFail = pipeThroughChannelOrFail$1;
+
+/**
+ * Emits the provided chunk before emitting any other value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const prepend = prepend$1;
+
+/**
+ * Provides the stream with its required context, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = provideContext$1;
+
+/**
+ * Provides a `Layer` to the stream, which translates it to another level.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideLayer = provideLayer$1;
+
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideService = provideService$1;
+
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideServiceEffect = provideServiceEffect$1;
+
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideServiceStream = provideServiceStream$1;
+
+/**
+ * Transforms the context being provided to the stream with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = mapInputContext$1;
+
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `R0`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideSomeLayer = provideSomeLayer$1;
+
+/**
+ * Constructs a stream from a range of integers, including both endpoints.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const range = range$1;
+
+/**
+ * Re-chunks the elements of the stream into chunks of `n` elements each. The
+ * last chunk might contain less than `n` elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const rechunk = rechunk$1;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDie = refineOrDie$1;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest, using the
+ * specified function to convert the `E` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDieWith = refineOrDieWith$1;
+
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeat = repeat$1;
+
+/**
+ * Creates a stream from an effect producing a value of type `A` which repeats
+ * forever.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffect = repeatEffect$1;
+
+/**
+ * Creates a stream from an effect producing chunks of `A` values which
+ * repeats forever.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectChunk = repeatEffectChunk$1;
+
+/**
+ * Creates a stream from an effect producing chunks of `A` values until it
+ * fails with `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectChunkOption = repeatEffectChunkOption$1;
+
+/**
+ * Creates a stream from an effect producing values of type `A` until it fails
+ * with `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectOption = repeatEffectOption$1;
+
+/**
+ * Creates a stream from an effect producing a value of type `A`, which is
+ * repeated using the specified schedule.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectWithSchedule = repeatEffectWithSchedule$1;
+
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ * The schedule output will be emitted at the end of each repetition.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatEither = repeatEither$1;
+
+/**
+ * Repeats each element of the stream using the provided schedule. Repetitions
+ * are done in addition to the first execution, which means using
+ * `Schedule.recurs(1)` actually results in the original effect, plus an
+ * additional recurrence, for a total of two repetitions of each value in the
+ * stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatElements = repeatElements$1;
+
+/**
+ * Repeats each element of the stream using the provided schedule. When the
+ * schedule is finished, then the output of the schedule will be emitted into
+ * the stream. Repetitions are done in addition to the first execution, which
+ * means using `Schedule.recurs(1)` actually results in the original effect,
+ * plus an additional recurrence, for a total of two repetitions of each value
+ * in the stream.
+ *
+ * This function accepts two conversion functions, which allow the output of
+ * this stream and the output of the provided schedule to be unified into a
+ * single type. For example, `Either` or similar data type.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatElementsWith = repeatElementsWith$1;
+
+/**
+ * Repeats the provided value infinitely.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatValue = repeatValue$1;
+
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ * The schedule output will be emitted at the end of each repetition and can
+ * be unified with the stream elements using the provided functions.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatWith = repeatWith$1;
+
+/**
+ * When the stream fails, retry it according to the given schedule
+ *
+ * This retries the entire stream, so will re-execute all of the stream's
+ * acquire operations.
+ *
+ * The schedule is reset as soon as the first element passes through the
+ * stream again.
+ *
+ * @param schedule A `Schedule` receiving as input the errors of the stream.
+ * @since 2.0.0
+ * @category utils
+ */
+const retry = retry$1;
+
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const run = run$1;
+
+/**
+ * Runs the stream and collects all of its elements to a chunk.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runCollect = runCollect$1;
+
+/**
+ * Runs the stream and emits the number of elements processed
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runCount = runCount$1;
+
+/**
+ * Runs the stream only for its effects. The emitted elements are discarded.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runDrain = runDrain$1;
+
+/**
+ * Executes a pure fold over the stream of values - reduces all elements in
+ * the stream to a value of type `S`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFold = runFold$1;
+
+/**
+ * Executes an effectful fold over the stream of values.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldEffect = runFoldEffect$1;
+
+/**
+ * Executes a pure fold over the stream of values. Returns a scoped value that
+ * represents the scope of the stream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldScoped = runFoldScoped$1;
+
+/**
+ * Executes an effectful fold over the stream of values. Returns a scoped
+ * value that represents the scope of the stream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldScopedEffect = runFoldScopedEffect$1;
+
+/**
+ * Reduces the elements in the stream to a value of type `S`. Stops the fold
+ * early when the condition is not fulfilled. Example:
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhile = runFoldWhile$1;
+
+/**
+ * Executes an effectful fold over the stream of values. Stops the fold early
+ * when the condition is not fulfilled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhileEffect = runFoldWhileEffect$1;
+
+/**
+ * Executes a pure fold over the stream of values. Returns a scoped value that
+ * represents the scope of the stream. Stops the fold early when the condition
+ * is not fulfilled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhileScoped = runFoldWhileScoped$1;
+
+/**
+ * Executes an effectful fold over the stream of values. Returns a scoped
+ * value that represents the scope of the stream. Stops the fold early when
+ * the condition is not fulfilled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhileScopedEffect = runFoldWhileScopedEffect$1;
+
+/**
+ * Consumes all elements of the stream, passing them to the specified
+ * callback.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEach = runForEach$1;
+
+/**
+ * Consumes all elements of the stream, passing them to the specified
+ * callback.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachChunk = runForEachChunk$1;
+
+/**
+ * Like `Stream.runForEachChunk`, but returns a scoped effect so the
+ * finalization order can be controlled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachChunkScoped = runForEachChunkScoped$1;
+
+/**
+ * Like `Stream.forEach`, but returns a scoped effect so the finalization
+ * order can be controlled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachScoped = runForEachScoped$1;
+
+/**
+ * Consumes elements of the stream, passing them to the specified callback,
+ * and terminating consumption when the callback returns `false`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachWhile = runForEachWhile$1;
+
+/**
+ * Like `Stream.runForEachWhile`, but returns a scoped effect so the
+ * finalization order can be controlled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachWhileScoped = runForEachWhileScoped$1;
+
+/**
+ * Runs the stream to completion and yields the first value emitted by it,
+ * discarding the rest of the elements.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runHead = runHead$1;
+
+/**
+ * Publishes elements of this stream to a hub. Stream failure and ending will
+ * also be signalled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoHub = runIntoHub$1;
+
+/**
+ * Like `Stream.runIntoHub`, but provides the result as a scoped effect to
+ * allow for scope composition.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoHubScoped = runIntoHubScoped$1;
+
+/**
+ * Enqueues elements of this stream into a queue. Stream failure and ending
+ * will also be signalled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoQueue = runIntoQueue$1;
+
+/**
+ * Like `Stream.runIntoQueue`, but provides the result as a scoped [[ZIO]]
+ * to allow for scope composition.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoQueueElementsScoped = runIntoQueueElementsScoped$1;
+
+/**
+ * Like `Stream.runIntoQueue`, but provides the result as a scoped effect
+ * to allow for scope composition.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoQueueScoped = runIntoQueueScoped$1;
+
+/**
+ * Runs the stream to completion and yields the last value emitted by it,
+ * discarding the rest of the elements.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runLast = runLast$1;
+
+/**
+ * @since 2.0.0
+ * @category destructors
+ */
+const runScoped = runScoped$1;
+
+/**
+ * Runs the stream to a sink which sums elements, provided they are Numeric.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runSum = runSum$1;
+
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results of type `S` given an initial S.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scan = scan$1;
+
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results of type `S` given an initial S.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scanEffect = scanEffect$1;
+
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results.
+ *
+ * See also `Stream.scan`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scanReduce = scanReduce$1;
+
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results.
+ *
+ * See also `Stream.scanEffect`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scanReduceEffect = scanReduceEffect$1;
+
+/**
+ * Schedules the output of the stream using the provided `schedule`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const schedule = schedule$1;
+
+/**
+ * Schedules the output of the stream using the provided `schedule` and emits
+ * its output at the end (if `schedule` is finite). Uses the provided function
+ * to align the stream and schedule outputs on the same type.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scheduleWith = scheduleWith$1;
+
+/**
+ * Creates a single-valued stream from a scoped resource.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scoped = scoped$1;
+
+/**
+ * Emits a sliding window of `n` elements.
+ *
+ * ```ts
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.make(1, 2, 3, 4),
+ *   Stream.sliding(2),
+ *   Stream.runCollect
+ * )
+ * // => Chunk(Chunk(1, 2), Chunk(2, 3), Chunk(3, 4))
+ * ```
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const sliding = sliding$1;
+
+/**
+ * Like `sliding`, but with a configurable `stepSize` parameter.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const slidingSize = slidingSize$1;
+
+/**
+ * Converts an option on values into an option on errors.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const some = some$1;
+
+/**
+ * Extracts the optional value, or returns the given 'default'.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const someOrElse = someOrElse$1;
+
+/**
+ * Extracts the optional value, or fails with the given error 'e'.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const someOrFail = someOrFail$1;
+
+/**
+ * Splits elements based on a predicate.
+ *
+ * ```ts
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.range(1, 10),
+ *   Stream.split((n) => n % 4 === 0),
+ *   Stream.runCollect
+ * )
+ * // => Chunk(Chunk(1, 2, 3), Chunk(5, 6, 7), Chunk(9))
+ * ```
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const split = split$1;
+
+/**
+ * Splits elements on a delimiter and transforms the splits into desired output.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const splitOnChunk = splitOnChunk$1;
+
+/**
+ * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
+ * newlines (`\n`).
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const splitLines = splitLines$1;
+
+/**
+ * Creates a single-valued pure stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * Creates a single-valued pure stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = sync$1;
+
+/**
+ * Returns a lazily constructed stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = suspend$1;
+
+/**
+ * Takes the specified number of elements from this stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const take = take$1;
+
+/**
+ * Takes the last specified number of elements from this stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeRight = takeRight$1;
+
+/**
+ * Takes all elements of the stream until the specified predicate evaluates to
+ * `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeUntil = takeUntil$1;
+
+/**
+ * Takes all elements of the stream until the specified effectual predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeUntilEffect = takeUntilEffect$1;
+
+/**
+ * Takes all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeWhile = takeWhile$1;
+
+/**
+ * Adds an effect to consumption of every element of the stream.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = tap$1;
+
+/**
+ * Returns a stream that effectfully "peeks" at the failure or success of
+ * the stream.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapBoth = tapBoth$1;
+
+/**
+ * Returns a stream that effectfully "peeks" at the failure of the stream.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = tapError$1;
+
+/**
+ * Returns a stream that effectfully "peeks" at the cause of failure of the
+ * stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const tapErrorCause = tapErrorCause$1;
+
+/**
+ * Sends all elements emitted by this stream to the specified sink in addition
+ * to emitting them.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapSink = tapSink$1;
+
+/**
+ * Delays the chunks of this stream according to the given bandwidth
+ * parameters using the token bucket algorithm. Allows for burst in the
+ * processing of elements by allowing the token bucket to accumulate tokens up
+ * to a `units + burst` threshold. The weight of each chunk is determined by
+ * the `costFn` function.
+ *
+ * If using the "enforce" strategy, chunks that do not meet the bandwidth
+ * constraints are dropped. If using the "shape" strategy, chunks are delayed
+ * until they can be emitted without exceeding the bandwidth constraints.
+ *
+ * Defaults to the "shape" strategy.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const throttle = throttle$1;
+
+/**
+ * Delays the chunks of this stream according to the given bandwidth
+ * parameters using the token bucket algorithm. Allows for burst in the
+ * processing of elements by allowing the token bucket to accumulate tokens up
+ * to a `units + burst` threshold. The weight of each chunk is determined by
+ * the effectful `costFn` function.
+ *
+ * If using the "enforce" strategy, chunks that do not meet the bandwidth
+ * constraints are dropped. If using the "shape" strategy, chunks are delayed
+ * until they can be emitted without exceeding the bandwidth constraints.
+ *
+ * Defaults to the "shape" strategy.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const throttleEffect = throttleEffect$1;
+
+/**
+ * A stream that emits Unit values spaced by the specified duration.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const tick = tick$1;
+
+/**
+ * Ends the stream if it does not produce a value after the specified duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeout = timeout$1;
+
+/**
+ * Fails the stream with given error if it does not produce a value after d
+ * duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeoutFail = timeoutFail$1;
+
+/**
+ * Fails the stream with given cause if it does not produce a value after d
+ * duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeoutFailCause = timeoutFailCause$1;
+
+/**
+ * Switches the stream if it does not produce a value after the specified
+ * duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeoutTo = timeoutTo$1;
+
+/**
+ * Converts the stream to a scoped hub of chunks. After the scope is closed,
+ * the hub will never again produce values and should be discarded.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toHub = toHub$1;
+
+/**
+ * Returns in a scope a ZIO effect that can be used to repeatedly pull chunks
+ * from the stream. The pull effect fails with None when the stream is
+ * finished, or with Some error if it fails, otherwise it returns a chunk of
+ * the stream's output.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toPull = toPull$1;
+
+/**
+ * Converts the stream to a scoped queue of chunks. After the scope is closed,
+ * the queue will never again produce values and should be discarded.
+ *
+ * Defaults to the "suspend" back pressure strategy with a capacity of 2.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toQueue = toQueue$1;
+
+/**
+ * Converts the stream to a scoped queue of elements. After the scope is
+ * closed, the queue will never again produce values and should be discarded.
+ *
+ * Defaults to a capacity of 2.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toQueueOfElements = toQueueOfElements$1;
+
+/**
+ * Converts the stream to a `ReadableStream`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toReadableStream = toReadableStream$1;
+
+/**
+ * Applies the transducer to the stream and emits its outputs.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const transduce = transduce$1;
+
+/**
+ * Creates a stream by peeling off the "layers" of a value of type `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfold = unfold$1;
+
+/**
+ * Creates a stream by peeling off the "layers" of a value of type `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfoldChunk = unfoldChunk$1;
+
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type
+ * `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfoldChunkEffect = unfoldChunkEffect$1;
+
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type
+ * `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfoldEffect = unfoldEffect$1;
+
+/**
+ * A stream that contains a single `Unit` value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unit = unit$1;
+
+/**
+ * Creates a stream produced from an `Effect`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = unwrap$1;
+
+/**
+ * Creates a stream produced from a scoped `Effect`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrapScoped = unwrapScoped$1;
+
+/**
+ * Updates the specified service within the context of the `Stream`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const updateService = updateService$1;
+
+/**
+ * Returns the specified stream if the given condition is satisfied, otherwise
+ * returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const when = when$1;
+
+/**
+ * Returns the resulting stream when the given `PartialFunction` is defined
+ * for the given value, otherwise returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const whenCase = whenCase$1;
+
+/**
+ * Returns the stream when the given partial function is defined for the given
+ * effectful value, otherwise returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whenCaseEffect = whenCaseEffect$1;
+
+/**
+ * Returns the stream if the given effectful condition is satisfied, otherwise
+ * returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whenEffect = whenEffect$1;
+
+/**
+ * Wraps the stream with a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category tracing
+ */
+const withSpan = withSpan$1;
+
+/**
+ * Zips this stream with another point-wise and emits tuples of elements from
+ * both streams.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = zip$1;
+
+/**
+ * Zips this stream with another point-wise and emits tuples of elements from
+ * both streams.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipFlatten = zipFlatten$1;
+
+/**
+ * Zips this stream with another point-wise, creating a new stream of pairs of
+ * elements from both sides.
+ *
+ * The defaults `defaultLeft` and `defaultRight` will be used if the streams
+ * have different lengths and one of the streams has ended before the other.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAll = zipAll$1;
+
+/**
+ * Zips this stream with another point-wise, and keeps only elements from this
+ * stream.
+ *
+ * The provided default value will be used if the other stream ends before
+ * this one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllLeft = zipAllLeft$1;
+
+/**
+ * Zips this stream with another point-wise, and keeps only elements from the
+ * other stream.
+ *
+ * The provided default value will be used if this stream ends before the
+ * other one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllRight = zipAllRight$1;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Combines values associated with each key into a tuple,
+ * using the specified values `defaultLeft` and `defaultRight` to fill in
+ * missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKey = zipAllSortedByKey$1;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Keeps only values from this stream, using the specified
+ * value `default` to fill in missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKeyLeft = zipAllSortedByKeyLeft$1;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Keeps only values from that stream, using the specified
+ * value `default` to fill in missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKeyRight = zipAllSortedByKeyRight$1;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Uses the functions `left`, `right`, and `both` to handle
+ * the cases where a key and value exist in this stream, that stream, or
+ * both streams.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKeyWith = zipAllSortedByKeyWith$1;
+
+/**
+ * Zips this stream with another point-wise. The provided functions will be
+ * used to create elements for the composed stream.
+ *
+ * The functions `left` and `right` will be used if the streams have different
+ * lengths and one of the streams has ended before the other.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllWith = zipAllWith$1;
+
+/**
+ * Zips the two streams so that when a value is emitted by either of the two
+ * streams, it is combined with the latest value from the other stream to
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLatest = zipLatest$1;
+
+/**
+ * Zips the two streams so that when a value is emitted by either of the two
+ * streams, it is combined with the latest value from the other stream to
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLatestWith = zipLatestWith$1;
+
+/**
+ * Zips this stream with another point-wise, but keeps only the outputs of
+ * this stream.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = zipLeft$1;
+
+/**
+ * Zips this stream with another point-wise, but keeps only the outputs of the
+ * other stream.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = zipRight$1;
+
+/**
+ * Zips this stream with another point-wise and applies the function to the
+ * paired elements.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = zipWith$1;
+
+/**
+ * Zips this stream with another point-wise and applies the function to the
+ * paired elements.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithChunks = zipWithChunks$1;
+
+/**
+ * Zips each element with the next element if present.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithNext = zipWithNext$1;
+
+/**
+ * Zips each element with the previous element. Initially accompanied by
+ * `None`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithPrevious = zipWithPrevious$1;
+
+/**
+ * Zips each element with both the previous and next element.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithPreviousAndNext = zipWithPreviousAndNext$1;
+
+/**
+ * Zips this stream together with the index of elements.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithIndex = zipWithIndex$1;
+
+// -------------------------------------------------------------------------------------
+// Do notation
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.0.0
+ * @category do notation
+ */
+const Do = Do$1;
+
+/**
+ * Binds a value from a stream in a `do` scope
+ *
+ * @since 2.0.0
+ * @category do notation
+ */
+const bind = bind$1;
+
+/**
+ * Binds an effectful value in a `do` scope
+ *
+ * @since 2.0.0
+ * @category do notation
+ */
+const bindEffect = bindEffect$1;
+
+/**
+ * @since 2.0.0
+ * @category do notation
+ */
+const bindTo = bindTo$1;
+const let_ = let_$1;
+
+// -------------------------------------------------------------------------------------
+// encoding
+// -------------------------------------------------------------------------------------
+
+/**
+ * Decode Uint8Array chunks into a stream of strings using the specified encoding.
+ *
+ * @since 2.0.0
+ * @category encoding
+ */
+const decodeText = decodeText$1;
+
+/**
+ * Encode a stream of strings into a stream of Uint8Array chunks using the specified encoding.
+ *
+ * @since 2.0.0
+ * @category encoding
+ */
+const encodeText = encodeText$1;
+
+export { DefaultChunkSize, Do, StreamTypeId, acquireRelease, aggregate, aggregateWithin, aggregateWithinEither, as, _async as async, asyncEffect, asyncInterrupt, asyncOption, asyncScoped, bind, bindEffect, bindTo, branchAfter, broadcast, broadcastDynamic, broadcastedQueues, broadcastedQueuesDynamic, buffer, bufferChunks, catchAll, catchAllCause, catchSome, catchSomeCause, catchTag, catchTags, changes, changesWith, changesWithEffect, chunks, chunksWith, combine, combineChunks, concat, concatAll, context, contextWith, contextWithEffect, contextWithStream, cross, crossLeft, crossRight, crossWith, debounce, decodeText, die, dieMessage, dieSync, distributedWith, distributedWithDynamic, drain, drainFork, drop, dropRight, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, either, empty, encodeText, ensuring, ensuringWith, execute, fail, failCause, failCauseSync, failSync, filter, filterEffect, filterMap, filterMapEffect, filterMapWhile, filterMapWhileEffect, finalizer, find, findEffect, flatMap, flatten, flattenChunks, flattenEffect, flattenExitOption, flattenIterables, flattenTake, forever, fromAsyncIterable, fromChannel, fromChunk, fromChunkHub, fromChunkQueue, fromChunks, fromEffect, fromEffectOption, fromHub, fromIterable, fromIterableEffect, fromIteratorSucceed, fromPull, fromQueue, fromReadableStream, fromReadableStreamByob, fromSchedule, groupAdjacentBy, groupBy, groupByKey, grouped, groupedWithin, haltAfter, haltWhen, haltWhenDeferred, identity, interleave, interleaveWith, interruptAfter, interruptWhen, interruptWhenDeferred, intersperse, intersperseAffixes, iterate, let_ as let, make, map, mapAccum, mapAccumEffect, mapBoth, mapChunks, mapChunksEffect, mapConcat, mapConcatChunk, mapConcatChunkEffect, mapConcatEffect, mapEffect, mapError, mapErrorCause, mapInputContext, merge, mergeAll, mergeEither, mergeLeft, mergeRight, mergeWith, mkString, never, onDone, onError, orDie, orDieWith, orElse, orElseEither, orElseFail, orElseIfEmpty, orElseIfEmptyChunk, orElseIfEmptyStream, orElseSucceed, paginate, paginateChunk, paginateChunkEffect, paginateEffect, partition, partitionEither, peel, pipeThrough, pipeThroughChannel, pipeThroughChannelOrFail, prepend, provideContext, provideLayer, provideService, provideServiceEffect, provideServiceStream, provideSomeLayer, range, rechunk, refineOrDie, refineOrDieWith, repeat, repeatEffect, repeatEffectChunk, repeatEffectChunkOption, repeatEffectOption, repeatEffectWithSchedule, repeatEither, repeatElements, repeatElementsWith, repeatValue, repeatWith, retry, run, runCollect, runCount, runDrain, runFold, runFoldEffect, runFoldScoped, runFoldScopedEffect, runFoldWhile, runFoldWhileEffect, runFoldWhileScoped, runFoldWhileScopedEffect, runForEach, runForEachChunk, runForEachChunkScoped, runForEachScoped, runForEachWhile, runForEachWhileScoped, runHead, runIntoHub, runIntoHubScoped, runIntoQueue, runIntoQueueElementsScoped, runIntoQueueScoped, runLast, runScoped, runSum, scan, scanEffect, scanReduce, scanReduceEffect, schedule, scheduleWith, scoped, sliding, slidingSize, some, someOrElse, someOrFail, split, splitLines, splitOnChunk, succeed, suspend, sync, take, takeRight, takeUntil, takeUntilEffect, takeWhile, tap, tapBoth, tapError, tapErrorCause, tapSink, throttle, throttleEffect, tick, timeout, timeoutFail, timeoutFailCause, timeoutTo, toChannel, toHub, toPull, toQueue, toQueueOfElements, toReadableStream, transduce, unfold, unfoldChunk, unfoldChunkEffect, unfoldEffect, unit, unwrap, unwrapScoped, updateService, when, whenCase, whenCaseEffect, whenEffect, withSpan, zip, zipAll, zipAllLeft, zipAllRight, zipAllSortedByKey, zipAllSortedByKeyLeft, zipAllSortedByKeyRight, zipAllSortedByKeyWith, zipAllWith, zipFlatten, zipLatest, zipLatestWith, zipLeft, zipRight, zipWith, zipWithChunks, zipWithIndex, zipWithNext, zipWithPrevious, zipWithPreviousAndNext };