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

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

@@ -0,0 +1,997 @@
+import { SinkTypeId as SinkTypeId$1, as as as$1, collectAll as collectAll$1, collectAllN as collectAllN$1, collectAllFrom as collectAllFrom$1, collectAllToMap as collectAllToMap$1, collectAllToMapN as collectAllToMapN$1, collectAllToSet as collectAllToSet$1, collectAllToSetN as collectAllToSetN$1, collectAllUntil as collectAllUntil$1, collectAllUntilEffect as collectAllUntilEffect$1, collectAllWhile as collectAllWhile$1, collectAllWhileEffect as collectAllWhileEffect$1, collectAllWhileWith as collectAllWhileWith$1, collectLeftover as collectLeftover$1, mapInput as mapInput$1, mapInputEffect as mapInputEffect$1, mapInputChunks as mapInputChunks$1, mapInputChunksEffect as mapInputChunksEffect$1, count as count$1, die as die$1, dieMessage as dieMessage$1, dieSync as dieSync$1, dimap as dimap$1, dimapEffect as dimapEffect$1, dimapChunks as dimapChunks$1, dimapChunksEffect as dimapChunksEffect$1, drain as drain$1, drop as drop$1, dropUntil as dropUntil$1, dropUntilEffect as dropUntilEffect$1, dropWhile as dropWhile$1, dropWhileEffect as dropWhileEffect$1, ensuring as ensuring$1, ensuringWith as ensuringWith$1, context as context$1, contextWith as contextWith$1, contextWithEffect as contextWithEffect$1, contextWithSink as contextWithSink$1, every as every$1, fail as fail$1, failSync as failSync$1, failCause as failCause$1, failCauseSync as failCauseSync$1, filterInput as filterInput$1, filterInputEffect as filterInputEffect$1, findEffect as findEffect$1, fold as fold$1, foldSink as foldSink$1, foldChunks as foldChunks$1, foldChunksEffect as foldChunksEffect$1, foldEffect as foldEffect$1, foldLeft as foldLeft$1, foldLeftChunks as foldLeftChunks$1, foldLeftChunksEffect as foldLeftChunksEffect$1, foldLeftEffect as foldLeftEffect$1, foldUntil as foldUntil$1, foldUntilEffect as foldUntilEffect$1, foldWeighted as foldWeighted$1, foldWeightedDecompose as foldWeightedDecompose$1, foldWeightedDecomposeEffect as foldWeightedDecomposeEffect$1, foldWeightedEffect as foldWeightedEffect$1, forEach as forEach$1, forEachChunk as forEachChunk$1, forEachChunkWhile as forEachChunkWhile$1, forEachWhile as forEachWhile$1, flatMap as flatMap$1, fromChannel as fromChannel$1, toChannel as toChannel$1, fromEffect as fromEffect$1, fromHub as fromHub$1, fromPush as fromPush$1, fromQueue as fromQueue$1, head as head$1, ignoreLeftover as ignoreLeftover$1, last as last$1, leftover as leftover$1, map as map$1, mapEffect as mapEffect$1, mapError as mapError$1, mapLeftover as mapLeftover$1, mkString as mkString$1, never as never$1, orElse as orElse$1, provideContext as provideContext$1, race as race$1, raceBoth as raceBoth$1, raceWith as raceWith$1, refineOrDie as refineOrDie$1, refineOrDieWith as refineOrDieWith$1, some as some$1, splitWhere as splitWhere$1, succeed as succeed$1, sum as sum$1, summarized as summarized$1, suspend as suspend$1, sync as sync$1, take as take$1, timed as timed$1, unwrap as unwrap$1, unwrapScoped as unwrapScoped$1, withDuration as withDuration$1, zip as zip$1, zipLeft as zipLeft$1, zipRight as zipRight$1, zipWith as zipWith$1 } from '../../internal/sink.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const SinkTypeId = SinkTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Sink<R, E, In, L, Z>` is used to consume elements produced by a `Stream`.
+ * You can think of a sink as a function that will consume a variable amount of
+ * `In` elements (could be 0, 1, or many), might fail with an error of type `E`,
+ * and will eventually yield a value of type `Z` together with a remainder of
+ * type `L` (i.e. any leftovers).
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * Replaces this sink's result with the provided value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = as$1;
+
+/**
+ * A sink that collects all elements into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAll = collectAll$1;
+
+/**
+ * A sink that collects first `n` elements into a chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllN = collectAllN$1;
+
+/**
+ * Repeatedly runs the sink and accumulates its results into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectAllFrom = collectAllFrom$1;
+
+/**
+ * A sink that collects all of its inputs into a map. The keys are extracted
+ * from inputs using the keying function `key`; if multiple inputs use the
+ * same key, they are merged using the `merge` function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllToMap = collectAllToMap$1;
+
+/**
+ * A sink that collects first `n` keys into a map. The keys are calculated
+ * from inputs using the keying function `key`; if multiple inputs use the the
+ * same key, they are merged using the `merge` function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllToMapN = collectAllToMapN$1;
+
+/**
+ * A sink that collects all of its inputs into a set.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllToSet = collectAllToSet$1;
+
+/**
+ * A sink that collects first `n` distinct inputs into a set.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllToSetN = collectAllToSetN$1;
+
+/**
+ * Accumulates incoming elements into a chunk until predicate `p` is
+ * satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllUntil = collectAllUntil$1;
+
+/**
+ * Accumulates incoming elements into a chunk until effectful predicate `p` is
+ * satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllUntilEffect = collectAllUntilEffect$1;
+
+/**
+ * Accumulates incoming elements into a chunk as long as they verify predicate
+ * `p`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllWhile = collectAllWhile$1;
+
+/**
+ * Accumulates incoming elements into a chunk as long as they verify effectful
+ * predicate `p`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllWhileEffect = collectAllWhileEffect$1;
+
+/**
+ * Repeatedly runs the sink for as long as its results satisfy the predicate
+ * `p`. The sink's results will be accumulated using the stepping function `f`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectAllWhileWith = collectAllWhileWith$1;
+
+/**
+ * Collects the leftovers from the stream when the sink succeeds and returns
+ * them as part of the sink's result.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectLeftover = collectLeftover$1;
+
+/**
+ * Transforms this sink's input elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInput = mapInput$1;
+
+/**
+ * Effectfully transforms this sink's input elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputEffect = mapInputEffect$1;
+
+/**
+ * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputChunks = mapInputChunks$1;
+
+/**
+ * Effectfully transforms this sink's input chunks. `f` must preserve
+ * chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputChunksEffect = mapInputChunksEffect$1;
+
+/**
+ * A sink that counts the number of elements fed to it.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const count = count$1;
+
+/**
+ * Creates a sink halting with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = die$1;
+
+/**
+ * Creates a sink halting with the specified message, wrapped in a
+ * `RuntimeException`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = dieMessage$1;
+
+/**
+ * Creates a sink halting with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = dieSync$1;
+
+/**
+ * Transforms both inputs and result of this sink using the provided
+ * functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimap = dimap$1;
+
+/**
+ * Effectfully transforms both inputs and result of this sink using the
+ * provided functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimapEffect = dimapEffect$1;
+
+/**
+ * Transforms both input chunks and result of this sink using the provided
+ * functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimapChunks = dimapChunks$1;
+
+/**
+ * Effectfully transforms both input chunks and result of this sink using the
+ * provided functions. `f` and `g` must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimapChunksEffect = dimapChunksEffect$1;
+
+/**
+ * A sink that ignores its inputs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const drain = drain$1;
+
+/**
+ * Creates a sink that drops `n` elements.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const drop = drop$1;
+
+/**
+ * Drops incoming elements until the predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropUntil = dropUntil$1;
+
+/**
+ * Drops incoming elements until the effectful predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropUntilEffect = dropUntilEffect$1;
+
+/**
+ * Drops incoming elements as long as the predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropWhile = dropWhile$1;
+
+/**
+ * Drops incoming elements as long as the effectful predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropWhileEffect = dropWhileEffect$1;
+
+/**
+ * Returns a new sink with an attached finalizer. The finalizer is guaranteed
+ * to be executed so long as the sink begins execution (and regardless of
+ * whether or not it completes).
+ *
+ * @since 2.0.0
+ * @category finalization
+ */
+const ensuring = ensuring$1;
+
+/**
+ * Returns a new sink with an attached finalizer. The finalizer is guaranteed
+ * to be executed so long as the sink begins execution (and regardless of
+ * whether or not it completes).
+ *
+ * @since 2.0.0
+ * @category finalization
+ */
+const ensuringWith = ensuringWith$1;
+
+/**
+ * Accesses the whole context of the sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = context$1;
+
+/**
+ * Accesses the context of the sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWith = contextWith$1;
+
+/**
+ * Accesses the context of the sink in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithEffect = contextWithEffect$1;
+
+/**
+ * Accesses the context of the sink in the context of a sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithSink = contextWithSink$1;
+
+/**
+ * A sink that returns whether all elements satisfy the specified predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const every = every$1;
+
+/**
+ * A sink that always fails with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * A sink that always fails with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = failSync$1;
+
+/**
+ * Creates a sink halting with a specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = failCause$1;
+
+/**
+ * Creates a sink halting with a specified lazily evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = failCauseSync$1;
+
+/**
+ * Filters the sink's input with the given predicate.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterInput = filterInput$1;
+
+/**
+ * Effectfully filter the input of this sink using the specified predicate.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterInputEffect = filterInputEffect$1;
+
+/**
+ * Creates a sink that produces values until one verifies the predicate `f`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const findEffect = findEffect$1;
+
+/**
+ * A sink that folds its inputs with the provided function, termination
+ * predicate and initial state.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const fold = fold$1;
+
+/**
+ * Folds over the result of the sink
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const foldSink = foldSink$1;
+
+/**
+ * A sink that folds its input chunks with the provided function, termination
+ * predicate and initial state. `contFn` condition is checked only for the
+ * initial value and at the end of processing of each chunk. `f` and `contFn`
+ * must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldChunks = foldChunks$1;
+
+/**
+ * A sink that effectfully folds its input chunks with the provided function,
+ * termination predicate and initial state. `contFn` condition is checked only
+ * for the initial value and at the end of processing of each chunk. `f` and
+ * `contFn` must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldChunksEffect = foldChunksEffect$1;
+
+/**
+ * A sink that effectfully folds its inputs with the provided function,
+ * termination predicate and initial state.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldEffect = foldEffect$1;
+
+/**
+ * A sink that folds its inputs with the provided function and initial state.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldLeft = foldLeft$1;
+
+/**
+ * A sink that folds its input chunks with the provided function and initial
+ * state. `f` must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldLeftChunks = foldLeftChunks$1;
+
+/**
+ * A sink that effectfully folds its input chunks with the provided function
+ * and initial state. `f` must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldLeftChunksEffect = foldLeftChunksEffect$1;
+
+/**
+ * A sink that effectfully folds its inputs with the provided function and
+ * initial state.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldLeftEffect = foldLeftEffect$1;
+
+/**
+ * Creates a sink that folds elements of type `In` into a structure of type
+ * `S` until `max` elements have been folded.
+ *
+ * Like `Sink.foldWeighted`, but with a constant cost function of `1`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldUntil = foldUntil$1;
+
+/**
+ * Creates a sink that effectfully folds elements of type `In` into a
+ * structure of type `S` until `max` elements have been folded.
+ *
+ * Like `Sink.foldWeightedEffect` but with a constant cost function of `1`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldUntilEffect = foldUntilEffect$1;
+
+/**
+ * Creates a sink that folds elements of type `In` into a structure of type
+ * `S`, until `max` worth of elements (determined by the `costFn`) have been
+ * folded.
+ *
+ * @note
+ *   Elements that have an individual cost larger than `max` will force the
+ *   sink to cross the `max` cost. See `Sink.foldWeightedDecompose` for a
+ *   variant that can handle these cases.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldWeighted = foldWeighted$1;
+
+/**
+ * Creates a sink that folds elements of type `In` into a structure of type
+ * `S`, until `max` worth of elements (determined by the `costFn`) have been
+ * folded.
+ *
+ * The `decompose` function will be used for decomposing elements that cause
+ * an `S` aggregate to cross `max` into smaller elements. For example:
+ *
+ * ```ts
+ * pipe(
+ *   Stream.make(1, 5, 1),
+ *   Stream.transduce(
+ *     Sink.foldWeightedDecompose(
+ *       Chunk.empty<number>(),
+ *       4,
+ *       (n: number) => n,
+ *       (n: number) => Chunk.make(n - 1, 1),
+ *       (acc, el) => pipe(acc, Chunk.append(el))
+ *     )
+ *   ),
+ *   Stream.runCollect
+ * )
+ * ```
+ *
+ * The stream would emit the elements `Chunk(1), Chunk(4), Chunk(1, 1)`.
+ *
+ * Be vigilant with this function, it has to generate "simpler" values or the
+ * fold may never end. A value is considered indivisible if `decompose` yields
+ * the empty chunk or a single-valued chunk. In these cases, there is no other
+ * choice than to yield a value that will cross the threshold.
+ *
+ * `Sink.foldWeightedDecomposeEffect` allows the decompose function to return an
+ * effect value, and consequently it allows the sink to fail.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldWeightedDecompose = foldWeightedDecompose$1;
+
+/**
+ * Creates a sink that effectfully folds elements of type `In` into a
+ * structure of type `S`, until `max` worth of elements (determined by the
+ * `costFn`) have been folded.
+ *
+ * The `decompose` function will be used for decomposing elements that cause
+ * an `S` aggregate to cross `max` into smaller elements. Be vigilant with
+ * this function, it has to generate "simpler" values or the fold may never
+ * end. A value is considered indivisible if `decompose` yields the empty
+ * chunk or a single-valued chunk. In these cases, there is no other choice
+ * than to yield a value that will cross the threshold.
+ *
+ * See `Sink.foldWeightedDecompose` for an example.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldWeightedDecomposeEffect = foldWeightedDecomposeEffect$1;
+
+/**
+ * Creates a sink that effectfully folds elements of type `In` into a
+ * structure of type `S`, until `max` worth of elements (determined by the
+ * `costFn`) have been folded.
+ *
+ * @note
+ *   Elements that have an individual cost larger than `max` will force the
+ *   sink to cross the `max` cost. See `Sink.foldWeightedDecomposeEffect` for
+ *   a variant that can handle these cases.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldWeightedEffect = foldWeightedEffect$1;
+
+/**
+ * A sink that executes the provided effectful function for every element fed
+ * to it.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forEach = forEach$1;
+
+/**
+ * A sink that executes the provided effectful function for every chunk fed to
+ * it.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forEachChunk = forEachChunk$1;
+
+/**
+ * A sink that executes the provided effectful function for every chunk fed to
+ * it until `f` evaluates to `false`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forEachChunkWhile = forEachChunkWhile$1;
+
+/**
+ * A sink that executes the provided effectful function for every element fed
+ * to it until `f` evaluates to `false`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forEachWhile = forEachWhile$1;
+
+/**
+ * Runs this sink until it yields a result, then uses that result to create
+ * another sink from the provided function which will continue to run until it
+ * yields a result.
+ *
+ * This function essentially runs sinks in sequence.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = flatMap$1;
+
+/**
+ * Creates a sink from a `Channel`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChannel = fromChannel$1;
+
+/**
+ * Creates a `Channel` from a Sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const toChannel = toChannel$1;
+
+/**
+ * Creates a single-value sink produced from an effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = fromEffect$1;
+
+/**
+ * Create a sink which publishes each element to the specified hub.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the sink is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromHub = fromHub$1;
+
+/**
+ * Creates a sink from a chunk processing function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPush = fromPush$1;
+
+/**
+ * Create a sink which enqueues each element into the specified queue.
+ *
+ * @param shutdown If `true`, the queue will be shutdown after the sink is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromQueue = fromQueue$1;
+
+/**
+ * Creates a sink containing the first value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const head = head$1;
+
+/**
+ * Drains the remaining elements from the stream after the sink finishes
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ignoreLeftover = ignoreLeftover$1;
+
+/**
+ * Creates a sink containing the last value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const last = last$1;
+
+/**
+ * Creates a sink that does not consume any input but provides the given chunk
+ * as its leftovers
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const leftover = leftover$1;
+
+/**
+ * Transforms this sink's result.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Effectfully transforms this sink's result.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = mapEffect$1;
+
+/**
+ * Transforms the errors emitted by this sink using `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = mapError$1;
+
+/**
+ * Transforms the leftovers emitted by this sink using `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapLeftover = mapLeftover$1;
+
+/**
+ * Creates a sink which transforms it's inputs into a string.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const mkString = mkString$1;
+
+/**
+ * Creates a sink which never terminates.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = never$1;
+
+/**
+ * Switch to another sink in case of failure
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = orElse$1;
+
+/**
+ * Provides the sink with its required context, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = provideContext$1;
+
+/**
+ * Runs both sinks in parallel on the input, , returning the result or the
+ * error from the one that finishes first.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const race = race$1;
+
+/**
+ * Runs both sinks in parallel on the input, returning the result or the error
+ * from the one that finishes first.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const raceBoth = raceBoth$1;
+
+/**
+ * Runs both sinks in parallel on the input, using the specified merge
+ * function as soon as one result or the other has been computed.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const raceWith = raceWith$1;
+
+/**
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDie = refineOrDie$1;
+
+/**
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDieWith = refineOrDieWith$1;
+
+/**
+ * A sink that returns whether an element satisfies the specified predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const some = some$1;
+
+/**
+ * Splits the sink on the specified predicate, returning a new sink that
+ * consumes elements until an element after the first satisfies the specified
+ * predicate.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const splitWhere = splitWhere$1;
+
+/**
+ * A sink that immediately ends with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * A sink that sums incoming numeric values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sum = sum$1;
+
+/**
+ * Summarize a sink by running an effect when the sink starts and again when
+ * it completes.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const summarized = summarized$1;
+
+/**
+ * Returns a lazily constructed sink that may require effects for its
+ * creation.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = suspend$1;
+
+/**
+ * A sink that immediately ends with the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = sync$1;
+
+/**
+ * A sink that takes the specified number of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const take = take$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const timed = timed$1;
+
+/**
+ * Creates a sink produced from an effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = unwrap$1;
+
+/**
+ * Creates a sink produced from a scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrapScoped = unwrapScoped$1;
+
+/**
+ * Returns the sink that executes this one and times its execution.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const withDuration = withDuration$1;
+
+/**
+ * Feeds inputs to this sink until it yields a result, then switches over to
+ * the provided sink until it yields a result, finally combining the two
+ * results into a tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = zip$1;
+
+/**
+ * Like `Sink.zip` but keeps only the result from this sink.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = zipLeft$1;
+
+/**
+ * Like `Sink.zip` but keeps only the result from `that` sink.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = zipRight$1;
+
+/**
+ * Feeds inputs to this sink until it yields a result, then switches over to
+ * the provided sink until it yields a result, finally combining the two
+ * results with `f`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = zipWith$1;
+
+export { SinkTypeId, as, collectAll, collectAllFrom, collectAllN, collectAllToMap, collectAllToMapN, collectAllToSet, collectAllToSetN, collectAllUntil, collectAllUntilEffect, collectAllWhile, collectAllWhileEffect, collectAllWhileWith, collectLeftover, context, contextWith, contextWithEffect, contextWithSink, count, die, dieMessage, dieSync, dimap, dimapChunks, dimapChunksEffect, dimapEffect, drain, drop, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, ensuring, ensuringWith, every, fail, failCause, failCauseSync, failSync, filterInput, filterInputEffect, findEffect, flatMap, fold, foldChunks, foldChunksEffect, foldEffect, foldLeft, foldLeftChunks, foldLeftChunksEffect, foldLeftEffect, foldSink, foldUntil, foldUntilEffect, foldWeighted, foldWeightedDecompose, foldWeightedDecomposeEffect, foldWeightedEffect, forEach, forEachChunk, forEachChunkWhile, forEachWhile, fromChannel, fromEffect, fromHub, fromPush, fromQueue, head, ignoreLeftover, last, leftover, map, mapEffect, mapError, mapInput, mapInputChunks, mapInputChunksEffect, mapInputEffect, mapLeftover, mkString, never, orElse, provideContext, race, raceBoth, raceWith, refineOrDie, refineOrDieWith, some, splitWhere, succeed, sum, summarized, suspend, sync, take, timed, toChannel, unwrap, unwrapScoped, withDuration, zip, zipLeft, zipRight, zipWith };