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

package/dist/Sink-9f82fc3b.cjs.prod.js

@@ -0,0 +1,1215 @@
+'use strict';
+
+var sink = require('./sink-c9ae7558.cjs.prod.js');
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const SinkTypeId = sink.SinkTypeId;
+
+/**
+ * @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 = sink.as;
+
+/**
+ * A sink that collects all elements into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAll = sink.collectAll;
+
+/**
+ * A sink that collects first `n` elements into a chunk.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllN = sink.collectAllN;
+
+/**
+ * Repeatedly runs the sink and accumulates its results into a `Chunk`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collectAllFrom = sink.collectAllFrom;
+
+/**
+ * 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 = sink.collectAllToMap;
+
+/**
+ * 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 = sink.collectAllToMapN;
+
+/**
+ * A sink that collects all of its inputs into a set.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllToSet = sink.collectAllToSet;
+
+/**
+ * A sink that collects first `n` distinct inputs into a set.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllToSetN = sink.collectAllToSetN;
+
+/**
+ * Accumulates incoming elements into a chunk until predicate `p` is
+ * satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllUntil = sink.collectAllUntil;
+
+/**
+ * Accumulates incoming elements into a chunk until effectful predicate `p` is
+ * satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllUntilEffect = sink.collectAllUntilEffect;
+
+/**
+ * Accumulates incoming elements into a chunk as long as they verify predicate
+ * `p`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllWhile = sink.collectAllWhile;
+
+/**
+ * Accumulates incoming elements into a chunk as long as they verify effectful
+ * predicate `p`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const collectAllWhileEffect = sink.collectAllWhileEffect;
+
+/**
+ * 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 = sink.collectAllWhileWith;
+
+/**
+ * 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 = sink.collectLeftover;
+
+/**
+ * Transforms this sink's input elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInput = sink.mapInput;
+
+/**
+ * Effectfully transforms this sink's input elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputEffect = sink.mapInputEffect;
+
+/**
+ * Transforms this sink's input chunks. `f` must preserve chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputChunks = sink.mapInputChunks;
+
+/**
+ * Effectfully transforms this sink's input chunks. `f` must preserve
+ * chunking-invariance.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapInputChunksEffect = sink.mapInputChunksEffect;
+
+/**
+ * A sink that counts the number of elements fed to it.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const count = sink.count;
+
+/**
+ * Creates a sink halting with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = sink.die;
+
+/**
+ * Creates a sink halting with the specified message, wrapped in a
+ * `RuntimeException`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = sink.dieMessage;
+
+/**
+ * Creates a sink halting with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = sink.dieSync;
+
+/**
+ * Transforms both inputs and result of this sink using the provided
+ * functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimap = sink.dimap;
+
+/**
+ * Effectfully transforms both inputs and result of this sink using the
+ * provided functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimapEffect = sink.dimapEffect;
+
+/**
+ * Transforms both input chunks and result of this sink using the provided
+ * functions.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const dimapChunks = sink.dimapChunks;
+
+/**
+ * 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 = sink.dimapChunksEffect;
+
+/**
+ * A sink that ignores its inputs.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const drain = sink.drain$1;
+
+/**
+ * Creates a sink that drops `n` elements.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const drop = sink.drop;
+
+/**
+ * Drops incoming elements until the predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropUntil = sink.dropUntil;
+
+/**
+ * Drops incoming elements until the effectful predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropUntilEffect = sink.dropUntilEffect;
+
+/**
+ * Drops incoming elements as long as the predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropWhile = sink.dropWhile;
+
+/**
+ * Drops incoming elements as long as the effectful predicate is satisfied.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dropWhileEffect = sink.dropWhileEffect;
+
+/**
+ * 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 = sink.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 = sink.ensuringWith$1;
+
+/**
+ * Accesses the whole context of the sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = sink.context;
+
+/**
+ * Accesses the context of the sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWith = sink.contextWith;
+
+/**
+ * Accesses the context of the sink in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithEffect = sink.contextWithEffect;
+
+/**
+ * Accesses the context of the sink in the context of a sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithSink = sink.contextWithSink;
+
+/**
+ * A sink that returns whether all elements satisfy the specified predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const every = sink.every;
+
+/**
+ * A sink that always fails with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = sink.fail$1;
+
+/**
+ * A sink that always fails with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = sink.failSync;
+
+/**
+ * Creates a sink halting with a specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = sink.failCause$1;
+
+/**
+ * Creates a sink halting with a specified lazily evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = sink.failCauseSync;
+
+/**
+ * Filters the sink's input with the given predicate.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterInput = sink.filterInput;
+
+/**
+ * Effectfully filter the input of this sink using the specified predicate.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterInputEffect = sink.filterInputEffect;
+
+/**
+ * Creates a sink that produces values until one verifies the predicate `f`.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const findEffect = sink.findEffect;
+
+/**
+ * A sink that folds its inputs with the provided function, termination
+ * predicate and initial state.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const fold = sink.fold;
+
+/**
+ * Folds over the result of the sink
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const foldSink = sink.foldSink;
+
+/**
+ * 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 = sink.foldChunks;
+
+/**
+ * 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 = sink.foldChunksEffect;
+
+/**
+ * A sink that effectfully folds its inputs with the provided function,
+ * termination predicate and initial state.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldEffect = sink.foldEffect;
+
+/**
+ * A sink that folds its inputs with the provided function and initial state.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldLeft = sink.foldLeft;
+
+/**
+ * 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 = sink.foldLeftChunks;
+
+/**
+ * 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 = sink.foldLeftChunksEffect;
+
+/**
+ * A sink that effectfully folds its inputs with the provided function and
+ * initial state.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const foldLeftEffect = sink.foldLeftEffect;
+
+/**
+ * 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 = sink.foldUntil;
+
+/**
+ * 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 = sink.foldUntilEffect;
+
+/**
+ * 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 = sink.foldWeighted;
+
+/**
+ * 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 = sink.foldWeightedDecompose;
+
+/**
+ * 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 = sink.foldWeightedDecomposeEffect;
+
+/**
+ * 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 = sink.foldWeightedEffect;
+
+/**
+ * A sink that executes the provided effectful function for every element fed
+ * to it.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forEach = sink.forEach;
+
+/**
+ * A sink that executes the provided effectful function for every chunk fed to
+ * it.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const forEachChunk = sink.forEachChunk;
+
+/**
+ * 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 = sink.forEachChunkWhile;
+
+/**
+ * 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 = sink.forEachWhile;
+
+/**
+ * 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 = sink.flatMap$1;
+
+/**
+ * Creates a sink from a `Channel`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChannel = sink.fromChannel;
+
+/**
+ * Creates a `Channel` from a Sink.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const toChannel = sink.toChannel;
+
+/**
+ * Creates a single-value sink produced from an effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = sink.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 = sink.fromHub;
+
+/**
+ * Creates a sink from a chunk processing function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPush = sink.fromPush;
+
+/**
+ * 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 = sink.fromQueue;
+
+/**
+ * Creates a sink containing the first value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const head = sink.head;
+
+/**
+ * Drains the remaining elements from the stream after the sink finishes
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ignoreLeftover = sink.ignoreLeftover;
+
+/**
+ * Creates a sink containing the last value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const last = sink.last;
+
+/**
+ * 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 = sink.leftover;
+
+/**
+ * Transforms this sink's result.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = sink.map;
+
+/**
+ * Effectfully transforms this sink's result.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = sink.mapEffect;
+
+/**
+ * Transforms the errors emitted by this sink using `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = sink.mapError$1;
+
+/**
+ * Transforms the leftovers emitted by this sink using `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapLeftover = sink.mapLeftover;
+
+/**
+ * Creates a sink which transforms it's inputs into a string.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const mkString = sink.mkString;
+
+/**
+ * Creates a sink which never terminates.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = sink.never;
+
+/**
+ * Switch to another sink in case of failure
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = sink.orElse$1;
+
+/**
+ * Provides the sink with its required context, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = sink.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 = sink.race;
+
+/**
+ * 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 = sink.raceBoth;
+
+/**
+ * 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 = sink.raceWith;
+
+/**
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDie = sink.refineOrDie;
+
+/**
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDieWith = sink.refineOrDieWith;
+
+/**
+ * A sink that returns whether an element satisfies the specified predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const some = sink.some;
+
+/**
+ * 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 = sink.splitWhere;
+
+/**
+ * A sink that immediately ends with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = sink.succeed$1;
+
+/**
+ * A sink that sums incoming numeric values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sum = sink.sum;
+
+/**
+ * Summarize a sink by running an effect when the sink starts and again when
+ * it completes.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const summarized = sink.summarized;
+
+/**
+ * Returns a lazily constructed sink that may require effects for its
+ * creation.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = sink.suspend$1;
+
+/**
+ * A sink that immediately ends with the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = sink.sync$1;
+
+/**
+ * A sink that takes the specified number of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const take = sink.take;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const timed = sink.timed;
+
+/**
+ * Creates a sink produced from an effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = sink.unwrap$1;
+
+/**
+ * Creates a sink produced from a scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrapScoped = sink.unwrapScoped$1;
+
+/**
+ * Returns the sink that executes this one and times its execution.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const withDuration = sink.withDuration;
+
+/**
+ * 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 = sink.zip;
+
+/**
+ * Like `Sink.zip` but keeps only the result from this sink.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = sink.zipLeft;
+
+/**
+ * Like `Sink.zip` but keeps only the result from `that` sink.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = sink.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 = sink.zipWith;
+
+var Sink = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  SinkTypeId: SinkTypeId,
+  as: as,
+  collectAll: collectAll,
+  collectAllN: collectAllN,
+  collectAllFrom: collectAllFrom,
+  collectAllToMap: collectAllToMap,
+  collectAllToMapN: collectAllToMapN,
+  collectAllToSet: collectAllToSet,
+  collectAllToSetN: collectAllToSetN,
+  collectAllUntil: collectAllUntil,
+  collectAllUntilEffect: collectAllUntilEffect,
+  collectAllWhile: collectAllWhile,
+  collectAllWhileEffect: collectAllWhileEffect,
+  collectAllWhileWith: collectAllWhileWith,
+  collectLeftover: collectLeftover,
+  mapInput: mapInput,
+  mapInputEffect: mapInputEffect,
+  mapInputChunks: mapInputChunks,
+  mapInputChunksEffect: mapInputChunksEffect,
+  count: count,
+  die: die,
+  dieMessage: dieMessage,
+  dieSync: dieSync,
+  dimap: dimap,
+  dimapEffect: dimapEffect,
+  dimapChunks: dimapChunks,
+  dimapChunksEffect: dimapChunksEffect,
+  drain: drain,
+  drop: drop,
+  dropUntil: dropUntil,
+  dropUntilEffect: dropUntilEffect,
+  dropWhile: dropWhile,
+  dropWhileEffect: dropWhileEffect,
+  ensuring: ensuring,
+  ensuringWith: ensuringWith,
+  context: context,
+  contextWith: contextWith,
+  contextWithEffect: contextWithEffect,
+  contextWithSink: contextWithSink,
+  every: every,
+  fail: fail,
+  failSync: failSync,
+  failCause: failCause,
+  failCauseSync: failCauseSync,
+  filterInput: filterInput,
+  filterInputEffect: filterInputEffect,
+  findEffect: findEffect,
+  fold: fold,
+  foldSink: foldSink,
+  foldChunks: foldChunks,
+  foldChunksEffect: foldChunksEffect,
+  foldEffect: foldEffect,
+  foldLeft: foldLeft,
+  foldLeftChunks: foldLeftChunks,
+  foldLeftChunksEffect: foldLeftChunksEffect,
+  foldLeftEffect: foldLeftEffect,
+  foldUntil: foldUntil,
+  foldUntilEffect: foldUntilEffect,
+  foldWeighted: foldWeighted,
+  foldWeightedDecompose: foldWeightedDecompose,
+  foldWeightedDecomposeEffect: foldWeightedDecomposeEffect,
+  foldWeightedEffect: foldWeightedEffect,
+  forEach: forEach,
+  forEachChunk: forEachChunk,
+  forEachChunkWhile: forEachChunkWhile,
+  forEachWhile: forEachWhile,
+  flatMap: flatMap,
+  fromChannel: fromChannel,
+  toChannel: toChannel,
+  fromEffect: fromEffect,
+  fromHub: fromHub,
+  fromPush: fromPush,
+  fromQueue: fromQueue,
+  head: head,
+  ignoreLeftover: ignoreLeftover,
+  last: last,
+  leftover: leftover,
+  map: map,
+  mapEffect: mapEffect,
+  mapError: mapError,
+  mapLeftover: mapLeftover,
+  mkString: mkString,
+  never: never,
+  orElse: orElse,
+  provideContext: provideContext,
+  race: race,
+  raceBoth: raceBoth,
+  raceWith: raceWith,
+  refineOrDie: refineOrDie,
+  refineOrDieWith: refineOrDieWith,
+  some: some,
+  splitWhere: splitWhere,
+  succeed: succeed,
+  sum: sum,
+  summarized: summarized,
+  suspend: suspend,
+  sync: sync,
+  take: take,
+  timed: timed,
+  unwrap: unwrap,
+  unwrapScoped: unwrapScoped,
+  withDuration: withDuration,
+  zip: zip,
+  zipLeft: zipLeft,
+  zipRight: zipRight,
+  zipWith: zipWith
+});
+
+exports.Sink = Sink;
+exports.SinkTypeId = SinkTypeId;
+exports.as = as;
+exports.collectAll = collectAll;
+exports.collectAllFrom = collectAllFrom;
+exports.collectAllN = collectAllN;
+exports.collectAllToMap = collectAllToMap;
+exports.collectAllToMapN = collectAllToMapN;
+exports.collectAllToSet = collectAllToSet;
+exports.collectAllToSetN = collectAllToSetN;
+exports.collectAllUntil = collectAllUntil;
+exports.collectAllUntilEffect = collectAllUntilEffect;
+exports.collectAllWhile = collectAllWhile;
+exports.collectAllWhileEffect = collectAllWhileEffect;
+exports.collectAllWhileWith = collectAllWhileWith;
+exports.collectLeftover = collectLeftover;
+exports.context = context;
+exports.contextWith = contextWith;
+exports.contextWithEffect = contextWithEffect;
+exports.contextWithSink = contextWithSink;
+exports.count = count;
+exports.die = die;
+exports.dieMessage = dieMessage;
+exports.dieSync = dieSync;
+exports.dimap = dimap;
+exports.dimapChunks = dimapChunks;
+exports.dimapChunksEffect = dimapChunksEffect;
+exports.dimapEffect = dimapEffect;
+exports.drain = drain;
+exports.drop = drop;
+exports.dropUntil = dropUntil;
+exports.dropUntilEffect = dropUntilEffect;
+exports.dropWhile = dropWhile;
+exports.dropWhileEffect = dropWhileEffect;
+exports.ensuring = ensuring;
+exports.ensuringWith = ensuringWith;
+exports.every = every;
+exports.fail = fail;
+exports.failCause = failCause;
+exports.failCauseSync = failCauseSync;
+exports.failSync = failSync;
+exports.filterInput = filterInput;
+exports.filterInputEffect = filterInputEffect;
+exports.findEffect = findEffect;
+exports.flatMap = flatMap;
+exports.fold = fold;
+exports.foldChunks = foldChunks;
+exports.foldChunksEffect = foldChunksEffect;
+exports.foldEffect = foldEffect;
+exports.foldLeft = foldLeft;
+exports.foldLeftChunks = foldLeftChunks;
+exports.foldLeftChunksEffect = foldLeftChunksEffect;
+exports.foldLeftEffect = foldLeftEffect;
+exports.foldSink = foldSink;
+exports.foldUntil = foldUntil;
+exports.foldUntilEffect = foldUntilEffect;
+exports.foldWeighted = foldWeighted;
+exports.foldWeightedDecompose = foldWeightedDecompose;
+exports.foldWeightedDecomposeEffect = foldWeightedDecomposeEffect;
+exports.foldWeightedEffect = foldWeightedEffect;
+exports.forEach = forEach;
+exports.forEachChunk = forEachChunk;
+exports.forEachChunkWhile = forEachChunkWhile;
+exports.forEachWhile = forEachWhile;
+exports.fromChannel = fromChannel;
+exports.fromEffect = fromEffect;
+exports.fromHub = fromHub;
+exports.fromPush = fromPush;
+exports.fromQueue = fromQueue;
+exports.head = head;
+exports.ignoreLeftover = ignoreLeftover;
+exports.last = last;
+exports.leftover = leftover;
+exports.map = map;
+exports.mapEffect = mapEffect;
+exports.mapError = mapError;
+exports.mapInput = mapInput;
+exports.mapInputChunks = mapInputChunks;
+exports.mapInputChunksEffect = mapInputChunksEffect;
+exports.mapInputEffect = mapInputEffect;
+exports.mapLeftover = mapLeftover;
+exports.mkString = mkString;
+exports.never = never;
+exports.orElse = orElse;
+exports.provideContext = provideContext;
+exports.race = race;
+exports.raceBoth = raceBoth;
+exports.raceWith = raceWith;
+exports.refineOrDie = refineOrDie;
+exports.refineOrDieWith = refineOrDieWith;
+exports.some = some;
+exports.splitWhere = splitWhere;
+exports.succeed = succeed;
+exports.sum = sum;
+exports.summarized = summarized;
+exports.suspend = suspend;
+exports.sync = sync;
+exports.take = take;
+exports.timed = timed;
+exports.toChannel = toChannel;
+exports.unwrap = unwrap;
+exports.unwrapScoped = unwrapScoped;
+exports.withDuration = withDuration;
+exports.zip = zip;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;