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

package/dist/Stream-b1eaedfc.cjs.dev.js

@@ -1,3469 +0,0 @@
-'use strict';
-
-var groupBy$1 = require('./groupBy-3a32c4b6.cjs.dev.js');
-var stream = require('./stream-b819c5b3.cjs.dev.js');
-
-/**
- * @since 1.0.0
- */
-/**
- * @since 1.0.0
- * @category symbols
- */
-const StreamTypeId = stream.StreamTypeId;
-
-/**
- * @since 1.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 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @category models
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @category type lambdas
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- */
-
-/**
- * The default chunk size used by the various combinators and constructors of
- * `Stream`.
- *
- * @since 1.0.0
- * @category constants
- */
-const DefaultChunkSize = stream.DefaultChunkSize;
-
-/**
- * Creates a stream from a single value that will get cleaned up after the
- * stream is consumed.
- *
- * @since 1.0.0
- * @category constructors
- */
-const acquireRelease = stream.acquireRelease;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const aggregate = stream.aggregate;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const aggregateWithin = stream.aggregateWithin;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const aggregateWithinEither = stream.aggregateWithinEither;
-
-/**
- * Maps the success values of this stream to the specified constant value.
- *
- * @since 1.0.0
- * @category mapping
- */
-const as = stream.as;
-const _async = stream._async;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const asyncEffect = stream.asyncEffect;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const asyncInterrupt = stream.asyncInterrupt;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const asyncOption = stream.asyncOption;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const asyncScoped = stream.asyncScoped;
-
-/**
- * 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 1.0.0
- * @category sequencing
- */
-const branchAfter = stream.branchAfter;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const broadcast = stream.broadcast;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const broadcastDynamic = stream.broadcastDynamic;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const broadcastedQueues = stream.broadcastedQueues;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const broadcastedQueuesDynamic = stream.broadcastedQueuesDynamic;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const buffer = stream.buffer;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const bufferChunks = stream.bufferChunks;
-
-/**
- * Switches over to the stream produced by the provided function in case this
- * one fails with a typed error.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchAll = stream.catchAll;
-
-/**
- * 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 1.0.0
- * @category error handling
- */
-const catchAllCause = stream.catchAllCause;
-
-/**
- * Switches over to the stream produced by the provided function in case this
- * one fails with some typed error.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchSome = stream.catchSome;
-
-/**
- * Switches over to the stream produced by the provided function in case this
- * one fails with an error matching the given `_tag`.
- *
- * @since 1.0.0
- * @category error handling
- */
-const catchTag = stream.catchTag;
-
-/**
- * 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 1.0.0
- * @category error handling
- */
-const catchTags = stream.catchTags;
-
-/**
- * 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 1.0.0
- * @category error handling
- */
-const catchSomeCause = stream.catchSomeCause;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const changes = stream.changes;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const changesWith = stream.changesWith;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const changesWithEffect = stream.changesWithEffect;
-
-/**
- * Exposes the underlying chunks of the stream as a stream of chunks of
- * elements.
- *
- * @since 1.0.0
- * @category utils
- */
-const chunks = stream.chunks;
-
-/**
- * Performs the specified stream transformation with the chunk structure of
- * the stream exposed.
- *
- * @since 1.0.0
- * @category utils
- */
-const chunksWith = stream.chunksWith;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const combine = stream.combine;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const combineChunks = stream.combineChunks;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const concat = stream.concat;
-
-/**
- * Concatenates all of the streams in the chunk to one stream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const concatAll = stream.concatAll;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const cross = stream.cross;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const crossLeft = stream.crossLeft;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const crossRight = stream.crossRight;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const crossWith = stream.crossWith;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const debounce = stream.debounce;
-
-/**
- * The stream that dies with the specified defect.
- *
- * @since 1.0.0
- * @category constructors
- */
-const die = stream.die;
-
-/**
- * The stream that dies with the specified lazily evaluated defect.
- *
- * @since 1.0.0
- * @category constructors
- */
-const dieSync = stream.dieSync;
-
-/**
- * The stream that dies with an exception described by `message`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const dieMessage = stream.dieMessage;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const distributedWith = stream.distributedWith;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const distributedWithDynamic = stream.distributedWithDynamic;
-
-/**
- * Converts this stream to a stream that executes its effects but emits no
- * elements. Useful for sequencing effects using streams:
- *
- * @since 1.0.0
- * @category utils
- */
-const drain = stream.drain;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const drainFork = stream.drainFork;
-
-/**
- * Drops the specified number of elements from this stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const drop = stream.drop;
-
-/**
- * Drops the last specified number of elements from this stream.
- *
- * @note This combinator keeps `n` elements in memory. Be careful with big
- *       numbers.
- * @since 1.0.0
- * @category utils
- */
-const dropRight = stream.dropRight;
-
-/**
- * Drops all elements of the stream until the specified predicate evaluates to
- * `true`.
- *
- * @since 1.0.0
- * @category utils
- */
-const dropUntil = stream.dropUntil;
-
-/**
- * Drops all elements of the stream until the specified effectful predicate
- * evaluates to `true`.
- *
- * @since 1.0.0
- * @category utils
- */
-const dropUntilEffect = stream.dropUntilEffect;
-
-/**
- * Drops all elements of the stream for as long as the specified predicate
- * evaluates to `true`.
- *
- * @since 1.0.0
- * @category utils
- */
-const dropWhile = stream.dropWhile;
-
-/**
- * Drops all elements of the stream for as long as the specified predicate
- * produces an effect that evalutates to `true`
- *
- * @since 1.0.0
- * @category utils
- */
-const dropWhileEffect = stream.dropWhileEffect;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const either = stream.either;
-
-/**
- * The empty stream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const empty = stream.empty;
-
-/**
- * Executes the provided finalizer after this stream's finalizers run.
- *
- * @since 1.0.0
- * @category utils
- */
-const ensuring = stream.ensuring;
-
-/**
- * Executes the provided finalizer after this stream's finalizers run.
- *
- * @since 1.0.0
- * @category utils
- */
-const ensuringWith = stream.ensuringWith;
-
-/**
- * Accesses the whole context of the stream.
- *
- * @since 1.0.0
- * @category context
- */
-const context = stream.context;
-
-/**
- * Accesses the context of the stream.
- *
- * @since 1.0.0
- * @category context
- */
-const contextWith = stream.contextWith;
-
-/**
- * Accesses the context of the stream in the context of an effect.
- *
- * @since 1.0.0
- * @category context
- */
-const contextWithEffect = stream.contextWithEffect;
-
-/**
- * Accesses the context of the stream in the context of a stream.
- *
- * @since 1.0.0
- * @category context
- */
-const contextWithStream = stream.contextWithStream;
-
-/**
- * Creates a stream that executes the specified effect but emits no elements.
- *
- * @since 1.0.0
- * @category constructors
- */
-const execute = stream.execute;
-
-/**
- * Terminates with the specified error.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fail = stream.fail;
-
-/**
- * Terminates with the specified lazily evaluated error.
- *
- * @since 1.0.0
- * @category constructors
- */
-const failSync = stream.failSync;
-
-/**
- * The stream that always fails with the specified `Cause`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const failCause = stream.failCause;
-
-/**
- * The stream that always fails with the specified lazily evaluated `Cause`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const failCauseSync = stream.failCauseSync;
-
-/**
- * Filters the elements emitted by this stream using the provided function.
- *
- * @since 1.0.0
- * @category filtering
- */
-const filter = stream.filter;
-
-/**
- * Effectfully filters the elements emitted by this stream.
- *
- * @since 1.0.0
- * @category filtering
- */
-const filterEffect = stream.filterEffect;
-
-/**
- * Performs a filter and map in a single step.
- *
- * @since 1.0.0
- * @category utils
- */
-const filterMap = stream.filterMap;
-
-/**
- * Performs an effectful filter and map in a single step.
- *
- * @since 1.0.0
- * @category utils
- */
-const filterMapEffect = stream.filterMapEffect;
-
-/**
- * Transforms all elements of the stream for as long as the specified partial
- * function is defined.
- *
- * @since 1.0.0
- * @category utils
- */
-const filterMapWhile = stream.filterMapWhile;
-
-/**
- * Effectfully transforms all elements of the stream for as long as the
- * specified partial function is defined.
- *
- * @since 1.0.0
- * @category utils
- */
-const filterMapWhileEffect = stream.filterMapWhileEffect;
-
-/**
- * Creates a one-element stream that never fails and executes the finalizer
- * when it ends.
- *
- * @since 1.0.0
- * @category constructors
- */
-const finalizer = stream.finalizer;
-
-/**
- * Finds the first element emitted by this stream that satisfies the provided
- * predicate.
- *
- * @since 1.0.0
- * @category elements
- */
-const find = stream.find;
-
-/**
- * Finds the first element emitted by this stream that satisfies the provided
- * effectful predicate.
- *
- * @since 1.0.0
- * @category elements
- */
-const findEffect = stream.findEffect;
-
-/**
- * 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 1.0.0
- * @category sequencing
- */
-const flatMap = stream.flatMap;
-
-/**
- * Flattens this stream-of-streams into a stream made of the concatenation in
- * strict order of all the streams.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flatten = stream.flatten;
-
-/**
- * Submerges the chunks carried by this stream into the stream's structure,
- * while still preserving them.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flattenChunks = stream.flattenChunks;
-
-/**
- * Flattens `Effect` values into the stream's structure, preserving all
- * information about the effect.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flattenEffect = stream.flattenEffect;
-
-/**
- * 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 1.0.0
- * @category sequencing
- */
-const flattenExitOption = stream.flattenExitOption;
-
-/**
- * Submerges the iterables carried by this stream into the stream's structure,
- * while still preserving them.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flattenIterables = stream.flattenIterables;
-
-/**
- * Unwraps `Exit` values and flatten chunks that also signify end-of-stream
- * by failing with `None`.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const flattenTake = stream.flattenTake;
-
-/**
- * Repeats this stream forever.
- *
- * @since 1.0.0
- * @category utils
- */
-const forever = stream.forever;
-
-/**
- * Creates a stream from an `AsyncIterable`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromAsyncIterable = stream.fromAsyncIterable;
-
-/**
- * Creates a stream from a `Channel`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromChannel = stream.fromChannel;
-
-/**
- * Creates a channel from a `Stream`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const toChannel = stream.toChannel;
-
-/**
- * Creates a stream from a `Chunk` of values.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromChunk = stream.fromChunk;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const fromChunkHub = stream.fromChunkHub;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const fromChunkQueue = stream.fromChunkQueue;
-
-/**
- * Creates a stream from an arbitrary number of chunks.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromChunks = stream.fromChunks;
-
-/**
- * Either emits the success value of this effect or terminates the stream
- * with the failure value of this effect.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromEffect = stream.fromEffect;
-
-/**
- * Creates a stream from an effect producing a value of type `A` or an empty
- * `Stream`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromEffectOption = stream.fromEffectOption;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const fromHub = stream.fromHub;
-
-/**
- * Creates a stream from an `Iterable` collection of values.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromIterable = stream.fromIterable;
-
-/**
- * Creates a stream from an effect producing a value of type `Iterable<A>`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromIterableEffect = stream.fromIterableEffect;
-
-/**
- * Creates a stream from an iterator
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromIteratorSucceed = stream.fromIteratorSucceed;
-
-/**
- * Creates a stream from an effect that pulls elements from another stream.
- *
- * See `Stream.toPull` for reference.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromPull = stream.fromPull;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const fromQueue = stream.fromQueue;
-
-/**
- * Creates a stream from a `ReadableStream`.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const fromReadableStream = stream.fromReadableStream;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const fromReadableStreamByob = stream.fromReadableStreamByob;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const fromSchedule = stream.fromSchedule;
-
-/**
- * Creates a pipeline that groups on adjacent keys, calculated by the
- * specified function.
- *
- * @since 1.0.0
- * @category grouping
- */
-const groupAdjacentBy = stream.groupAdjacentBy;
-
-/**
- * More powerful version of `Stream.groupByKey`.
- *
- * @since 1.0.0
- * @category grouping
- */
-const groupBy = groupBy$1.groupBy;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const groupByKey = groupBy$1.groupByKey;
-
-/**
- * Partitions the stream with specified `chunkSize`.
- *
- * @since 1.0.0
- * @category utils
- */
-const grouped = stream.grouped;
-
-/**
- * Partitions the stream with the specified `chunkSize` or until the specified
- * `duration` has passed, whichever is satisfied first.
- *
- * @since 1.0.0
- * @category utils
- */
-const groupedWithin = stream.groupedWithin;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const haltAfter = stream.haltAfter;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const haltWhen = stream.haltWhen;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const haltWhenDeferred = stream.haltWhenDeferred;
-
-/**
- * The identity pipeline, which does not modify streams in any way.
- *
- * @since 1.0.0
- * @category utils
- */
-const identity = stream.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 1.0.0
- * @category utils
- */
-const interleave = stream.interleave;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const interleaveWith = stream.interleaveWith;
-
-/**
- * Intersperse stream with provided `element`.
- *
- * @since 1.0.0
- * @category utils
- */
-const intersperse = stream.intersperse;
-
-/**
- * Intersperse the specified element, also adding a prefix and a suffix.
- *
- * @since 1.0.0
- * @category utils
- */
-const intersperseAffixes = stream.intersperseAffixes;
-
-/**
- * Specialized version of `Stream.interruptWhen` which interrupts the
- * evaluation of this stream after the given `Duration`.
- *
- * @since 1.0.0
- * @category utils
- */
-const interruptAfter = stream.interruptAfter;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const interruptWhen = stream.interruptWhen;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const interruptWhenDeferred = stream.interruptWhenDeferred;
-
-/**
- * The infinite stream of iterative function application: a, f(a), f(f(a)),
- * f(f(f(a))), ...
- *
- * @since 1.0.0
- * @category constructors
- */
-const iterate = stream.iterate;
-
-/**
- * Creates a stream from an sequence of values.
- *
- * @since 1.0.0
- * @category constructors
- */
-const make = stream.make;
-
-/**
- * Transforms the elements of this stream using the supplied function.
- *
- * @since 1.0.0
- * @category mapping
- */
-const map = stream.map;
-
-/**
- * Statefully maps over the elements of this stream to produce new elements.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapAccum = stream.mapAccum;
-
-/**
- * Statefully and effectfully maps over the elements of this stream to produce
- * new elements.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapAccumEffect = stream.mapAccumEffect;
-
-/**
- * Returns a stream whose failure and success channels have been mapped by the
- * specified `onFailure` and `onSuccess` functions.
- *
- * @since 1.0.0
- * @category utils
- */
-const mapBoth = stream.mapBoth;
-
-/**
- * Transforms the chunks emitted by this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapChunks = stream.mapChunks;
-
-/**
- * Effectfully transforms the chunks emitted by this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapChunksEffect = stream.mapChunksEffect;
-
-/**
- * Maps each element to an iterable, and flattens the iterables into the
- * output of this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapConcat = stream.mapConcat;
-
-/**
- * Maps each element to a chunk, and flattens the chunks into the output of
- * this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapConcatChunk = stream.mapConcatChunk;
-
-/**
- * Effectfully maps each element to a chunk, and flattens the chunks into the
- * output of this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapConcatChunkEffect = stream.mapConcatChunkEffect;
-
-/**
- * Effectfully maps each element to an iterable, and flattens the iterables
- * into the output of this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapConcatEffect = stream.mapConcatEffect;
-
-/**
- * Maps over elements of the stream with the specified effectful function.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapEffect = groupBy$1.mapEffectOptions;
-
-/**
- * Transforms the errors emitted by this stream using `f`.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapError = stream.mapError;
-
-/**
- * Transforms the full causes of failures emitted by this stream.
- *
- * @since 1.0.0
- * @category mapping
- */
-const mapErrorCause = stream.mapErrorCause;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const merge = stream.merge;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const mergeAll = stream.mergeAll;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const mergeWith = stream.mergeWith;
-
-/**
- * Merges this stream and the specified stream together to produce a stream of
- * eithers.
- *
- * @since 1.0.0
- * @category utils
- */
-const mergeEither = stream.mergeEither;
-
-/**
- * Merges this stream and the specified stream together, discarding the values
- * from the right stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const mergeLeft = stream.mergeLeft;
-
-/**
- * Merges this stream and the specified stream together, discarding the values
- * from the left stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const mergeRight = stream.mergeRight;
-
-/**
- * Returns a combined string resulting from concatenating each of the values
- * from the stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const mkString = stream.mkString;
-
-/**
- * The stream that never produces any value or fails with any error.
- *
- * @since 1.0.0
- * @category constructors
- */
-const never = stream.never;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const onError = stream.onError;
-
-/**
- * Runs the specified effect if this stream ends.
- *
- * @since 1.0.0
- * @category utils
- */
-const onDone = stream.onDone;
-
-/**
- * Translates any failure into a stream termination, making the stream
- * infallible and all failures unchecked.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orDie = stream.orDie;
-
-/**
- * Keeps none of the errors, and terminates the stream with them, using the
- * specified function to convert the `E` into a defect.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orDieWith = stream.orDieWith;
-
-/**
- * Switches to the provided stream in case this one fails with a typed error.
- *
- * See also `Stream.catchAll`.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElse = stream.orElse;
-
-/**
- * Switches to the provided stream in case this one fails with a typed error.
- *
- * See also `Stream.catchAll`.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseEither = stream.orElseEither;
-
-/**
- * Fails with given error in case this one fails with a typed error.
- *
- * See also `Stream.catchAll`.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseFail = stream.orElseFail;
-
-/**
- * Produces the specified element if this stream is empty.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseIfEmpty = stream.orElseIfEmpty;
-
-/**
- * Produces the specified chunk if this stream is empty.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseIfEmptyChunk = stream.orElseIfEmptyChunk;
-
-/**
- * Switches to the provided stream in case this one is empty.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseIfEmptyStream = stream.orElseIfEmptyStream;
-
-/**
- * Succeeds with the specified value if this one fails with a typed error.
- *
- * @since 1.0.0
- * @category error handling
- */
-const orElseSucceed = stream.orElseSucceed;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const paginate = stream.paginate;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const paginateChunk = stream.paginateChunk;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const paginateChunkEffect = stream.paginateChunkEffect;
-
-/**
- * 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 1.0.0
- * @category constructors
- */
-const paginateEffect = stream.paginateEffect;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const partition = stream.partition;
-
-/**
- * Split a stream by an effectful predicate. The faster stream may advance by
- * up to buffer elements further than the slower one.
- *
- * @since 1.0.0
- * @category utils
- */
-const partitionEither = stream.partitionEither;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const peel = stream.peel;
-
-/**
- * Pipes all of the values from this stream through the provided sink.
- *
- * See also `Stream.transduce`.
- *
- * @since 1.0.0
- * @category utils
- */
-const pipeThrough = stream.pipeThrough;
-
-/**
- * Pipes all the values from this stream through the provided channel.
- *
- * @since 1.0.0
- * @category utils
- */
-const pipeThroughChannel = stream.pipeThroughChannel;
-
-/**
- * Pipes all values from this stream through the provided channel, passing
- * through any error emitted by this stream unchanged.
- *
- * @since 1.0.0
- * @category utils
- */
-const pipeThroughChannelOrFail = stream.pipeThroughChannelOrFail;
-
-/**
- * Emits the provided chunk before emitting any other value.
- *
- * @since 1.0.0
- * @category utils
- */
-const prepend = stream.prepend;
-
-/**
- * Provides the stream with its required context, which eliminates its
- * dependency on `R`.
- *
- * @since 1.0.0
- * @category context
- */
-const provideContext = stream.provideContext;
-
-/**
- * Provides a `Layer` to the stream, which translates it to another level.
- *
- * @since 1.0.0
- * @category context
- */
-const provideLayer = stream.provideLayer;
-
-/**
- * Provides the stream with the single service it requires. If the stream
- * requires more than one service use `Stream.provideContext` instead.
- *
- * @since 1.0.0
- * @category context
- */
-const provideService = stream.provideService;
-
-/**
- * Provides the stream with the single service it requires. If the stream
- * requires more than one service use `Stream.provideContext` instead.
- *
- * @since 1.0.0
- * @category context
- */
-const provideServiceEffect = stream.provideServiceEffect;
-
-/**
- * Provides the stream with the single service it requires. If the stream
- * requires more than one service use `Stream.provideContext` instead.
- *
- * @since 1.0.0
- * @category context
- */
-const provideServiceStream = stream.provideServiceStream;
-
-/**
- * Transforms the context being provided to the stream with the specified
- * function.
- *
- * @since 1.0.0
- * @category context
- */
-const mapInputContext = stream.mapInputContext;
-
-/**
- * Splits the context into two parts, providing one part using the
- * specified layer and leaving the remainder `R0`.
- *
- * @since 1.0.0
- * @category context
- */
-const provideSomeLayer = stream.provideSomeLayer;
-
-/**
- * Constructs a stream from a range of integers, including both endpoints.
- *
- * @since 1.0.0
- * @category constructors
- */
-const range = stream.range;
-
-/**
- * Re-chunks the elements of the stream into chunks of `n` elements each. The
- * last chunk might contain less than `n` elements.
- *
- * @since 1.0.0
- * @category utils
- */
-const rechunk = stream.rechunk;
-
-/**
- * Keeps some of the errors, and terminates the fiber with the rest
- *
- * @since 1.0.0
- * @category error handling
- */
-const refineOrDie = stream.refineOrDie;
-
-/**
- * Keeps some of the errors, and terminates the fiber with the rest, using the
- * specified function to convert the `E` into a defect.
- *
- * @since 1.0.0
- * @category error handling
- */
-const refineOrDieWith = stream.refineOrDieWith;
-
-/**
- * Repeats the entire stream using the specified schedule. The stream will
- * execute normally, and then repeat again according to the provided schedule.
- *
- * @since 1.0.0
- * @category utils
- */
-const repeat = stream.repeat;
-
-/**
- * Creates a stream from an effect producing a value of type `A` which repeats
- * forever.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatEffect = stream.repeatEffect;
-
-/**
- * Creates a stream from an effect producing chunks of `A` values which
- * repeats forever.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatEffectChunk = stream.repeatEffectChunk;
-
-/**
- * Creates a stream from an effect producing chunks of `A` values until it
- * fails with `None`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatEffectChunkOption = stream.repeatEffectChunkOption;
-
-/**
- * Creates a stream from an effect producing values of type `A` until it fails
- * with `None`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatEffectOption = stream.repeatEffectOption;
-
-/**
- * Creates a stream from an effect producing a value of type `A`, which is
- * repeated using the specified schedule.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatEffectWithSchedule = stream.repeatEffectWithSchedule;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const repeatEither = stream.repeatEither;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const repeatElements = stream.repeatElements;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const repeatElementsWith = stream.repeatElementsWith;
-
-/**
- * Repeats the provided value infinitely.
- *
- * @since 1.0.0
- * @category constructors
- */
-const repeatValue = stream.repeatValue;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const repeatWith = stream.repeatWith;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const retry = stream.retry;
-
-/**
- * Runs the sink on the stream to produce either the sink's result or an error.
- *
- * @since 1.0.0
- * @category destructors
- */
-const run = stream.run;
-
-/**
- * Runs the stream and collects all of its elements to a chunk.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runCollect = stream.runCollect;
-
-/**
- * Runs the stream and emits the number of elements processed
- *
- * @since 1.0.0
- * @category destructors
- */
-const runCount = stream.runCount;
-
-/**
- * Runs the stream only for its effects. The emitted elements are discarded.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runDrain = stream.runDrain;
-
-/**
- * Executes a pure fold over the stream of values - reduces all elements in
- * the stream to a value of type `S`.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runFold = stream.runFold;
-
-/**
- * Executes an effectful fold over the stream of values.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runFoldEffect = stream.runFoldEffect;
-
-/**
- * Executes a pure fold over the stream of values. Returns a scoped value that
- * represents the scope of the stream.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runFoldScoped = stream.runFoldScoped;
-
-/**
- * Executes an effectful fold over the stream of values. Returns a scoped
- * value that represents the scope of the stream.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runFoldScopedEffect = stream.runFoldScopedEffect;
-
-/**
- * Reduces the elements in the stream to a value of type `S`. Stops the fold
- * early when the condition is not fulfilled. Example:
- *
- * @since 1.0.0
- * @category destructors
- */
-const runFoldWhile = stream.runFoldWhile;
-
-/**
- * Executes an effectful fold over the stream of values. Stops the fold early
- * when the condition is not fulfilled.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runFoldWhileEffect = stream.runFoldWhileEffect;
-
-/**
- * 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 1.0.0
- * @category destructors
- */
-const runFoldWhileScoped = stream.runFoldWhileScoped;
-
-/**
- * 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 1.0.0
- * @category destructors
- */
-const runFoldWhileScopedEffect = stream.runFoldWhileScopedEffect;
-
-/**
- * Consumes all elements of the stream, passing them to the specified
- * callback.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runForEach = stream.runForEach;
-
-/**
- * Consumes all elements of the stream, passing them to the specified
- * callback.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runForEachChunk = stream.runForEachChunk;
-
-/**
- * Like `Stream.runForEachChunk`, but returns a scoped effect so the
- * finalization order can be controlled.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runForEachChunkScoped = stream.runForEachChunkScoped;
-
-/**
- * Like `Stream.forEach`, but returns a scoped effect so the finalization
- * order can be controlled.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runForEachScoped = stream.runForEachScoped;
-
-/**
- * Consumes elements of the stream, passing them to the specified callback,
- * and terminating consumption when the callback returns `false`.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runForEachWhile = stream.runForEachWhile;
-
-/**
- * Like `Stream.runForEachWhile`, but returns a scoped effect so the
- * finalization order can be controlled.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runForEachWhileScoped = stream.runForEachWhileScoped;
-
-/**
- * Runs the stream to completion and yields the first value emitted by it,
- * discarding the rest of the elements.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runHead = stream.runHead;
-
-/**
- * Publishes elements of this stream to a hub. Stream failure and ending will
- * also be signalled.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runIntoHub = stream.runIntoHub;
-
-/**
- * Like `Stream.runIntoHub`, but provides the result as a scoped effect to
- * allow for scope composition.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runIntoHubScoped = stream.runIntoHubScoped;
-
-/**
- * Enqueues elements of this stream into a queue. Stream failure and ending
- * will also be signalled.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runIntoQueue = stream.runIntoQueue;
-
-/**
- * Like `Stream.runIntoQueue`, but provides the result as a scoped [[ZIO]]
- * to allow for scope composition.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runIntoQueueElementsScoped = stream.runIntoQueueElementsScoped;
-
-/**
- * Like `Stream.runIntoQueue`, but provides the result as a scoped effect
- * to allow for scope composition.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runIntoQueueScoped = stream.runIntoQueueScoped;
-
-/**
- * Runs the stream to completion and yields the last value emitted by it,
- * discarding the rest of the elements.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runLast = stream.runLast;
-
-/**
- * @since 1.0.0
- * @category destructors
- */
-const runScoped = stream.runScoped;
-
-/**
- * Runs the stream to a sink which sums elements, provided they are Numeric.
- *
- * @since 1.0.0
- * @category destructors
- */
-const runSum = stream.runSum;
-
-/**
- * Statefully maps over the elements of this stream to produce all
- * intermediate results of type `S` given an initial S.
- *
- * @since 1.0.0
- * @category utils
- */
-const scan = stream.scan;
-
-/**
- * Statefully and effectfully maps over the elements of this stream to produce
- * all intermediate results of type `S` given an initial S.
- *
- * @since 1.0.0
- * @category utils
- */
-const scanEffect = stream.scanEffect;
-
-/**
- * Statefully maps over the elements of this stream to produce all
- * intermediate results.
- *
- * See also `Stream.scan`.
- *
- * @since 1.0.0
- * @category utils
- */
-const scanReduce = stream.scanReduce;
-
-/**
- * Statefully and effectfully maps over the elements of this stream to produce
- * all intermediate results.
- *
- * See also `Stream.scanEffect`.
- *
- * @since 1.0.0
- * @category utils
- */
-const scanReduceEffect = stream.scanReduceEffect;
-
-/**
- * Schedules the output of the stream using the provided `schedule`.
- *
- * @since 1.0.0
- * @category utils
- */
-const schedule = stream.schedule;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const scheduleWith = stream.scheduleWith;
-
-/**
- * Creates a single-valued stream from a scoped resource.
- *
- * @since 1.0.0
- * @category constructors
- */
-const scoped = stream.scoped;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const sliding = stream.sliding;
-
-/**
- * Like `sliding`, but with a configurable `stepSize` parameter.
- *
- * @since 1.0.0
- * @category utils
- */
-const slidingSize = stream.slidingSize;
-
-/**
- * Converts an option on values into an option on errors.
- *
- * @since 1.0.0
- * @category utils
- */
-const some = stream.some;
-
-/**
- * Extracts the optional value, or returns the given 'default'.
- *
- * @since 1.0.0
- * @category utils
- */
-const someOrElse = stream.someOrElse;
-
-/**
- * Extracts the optional value, or fails with the given error 'e'.
- *
- * @since 1.0.0
- * @category utils
- */
-const someOrFail = stream.someOrFail;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const split = stream.split;
-
-/**
- * Splits elements on a delimiter and transforms the splits into desired output.
- *
- * @since 1.0.0
- * @category utils
- */
-const splitOnChunk = stream.splitOnChunk;
-
-/**
- * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
- * newlines (`\n`).
- *
- * @since 1.0.0
- * @category combinators
- */
-const splitLines = stream.splitLines;
-
-/**
- * Creates a single-valued pure stream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const succeed = stream.succeed;
-
-/**
- * Creates a single-valued pure stream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const sync = stream.sync;
-
-/**
- * Returns a lazily constructed stream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const suspend = stream.suspend;
-
-/**
- * Takes the specified number of elements from this stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const take = stream.take;
-
-/**
- * Takes the last specified number of elements from this stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const takeRight = stream.takeRight;
-
-/**
- * Takes all elements of the stream until the specified predicate evaluates to
- * `true`.
- *
- * @since 1.0.0
- * @category utils
- */
-const takeUntil = stream.takeUntil;
-
-/**
- * Takes all elements of the stream until the specified effectual predicate
- * evaluates to `true`.
- *
- * @since 1.0.0
- * @category utils
- */
-const takeUntilEffect = stream.takeUntilEffect;
-
-/**
- * Takes all elements of the stream for as long as the specified predicate
- * evaluates to `true`.
- *
- * @since 1.0.0
- * @category utils
- */
-const takeWhile = stream.takeWhile;
-
-/**
- * Adds an effect to consumption of every element of the stream.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tap = stream.tap;
-
-/**
- * Returns a stream that effectfully "peeks" at the failure or success of
- * the stream.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapBoth = stream.tapBoth;
-
-/**
- * Returns a stream that effectfully "peeks" at the failure of the stream.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapError = stream.tapError;
-
-/**
- * Returns a stream that effectfully "peeks" at the cause of failure of the
- * stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const tapErrorCause = stream.tapErrorCause;
-
-/**
- * Sends all elements emitted by this stream to the specified sink in addition
- * to emitting them.
- *
- * @since 1.0.0
- * @category sequencing
- */
-const tapSink = stream.tapSink;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const throttle = stream.throttle;
-
-/**
- * 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 1.0.0
- * @category utils
- */
-const throttleEffect = stream.throttleEffect;
-
-/**
- * A stream that emits Unit values spaced by the specified duration.
- *
- * @since 1.0.0
- * @category constructors
- */
-const tick = stream.tick;
-
-/**
- * Ends the stream if it does not produce a value after the specified duration.
- *
- * @since 1.0.0
- * @category utils
- */
-const timeout = stream.timeout;
-
-/**
- * Fails the stream with given error if it does not produce a value after d
- * duration.
- *
- * @since 1.0.0
- * @category utils
- */
-const timeoutFail = stream.timeoutFail;
-
-/**
- * Fails the stream with given cause if it does not produce a value after d
- * duration.
- *
- * @since 1.0.0
- * @category utils
- */
-const timeoutFailCause = stream.timeoutFailCause;
-
-/**
- * Switches the stream if it does not produce a value after the specified
- * duration.
- *
- * @since 1.0.0
- * @category utils
- */
-const timeoutTo = stream.timeoutTo;
-
-/**
- * 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 1.0.0
- * @category destructors
- */
-const toHub = stream.toHub;
-
-/**
- * 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 1.0.0
- * @category destructors
- */
-const toPull = stream.toPull;
-
-/**
- * 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 1.0.0
- * @category destructors
- */
-const toQueue = stream.toQueue;
-
-/**
- * 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 1.0.0
- * @category destructors
- */
-const toQueueOfElements = stream.toQueueOfElements;
-
-/**
- * Converts the stream to a `ReadableStream`.
- *
- * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
- *
- * @since 1.0.0
- * @category destructors
- */
-const toReadableStream = stream.toReadableStream;
-
-/**
- * Applies the transducer to the stream and emits its outputs.
- *
- * @since 1.0.0
- * @category utils
- */
-const transduce = stream.transduce;
-
-/**
- * Creates a stream by peeling off the "layers" of a value of type `S`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unfold = stream.unfold;
-
-/**
- * Creates a stream by peeling off the "layers" of a value of type `S`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unfoldChunk = stream.unfoldChunk;
-
-/**
- * Creates a stream by effectfully peeling off the "layers" of a value of type
- * `S`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unfoldChunkEffect = stream.unfoldChunkEffect;
-
-/**
- * Creates a stream by effectfully peeling off the "layers" of a value of type
- * `S`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unfoldEffect = stream.unfoldEffect;
-
-/**
- * A stream that contains a single `Unit` value.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unit = stream.unit;
-
-/**
- * Creates a stream produced from an `Effect`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unwrap = stream.unwrap;
-
-/**
- * Creates a stream produced from a scoped `Effect`.
- *
- * @since 1.0.0
- * @category constructors
- */
-const unwrapScoped = stream.unwrapScoped;
-
-/**
- * Updates the specified service within the context of the `Stream`.
- *
- * @since 1.0.0
- * @category context
- */
-const updateService = stream.updateService;
-
-/**
- * Returns the specified stream if the given condition is satisfied, otherwise
- * returns an empty stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const when = stream.when;
-
-/**
- * Returns the resulting stream when the given `PartialFunction` is defined
- * for the given value, otherwise returns an empty stream.
- *
- * @since 1.0.0
- * @category constructors
- */
-const whenCase = stream.whenCase;
-
-/**
- * Returns the stream when the given partial function is defined for the given
- * effectful value, otherwise returns an empty stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const whenCaseEffect = stream.whenCaseEffect;
-
-/**
- * Returns the stream if the given effectful condition is satisfied, otherwise
- * returns an empty stream.
- *
- * @since 1.0.0
- * @category utils
- */
-const whenEffect = stream.whenEffect;
-
-/**
- * Wraps the stream with a new span for tracing.
- *
- * @since 1.0.0
- * @category tracing
- */
-const withSpan = stream.withSpan;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zip = stream.zip;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipFlatten = stream.zipFlatten;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAll = stream.zipAll;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllLeft = stream.zipAllLeft;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllRight = stream.zipAllRight;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllSortedByKey = stream.zipAllSortedByKey;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllSortedByKeyLeft = stream.zipAllSortedByKeyLeft;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllSortedByKeyRight = stream.zipAllSortedByKeyRight;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllSortedByKeyWith = stream.zipAllSortedByKeyWith;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipAllWith = stream.zipAllWith;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipLatest = stream.zipLatest;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipLatestWith = stream.zipLatestWith;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipLeft = stream.zipLeft;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipRight = stream.zipRight;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipWith = stream.zipWith;
-
-/**
- * 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 1.0.0
- * @category zipping
- */
-const zipWithChunks = stream.zipWithChunks;
-
-/**
- * Zips each element with the next element if present.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipWithNext = stream.zipWithNext;
-
-/**
- * Zips each element with the previous element. Initially accompanied by
- * `None`.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipWithPrevious = stream.zipWithPrevious;
-
-/**
- * Zips each element with both the previous and next element.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipWithPreviousAndNext = stream.zipWithPreviousAndNext;
-
-/**
- * Zips this stream together with the index of elements.
- *
- * @since 1.0.0
- * @category zipping
- */
-const zipWithIndex = stream.zipWithIndex;
-
-// -------------------------------------------------------------------------------------
-// Do notation
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 1.0.0
- * @category do notation
- */
-const Do = stream.Do;
-
-/**
- * Binds a value from a stream in a `do` scope
- *
- * @since 1.0.0
- * @category do notation
- */
-const bind = stream.bind;
-
-/**
- * Binds an effectful value in a `do` scope
- *
- * @since 1.0.0
- * @category do notation
- */
-const bindEffect = groupBy$1.bindEffect;
-
-/**
- * @since 1.0.0
- * @category do notation
- */
-const bindTo = stream.bindTo;
-const let_ = stream.let_;
-
-// -------------------------------------------------------------------------------------
-// encoding
-// -------------------------------------------------------------------------------------
-
-/**
- * Decode Uint8Array chunks into a stream of strings using the specified encoding.
- *
- * @since 1.0.0
- * @category encoding
- */
-const decodeText = stream.decodeText;
-
-/**
- * Encode a stream of strings into a stream of Uint8Array chunks using the specified encoding.
- *
- * @since 1.0.0
- * @category encoding
- */
-const encodeText = stream.encodeText;
-
-var Stream = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  StreamTypeId: StreamTypeId,
-  DefaultChunkSize: DefaultChunkSize,
-  acquireRelease: acquireRelease,
-  aggregate: aggregate,
-  aggregateWithin: aggregateWithin,
-  aggregateWithinEither: aggregateWithinEither,
-  as: as,
-  async: _async,
-  asyncEffect: asyncEffect,
-  asyncInterrupt: asyncInterrupt,
-  asyncOption: asyncOption,
-  asyncScoped: asyncScoped,
-  branchAfter: branchAfter,
-  broadcast: broadcast,
-  broadcastDynamic: broadcastDynamic,
-  broadcastedQueues: broadcastedQueues,
-  broadcastedQueuesDynamic: broadcastedQueuesDynamic,
-  buffer: buffer,
-  bufferChunks: bufferChunks,
-  catchAll: catchAll,
-  catchAllCause: catchAllCause,
-  catchSome: catchSome,
-  catchTag: catchTag,
-  catchTags: catchTags,
-  catchSomeCause: catchSomeCause,
-  changes: changes,
-  changesWith: changesWith,
-  changesWithEffect: changesWithEffect,
-  chunks: chunks,
-  chunksWith: chunksWith,
-  combine: combine,
-  combineChunks: combineChunks,
-  concat: concat,
-  concatAll: concatAll,
-  cross: cross,
-  crossLeft: crossLeft,
-  crossRight: crossRight,
-  crossWith: crossWith,
-  debounce: debounce,
-  die: die,
-  dieSync: dieSync,
-  dieMessage: dieMessage,
-  distributedWith: distributedWith,
-  distributedWithDynamic: distributedWithDynamic,
-  drain: drain,
-  drainFork: drainFork,
-  drop: drop,
-  dropRight: dropRight,
-  dropUntil: dropUntil,
-  dropUntilEffect: dropUntilEffect,
-  dropWhile: dropWhile,
-  dropWhileEffect: dropWhileEffect,
-  either: either,
-  empty: empty,
-  ensuring: ensuring,
-  ensuringWith: ensuringWith,
-  context: context,
-  contextWith: contextWith,
-  contextWithEffect: contextWithEffect,
-  contextWithStream: contextWithStream,
-  execute: execute,
-  fail: fail,
-  failSync: failSync,
-  failCause: failCause,
-  failCauseSync: failCauseSync,
-  filter: filter,
-  filterEffect: filterEffect,
-  filterMap: filterMap,
-  filterMapEffect: filterMapEffect,
-  filterMapWhile: filterMapWhile,
-  filterMapWhileEffect: filterMapWhileEffect,
-  finalizer: finalizer,
-  find: find,
-  findEffect: findEffect,
-  flatMap: flatMap,
-  flatten: flatten,
-  flattenChunks: flattenChunks,
-  flattenEffect: flattenEffect,
-  flattenExitOption: flattenExitOption,
-  flattenIterables: flattenIterables,
-  flattenTake: flattenTake,
-  forever: forever,
-  fromAsyncIterable: fromAsyncIterable,
-  fromChannel: fromChannel,
-  toChannel: toChannel,
-  fromChunk: fromChunk,
-  fromChunkHub: fromChunkHub,
-  fromChunkQueue: fromChunkQueue,
-  fromChunks: fromChunks,
-  fromEffect: fromEffect,
-  fromEffectOption: fromEffectOption,
-  fromHub: fromHub,
-  fromIterable: fromIterable,
-  fromIterableEffect: fromIterableEffect,
-  fromIteratorSucceed: fromIteratorSucceed,
-  fromPull: fromPull,
-  fromQueue: fromQueue,
-  fromReadableStream: fromReadableStream,
-  fromReadableStreamByob: fromReadableStreamByob,
-  fromSchedule: fromSchedule,
-  groupAdjacentBy: groupAdjacentBy,
-  groupBy: groupBy,
-  groupByKey: groupByKey,
-  grouped: grouped,
-  groupedWithin: groupedWithin,
-  haltAfter: haltAfter,
-  haltWhen: haltWhen,
-  haltWhenDeferred: haltWhenDeferred,
-  identity: identity,
-  interleave: interleave,
-  interleaveWith: interleaveWith,
-  intersperse: intersperse,
-  intersperseAffixes: intersperseAffixes,
-  interruptAfter: interruptAfter,
-  interruptWhen: interruptWhen,
-  interruptWhenDeferred: interruptWhenDeferred,
-  iterate: iterate,
-  make: make,
-  map: map,
-  mapAccum: mapAccum,
-  mapAccumEffect: mapAccumEffect,
-  mapBoth: mapBoth,
-  mapChunks: mapChunks,
-  mapChunksEffect: mapChunksEffect,
-  mapConcat: mapConcat,
-  mapConcatChunk: mapConcatChunk,
-  mapConcatChunkEffect: mapConcatChunkEffect,
-  mapConcatEffect: mapConcatEffect,
-  mapEffect: mapEffect,
-  mapError: mapError,
-  mapErrorCause: mapErrorCause,
-  merge: merge,
-  mergeAll: mergeAll,
-  mergeWith: mergeWith,
-  mergeEither: mergeEither,
-  mergeLeft: mergeLeft,
-  mergeRight: mergeRight,
-  mkString: mkString,
-  never: never,
-  onError: onError,
-  onDone: onDone,
-  orDie: orDie,
-  orDieWith: orDieWith,
-  orElse: orElse,
-  orElseEither: orElseEither,
-  orElseFail: orElseFail,
-  orElseIfEmpty: orElseIfEmpty,
-  orElseIfEmptyChunk: orElseIfEmptyChunk,
-  orElseIfEmptyStream: orElseIfEmptyStream,
-  orElseSucceed: orElseSucceed,
-  paginate: paginate,
-  paginateChunk: paginateChunk,
-  paginateChunkEffect: paginateChunkEffect,
-  paginateEffect: paginateEffect,
-  partition: partition,
-  partitionEither: partitionEither,
-  peel: peel,
-  pipeThrough: pipeThrough,
-  pipeThroughChannel: pipeThroughChannel,
-  pipeThroughChannelOrFail: pipeThroughChannelOrFail,
-  prepend: prepend,
-  provideContext: provideContext,
-  provideLayer: provideLayer,
-  provideService: provideService,
-  provideServiceEffect: provideServiceEffect,
-  provideServiceStream: provideServiceStream,
-  mapInputContext: mapInputContext,
-  provideSomeLayer: provideSomeLayer,
-  range: range,
-  rechunk: rechunk,
-  refineOrDie: refineOrDie,
-  refineOrDieWith: refineOrDieWith,
-  repeat: repeat,
-  repeatEffect: repeatEffect,
-  repeatEffectChunk: repeatEffectChunk,
-  repeatEffectChunkOption: repeatEffectChunkOption,
-  repeatEffectOption: repeatEffectOption,
-  repeatEffectWithSchedule: repeatEffectWithSchedule,
-  repeatEither: repeatEither,
-  repeatElements: repeatElements,
-  repeatElementsWith: repeatElementsWith,
-  repeatValue: repeatValue,
-  repeatWith: repeatWith,
-  retry: retry,
-  run: run,
-  runCollect: runCollect,
-  runCount: runCount,
-  runDrain: runDrain,
-  runFold: runFold,
-  runFoldEffect: runFoldEffect,
-  runFoldScoped: runFoldScoped,
-  runFoldScopedEffect: runFoldScopedEffect,
-  runFoldWhile: runFoldWhile,
-  runFoldWhileEffect: runFoldWhileEffect,
-  runFoldWhileScoped: runFoldWhileScoped,
-  runFoldWhileScopedEffect: runFoldWhileScopedEffect,
-  runForEach: runForEach,
-  runForEachChunk: runForEachChunk,
-  runForEachChunkScoped: runForEachChunkScoped,
-  runForEachScoped: runForEachScoped,
-  runForEachWhile: runForEachWhile,
-  runForEachWhileScoped: runForEachWhileScoped,
-  runHead: runHead,
-  runIntoHub: runIntoHub,
-  runIntoHubScoped: runIntoHubScoped,
-  runIntoQueue: runIntoQueue,
-  runIntoQueueElementsScoped: runIntoQueueElementsScoped,
-  runIntoQueueScoped: runIntoQueueScoped,
-  runLast: runLast,
-  runScoped: runScoped,
-  runSum: runSum,
-  scan: scan,
-  scanEffect: scanEffect,
-  scanReduce: scanReduce,
-  scanReduceEffect: scanReduceEffect,
-  schedule: schedule,
-  scheduleWith: scheduleWith,
-  scoped: scoped,
-  sliding: sliding,
-  slidingSize: slidingSize,
-  some: some,
-  someOrElse: someOrElse,
-  someOrFail: someOrFail,
-  split: split,
-  splitOnChunk: splitOnChunk,
-  splitLines: splitLines,
-  succeed: succeed,
-  sync: sync,
-  suspend: suspend,
-  take: take,
-  takeRight: takeRight,
-  takeUntil: takeUntil,
-  takeUntilEffect: takeUntilEffect,
-  takeWhile: takeWhile,
-  tap: tap,
-  tapBoth: tapBoth,
-  tapError: tapError,
-  tapErrorCause: tapErrorCause,
-  tapSink: tapSink,
-  throttle: throttle,
-  throttleEffect: throttleEffect,
-  tick: tick,
-  timeout: timeout,
-  timeoutFail: timeoutFail,
-  timeoutFailCause: timeoutFailCause,
-  timeoutTo: timeoutTo,
-  toHub: toHub,
-  toPull: toPull,
-  toQueue: toQueue,
-  toQueueOfElements: toQueueOfElements,
-  toReadableStream: toReadableStream,
-  transduce: transduce,
-  unfold: unfold,
-  unfoldChunk: unfoldChunk,
-  unfoldChunkEffect: unfoldChunkEffect,
-  unfoldEffect: unfoldEffect,
-  unit: unit,
-  unwrap: unwrap,
-  unwrapScoped: unwrapScoped,
-  updateService: updateService,
-  when: when,
-  whenCase: whenCase,
-  whenCaseEffect: whenCaseEffect,
-  whenEffect: whenEffect,
-  withSpan: withSpan,
-  zip: zip,
-  zipFlatten: zipFlatten,
-  zipAll: zipAll,
-  zipAllLeft: zipAllLeft,
-  zipAllRight: zipAllRight,
-  zipAllSortedByKey: zipAllSortedByKey,
-  zipAllSortedByKeyLeft: zipAllSortedByKeyLeft,
-  zipAllSortedByKeyRight: zipAllSortedByKeyRight,
-  zipAllSortedByKeyWith: zipAllSortedByKeyWith,
-  zipAllWith: zipAllWith,
-  zipLatest: zipLatest,
-  zipLatestWith: zipLatestWith,
-  zipLeft: zipLeft,
-  zipRight: zipRight,
-  zipWith: zipWith,
-  zipWithChunks: zipWithChunks,
-  zipWithNext: zipWithNext,
-  zipWithPrevious: zipWithPrevious,
-  zipWithPreviousAndNext: zipWithPreviousAndNext,
-  zipWithIndex: zipWithIndex,
-  Do: Do,
-  bind: bind,
-  bindEffect: bindEffect,
-  bindTo: bindTo,
-  'let': let_,
-  decodeText: decodeText,
-  encodeText: encodeText
-});
-
-exports.DefaultChunkSize = DefaultChunkSize;
-exports.Do = Do;
-exports.Stream = Stream;
-exports.StreamTypeId = StreamTypeId;
-exports._async = _async;
-exports.acquireRelease = acquireRelease;
-exports.aggregate = aggregate;
-exports.aggregateWithin = aggregateWithin;
-exports.aggregateWithinEither = aggregateWithinEither;
-exports.as = as;
-exports.asyncEffect = asyncEffect;
-exports.asyncInterrupt = asyncInterrupt;
-exports.asyncOption = asyncOption;
-exports.asyncScoped = asyncScoped;
-exports.bind = bind;
-exports.bindEffect = bindEffect;
-exports.bindTo = bindTo;
-exports.branchAfter = branchAfter;
-exports.broadcast = broadcast;
-exports.broadcastDynamic = broadcastDynamic;
-exports.broadcastedQueues = broadcastedQueues;
-exports.broadcastedQueuesDynamic = broadcastedQueuesDynamic;
-exports.buffer = buffer;
-exports.bufferChunks = bufferChunks;
-exports.catchAll = catchAll;
-exports.catchAllCause = catchAllCause;
-exports.catchSome = catchSome;
-exports.catchSomeCause = catchSomeCause;
-exports.catchTag = catchTag;
-exports.catchTags = catchTags;
-exports.changes = changes;
-exports.changesWith = changesWith;
-exports.changesWithEffect = changesWithEffect;
-exports.chunks = chunks;
-exports.chunksWith = chunksWith;
-exports.combine = combine;
-exports.combineChunks = combineChunks;
-exports.concat = concat;
-exports.concatAll = concatAll;
-exports.context = context;
-exports.contextWith = contextWith;
-exports.contextWithEffect = contextWithEffect;
-exports.contextWithStream = contextWithStream;
-exports.cross = cross;
-exports.crossLeft = crossLeft;
-exports.crossRight = crossRight;
-exports.crossWith = crossWith;
-exports.debounce = debounce;
-exports.decodeText = decodeText;
-exports.die = die;
-exports.dieMessage = dieMessage;
-exports.dieSync = dieSync;
-exports.distributedWith = distributedWith;
-exports.distributedWithDynamic = distributedWithDynamic;
-exports.drain = drain;
-exports.drainFork = drainFork;
-exports.drop = drop;
-exports.dropRight = dropRight;
-exports.dropUntil = dropUntil;
-exports.dropUntilEffect = dropUntilEffect;
-exports.dropWhile = dropWhile;
-exports.dropWhileEffect = dropWhileEffect;
-exports.either = either;
-exports.empty = empty;
-exports.encodeText = encodeText;
-exports.ensuring = ensuring;
-exports.ensuringWith = ensuringWith;
-exports.execute = execute;
-exports.fail = fail;
-exports.failCause = failCause;
-exports.failCauseSync = failCauseSync;
-exports.failSync = failSync;
-exports.filter = filter;
-exports.filterEffect = filterEffect;
-exports.filterMap = filterMap;
-exports.filterMapEffect = filterMapEffect;
-exports.filterMapWhile = filterMapWhile;
-exports.filterMapWhileEffect = filterMapWhileEffect;
-exports.finalizer = finalizer;
-exports.find = find;
-exports.findEffect = findEffect;
-exports.flatMap = flatMap;
-exports.flatten = flatten;
-exports.flattenChunks = flattenChunks;
-exports.flattenEffect = flattenEffect;
-exports.flattenExitOption = flattenExitOption;
-exports.flattenIterables = flattenIterables;
-exports.flattenTake = flattenTake;
-exports.forever = forever;
-exports.fromAsyncIterable = fromAsyncIterable;
-exports.fromChannel = fromChannel;
-exports.fromChunk = fromChunk;
-exports.fromChunkHub = fromChunkHub;
-exports.fromChunkQueue = fromChunkQueue;
-exports.fromChunks = fromChunks;
-exports.fromEffect = fromEffect;
-exports.fromEffectOption = fromEffectOption;
-exports.fromHub = fromHub;
-exports.fromIterable = fromIterable;
-exports.fromIterableEffect = fromIterableEffect;
-exports.fromIteratorSucceed = fromIteratorSucceed;
-exports.fromPull = fromPull;
-exports.fromQueue = fromQueue;
-exports.fromReadableStream = fromReadableStream;
-exports.fromReadableStreamByob = fromReadableStreamByob;
-exports.fromSchedule = fromSchedule;
-exports.groupAdjacentBy = groupAdjacentBy;
-exports.groupBy = groupBy;
-exports.groupByKey = groupByKey;
-exports.grouped = grouped;
-exports.groupedWithin = groupedWithin;
-exports.haltAfter = haltAfter;
-exports.haltWhen = haltWhen;
-exports.haltWhenDeferred = haltWhenDeferred;
-exports.identity = identity;
-exports.interleave = interleave;
-exports.interleaveWith = interleaveWith;
-exports.interruptAfter = interruptAfter;
-exports.interruptWhen = interruptWhen;
-exports.interruptWhenDeferred = interruptWhenDeferred;
-exports.intersperse = intersperse;
-exports.intersperseAffixes = intersperseAffixes;
-exports.iterate = iterate;
-exports.let_ = let_;
-exports.make = make;
-exports.map = map;
-exports.mapAccum = mapAccum;
-exports.mapAccumEffect = mapAccumEffect;
-exports.mapBoth = mapBoth;
-exports.mapChunks = mapChunks;
-exports.mapChunksEffect = mapChunksEffect;
-exports.mapConcat = mapConcat;
-exports.mapConcatChunk = mapConcatChunk;
-exports.mapConcatChunkEffect = mapConcatChunkEffect;
-exports.mapConcatEffect = mapConcatEffect;
-exports.mapEffect = mapEffect;
-exports.mapError = mapError;
-exports.mapErrorCause = mapErrorCause;
-exports.mapInputContext = mapInputContext;
-exports.merge = merge;
-exports.mergeAll = mergeAll;
-exports.mergeEither = mergeEither;
-exports.mergeLeft = mergeLeft;
-exports.mergeRight = mergeRight;
-exports.mergeWith = mergeWith;
-exports.mkString = mkString;
-exports.never = never;
-exports.onDone = onDone;
-exports.onError = onError;
-exports.orDie = orDie;
-exports.orDieWith = orDieWith;
-exports.orElse = orElse;
-exports.orElseEither = orElseEither;
-exports.orElseFail = orElseFail;
-exports.orElseIfEmpty = orElseIfEmpty;
-exports.orElseIfEmptyChunk = orElseIfEmptyChunk;
-exports.orElseIfEmptyStream = orElseIfEmptyStream;
-exports.orElseSucceed = orElseSucceed;
-exports.paginate = paginate;
-exports.paginateChunk = paginateChunk;
-exports.paginateChunkEffect = paginateChunkEffect;
-exports.paginateEffect = paginateEffect;
-exports.partition = partition;
-exports.partitionEither = partitionEither;
-exports.peel = peel;
-exports.pipeThrough = pipeThrough;
-exports.pipeThroughChannel = pipeThroughChannel;
-exports.pipeThroughChannelOrFail = pipeThroughChannelOrFail;
-exports.prepend = prepend;
-exports.provideContext = provideContext;
-exports.provideLayer = provideLayer;
-exports.provideService = provideService;
-exports.provideServiceEffect = provideServiceEffect;
-exports.provideServiceStream = provideServiceStream;
-exports.provideSomeLayer = provideSomeLayer;
-exports.range = range;
-exports.rechunk = rechunk;
-exports.refineOrDie = refineOrDie;
-exports.refineOrDieWith = refineOrDieWith;
-exports.repeat = repeat;
-exports.repeatEffect = repeatEffect;
-exports.repeatEffectChunk = repeatEffectChunk;
-exports.repeatEffectChunkOption = repeatEffectChunkOption;
-exports.repeatEffectOption = repeatEffectOption;
-exports.repeatEffectWithSchedule = repeatEffectWithSchedule;
-exports.repeatEither = repeatEither;
-exports.repeatElements = repeatElements;
-exports.repeatElementsWith = repeatElementsWith;
-exports.repeatValue = repeatValue;
-exports.repeatWith = repeatWith;
-exports.retry = retry;
-exports.run = run;
-exports.runCollect = runCollect;
-exports.runCount = runCount;
-exports.runDrain = runDrain;
-exports.runFold = runFold;
-exports.runFoldEffect = runFoldEffect;
-exports.runFoldScoped = runFoldScoped;
-exports.runFoldScopedEffect = runFoldScopedEffect;
-exports.runFoldWhile = runFoldWhile;
-exports.runFoldWhileEffect = runFoldWhileEffect;
-exports.runFoldWhileScoped = runFoldWhileScoped;
-exports.runFoldWhileScopedEffect = runFoldWhileScopedEffect;
-exports.runForEach = runForEach;
-exports.runForEachChunk = runForEachChunk;
-exports.runForEachChunkScoped = runForEachChunkScoped;
-exports.runForEachScoped = runForEachScoped;
-exports.runForEachWhile = runForEachWhile;
-exports.runForEachWhileScoped = runForEachWhileScoped;
-exports.runHead = runHead;
-exports.runIntoHub = runIntoHub;
-exports.runIntoHubScoped = runIntoHubScoped;
-exports.runIntoQueue = runIntoQueue;
-exports.runIntoQueueElementsScoped = runIntoQueueElementsScoped;
-exports.runIntoQueueScoped = runIntoQueueScoped;
-exports.runLast = runLast;
-exports.runScoped = runScoped;
-exports.runSum = runSum;
-exports.scan = scan;
-exports.scanEffect = scanEffect;
-exports.scanReduce = scanReduce;
-exports.scanReduceEffect = scanReduceEffect;
-exports.schedule = schedule;
-exports.scheduleWith = scheduleWith;
-exports.scoped = scoped;
-exports.sliding = sliding;
-exports.slidingSize = slidingSize;
-exports.some = some;
-exports.someOrElse = someOrElse;
-exports.someOrFail = someOrFail;
-exports.split = split;
-exports.splitLines = splitLines;
-exports.splitOnChunk = splitOnChunk;
-exports.succeed = succeed;
-exports.suspend = suspend;
-exports.sync = sync;
-exports.take = take;
-exports.takeRight = takeRight;
-exports.takeUntil = takeUntil;
-exports.takeUntilEffect = takeUntilEffect;
-exports.takeWhile = takeWhile;
-exports.tap = tap;
-exports.tapBoth = tapBoth;
-exports.tapError = tapError;
-exports.tapErrorCause = tapErrorCause;
-exports.tapSink = tapSink;
-exports.throttle = throttle;
-exports.throttleEffect = throttleEffect;
-exports.tick = tick;
-exports.timeout = timeout;
-exports.timeoutFail = timeoutFail;
-exports.timeoutFailCause = timeoutFailCause;
-exports.timeoutTo = timeoutTo;
-exports.toChannel = toChannel;
-exports.toHub = toHub;
-exports.toPull = toPull;
-exports.toQueue = toQueue;
-exports.toQueueOfElements = toQueueOfElements;
-exports.toReadableStream = toReadableStream;
-exports.transduce = transduce;
-exports.unfold = unfold;
-exports.unfoldChunk = unfoldChunk;
-exports.unfoldChunkEffect = unfoldChunkEffect;
-exports.unfoldEffect = unfoldEffect;
-exports.unit = unit;
-exports.unwrap = unwrap;
-exports.unwrapScoped = unwrapScoped;
-exports.updateService = updateService;
-exports.when = when;
-exports.whenCase = whenCase;
-exports.whenCaseEffect = whenCaseEffect;
-exports.whenEffect = whenEffect;
-exports.withSpan = withSpan;
-exports.zip = zip;
-exports.zipAll = zipAll;
-exports.zipAllLeft = zipAllLeft;
-exports.zipAllRight = zipAllRight;
-exports.zipAllSortedByKey = zipAllSortedByKey;
-exports.zipAllSortedByKeyLeft = zipAllSortedByKeyLeft;
-exports.zipAllSortedByKeyRight = zipAllSortedByKeyRight;
-exports.zipAllSortedByKeyWith = zipAllSortedByKeyWith;
-exports.zipAllWith = zipAllWith;
-exports.zipFlatten = zipFlatten;
-exports.zipLatest = zipLatest;
-exports.zipLatestWith = zipLatestWith;
-exports.zipLeft = zipLeft;
-exports.zipRight = zipRight;
-exports.zipWith = zipWith;
-exports.zipWithChunks = zipWithChunks;
-exports.zipWithIndex = zipWithIndex;
-exports.zipWithNext = zipWithNext;
-exports.zipWithPrevious = zipWithPrevious;
-exports.zipWithPreviousAndNext = zipWithPreviousAndNext;