effect 2.0.0-next.38 → 2.0.0-next.39

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

@@ -1,101 +1,997 @@
-import '../../dist/sink-637a9670.esm.js';
-export { a as SinkTypeId, b as as, c as collectAll, e as collectAllFrom, d as collectAllN, f as collectAllToMap, g as collectAllToMapN, h as collectAllToSet, i as collectAllToSetN, j as collectAllUntil, k as collectAllUntilEffect, l as collectAllWhile, m as collectAllWhileEffect, n as collectAllWhileWith, o as collectLeftover, J as context, K as contextWith, L as contextWithEffect, M as contextWithSink, t as count, u as die, v as dieMessage, w as dieSync, x as dimap, z as dimapChunks, A as dimapChunksEffect, y as dimapEffect, B as drain, C as drop, D as dropUntil, E as dropUntilEffect, F as dropWhile, G as dropWhileEffect, H as ensuring, I as ensuringWith, N as every, O as fail, Q as failCause, R as failCauseSync, P as failSync, T as filterInput, U as filterInputEffect, V as findEffect, ad as flatMap, W as fold, Y as foldChunks, Z as foldChunksEffect, _ as foldEffect, $ as foldLeft, a0 as foldLeftChunks, a1 as foldLeftChunksEffect, a2 as foldLeftEffect, X as foldSink, a3 as foldUntil, a4 as foldUntilEffect, a5 as foldWeighted, a6 as foldWeightedDecompose, a7 as foldWeightedDecomposeEffect, a8 as foldWeightedEffect, a9 as forEach, aa as forEachChunk, ab as forEachChunkWhile, ac as forEachWhile, ae as fromChannel, ag as fromEffect, ah as fromHub, ai as fromPush, aj as fromQueue, ak as head, al as ignoreLeftover, am as last, an as leftover, ao as map, ap as mapEffect, aq as mapError, p as mapInput, r as mapInputChunks, s as mapInputChunksEffect, q as mapInputEffect, ar as mapLeftover, as as mkString, at as never, au as orElse, av as provideContext, aw as race, ax as raceBoth, ay as raceWith, az as refineOrDie, aA as refineOrDieWith, aB as some, aC as splitWhere, aD as succeed, aE as sum, aF as summarized, aG as suspend, aH as sync, aI as take, aJ as timed, af as toChannel, aK as unwrap, aL as unwrapScoped, aM as withDuration, aN as zip, aO as zipLeft, aP as zipRight, aQ as zipWith } from '../../dist/Sink-322b0a96.esm.js';
-import '../../dist/Cause-5946c7a3.esm.js';
-import '../../dist/core-64ab7ff5.esm.js';
-import '../../dist/Chunk-4c1f4599.esm.js';
-import '../../dist/Equal-2a99fde3.esm.js';
-import '../../dist/Hash-7910f34f.esm.js';
-import '../../dist/Function-12511160.esm.js';
-import '../../dist/GlobalValue-b5edf230.esm.js';
-import '../../dist/Utils-80c21479.esm.js';
-import '../../dist/Predicate-6b61b95b.esm.js';
-import '../../dist/Equivalence-cf2752b1.esm.js';
-import '../../dist/Inspectable-b0c51e90.esm.js';
-import '../../dist/Option-df40d2b9.esm.js';
-import '../../dist/Either-408d23a8.esm.js';
-import '../../dist/Effectable-a292d920.esm.js';
-import '../../dist/Data-dee529b9.esm.js';
-import '../../dist/Pipeable-10760a1d.esm.js';
-import '../../dist/Number-4b836a09.esm.js';
-import '../../dist/Order-a875fe30.esm.js';
-import '../../dist/ReadonlyArray-0a71b226.esm.js';
-import '../../dist/Either-aa46c018.esm.js';
-import '../../dist/ReadonlyArray-c8b1f51c.esm.js';
-import '../../dist/ReadonlyRecord-c9f03980.esm.js';
-import '../../dist/Context-c41aa832.esm.js';
-import '../../dist/Context-149c432f.esm.js';
-import '../../dist/Differ-a249bf4d.esm.js';
-import '../../dist/HashMap-6c230bde.esm.js';
-import '../../dist/HashSet-69824ba8.esm.js';
-import '../../dist/Stack-765c2298.esm.js';
-import '../../dist/HashSet-ae2856c1.esm.js';
-import '../../dist/FiberId-17e50f05.esm.js';
-import '../../dist/MutableRef-2734b082.esm.js';
-import '../../dist/List-6e58a1e9.esm.js';
-import '../../dist/RuntimeFlagsPatch-51f77dce.esm.js';
-import '../../dist/Clock-f8b987d7.esm.js';
-import '../../dist/defaultServices-b9ca1236.esm.js';
-import '../../dist/Duration-98bca14c.esm.js';
-import '../../dist/timeout-4180303d.esm.js';
-import '../../dist/configProvider-c997961d.esm.js';
-import '../../dist/config-b039b99f.esm.js';
-import '../../dist/ConfigError-41421a53.esm.js';
-import '../../dist/configError-8b2e2999.esm.js';
-import '../../dist/configSecret-6e9eaf9d.esm.js';
-import '../../dist/pathPatch-f393ab1b.esm.js';
-import '../../dist/Effect-ee05a487.esm.js';
-import '../../dist/core-effect-57445976.esm.js';
-import '../../dist/FiberRefs-f705c1b5.esm.js';
-import '../../dist/fiberRefs-69cce1a0.esm.js';
-import '../../dist/patch-743d675c.esm.js';
-import '../../dist/label-0cc6c9a0.esm.js';
-import '../../dist/LogLevel-5a4fa506.esm.js';
-import '../../dist/LogSpan-f36e9619.esm.js';
-import '../../dist/Ref-5eefaff1.esm.js';
-import '../../dist/Tracer-da65ce12.esm.js';
-import '../../dist/circular-08fb0138.esm.js';
-import '../../dist/Exit-666b4f01.esm.js';
-import '../../dist/ExecutionStrategy-e3775e86.esm.js';
-import '../../dist/fiber-8fb398f3.esm.js';
-import '../../dist/FiberStatus-7a24d5ef.esm.js';
-import '../../dist/fiberRuntime-bfcf5f49.esm.js';
-import '../../dist/Boolean-bf38e241.esm.js';
-import '../../dist/Deferred-9010d2ac.esm.js';
-import '../../dist/FiberRefsPatch-04e0adc7.esm.js';
-import '../../dist/boundaries-52029180.esm.js';
-import '../../dist/key-340a2bae.esm.js';
-import '../../dist/keyType-869d90f8.esm.js';
-import '../../dist/registry-c59aeb06.esm.js';
-import '../../dist/hook-fd61107b.esm.js';
-import '../../dist/state-2c6abdb1.esm.js';
-import '../../dist/pair-5bb3eef4.esm.js';
-import '../../dist/MutableHashMap-02b39969.esm.js';
-import '../../dist/SortedSet-ffc2cefd.esm.js';
-import '../../dist/RedBlackTree-611b3b4c.esm.js';
-import '../../dist/Scheduler-844c1a90.esm.js';
-import '../../dist/schedule-566ae18c.esm.js';
-import '../../dist/Random-5ed16d23.esm.js';
-import '../../dist/ScheduleDecision-e0b221dc.esm.js';
-import '../../dist/ScheduleIntervals-c4dc0500.esm.js';
-import '../../dist/ScheduleInterval-cc7fc624.esm.js';
-import '../../dist/layer-35828af7.esm.js';
-import '../../dist/runtime-bcdd4416.esm.js';
-import '../../dist/Fiber-ebef9c60.esm.js';
-import '../../dist/synchronizedRef-1ceb6bd3.esm.js';
-import '../../dist/Scope-0253ac82.esm.js';
-import '../../dist/circular-e463e1e6.esm.js';
-import '../../dist/Layer-8586a429.esm.js';
-import '../../dist/query-242f7fda.esm.js';
-import '../../dist/cache-d62912e6.esm.js';
-import '../../dist/MutableQueue-446ac662.esm.js';
-import '../../dist/MutableList-76401868.esm.js';
-import '../../dist/Hub-121dbf51.esm.js';
-import '../../dist/queue-f74db567.esm.js';
-import '../../dist/Queue-d99be5de.esm.js';
-import '../../dist/childExecutorDecision-a7b466d2.esm.js';
-import '../../dist/upstreamPullStrategy-d5d1aa92.esm.js';
-import '../../dist/upstreamPullRequest-fed99e29.esm.js';
-import '../../dist/mergeDecision-d31cb28c.esm.js';
-import '../../dist/mergeState-1325df20.esm.js';
-import '../../dist/mergeStrategy-a88b5442.esm.js';
-import '../../dist/singleProducerAsyncInput-5b2ede75.esm.js';
+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 };