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

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

@@ -1,101 +1,997 @@
-import '../../dist/sink-3f26fc31.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-923b4ad8.esm.js';
-import '../../dist/Cause-8be0b9a6.esm.js';
-import '../../dist/core-9f5f0dc2.esm.js';
-import '../../dist/Chunk-98371336.esm.js';
-import '../../dist/Equal-7d4ae7e7.esm.js';
-import '../../dist/Hash-039222d1.esm.js';
-import '../../dist/Function-52fb7d21.esm.js';
-import '../../dist/GlobalValue-c5f1e8e5.esm.js';
-import '../../dist/Utils-657e8bfa.esm.js';
-import '../../dist/Predicate-52271838.esm.js';
-import '../../dist/Equivalence-e5c9cba4.esm.js';
-import '../../dist/Inspectable-bda84223.esm.js';
-import '../../dist/Option-1d073850.esm.js';
-import '../../dist/Either-be9c40b9.esm.js';
-import '../../dist/Effectable-a76b6aa1.esm.js';
-import '../../dist/Data-bad1ffeb.esm.js';
-import '../../dist/Pipeable-fe51dc02.esm.js';
-import '../../dist/Number-dc454336.esm.js';
-import '../../dist/Order-2f11aa24.esm.js';
-import '../../dist/ReadonlyArray-199ff80e.esm.js';
-import '../../dist/Either-09270bbc.esm.js';
-import '../../dist/ReadonlyArray-84c71385.esm.js';
-import '../../dist/ReadonlyRecord-c1f5d048.esm.js';
-import '../../dist/Context-48179faa.esm.js';
-import '../../dist/Context-fcee7bba.esm.js';
-import '../../dist/Differ-3be1df41.esm.js';
-import '../../dist/HashMap-e644e23b.esm.js';
-import '../../dist/HashSet-d051e0ea.esm.js';
-import '../../dist/Stack-765c2298.esm.js';
-import '../../dist/HashSet-dff2542b.esm.js';
-import '../../dist/FiberId-556ab9ef.esm.js';
-import '../../dist/MutableRef-cb4d2fc0.esm.js';
-import '../../dist/List-c066a506.esm.js';
-import '../../dist/RuntimeFlagsPatch-a1da6096.esm.js';
-import '../../dist/Clock-ab907687.esm.js';
-import '../../dist/defaultServices-86214de4.esm.js';
-import '../../dist/Duration-5e9f2327.esm.js';
-import '../../dist/timeout-4180303d.esm.js';
-import '../../dist/configProvider-cd15d971.esm.js';
-import '../../dist/config-64a67e36.esm.js';
-import '../../dist/ConfigError-5801d561.esm.js';
-import '../../dist/configError-84c0742e.esm.js';
-import '../../dist/configSecret-793e52b4.esm.js';
-import '../../dist/pathPatch-5ac830c8.esm.js';
-import '../../dist/Effect-d5910dae.esm.js';
-import '../../dist/core-effect-e762d50b.esm.js';
-import '../../dist/FiberRefs-a6ab4b8d.esm.js';
-import '../../dist/fiberRefs-b32de18b.esm.js';
-import '../../dist/patch-99e8591b.esm.js';
-import '../../dist/label-5cb21441.esm.js';
-import '../../dist/LogLevel-2e6b00c7.esm.js';
-import '../../dist/LogSpan-e5cf11a5.esm.js';
-import '../../dist/Ref-9a9de951.esm.js';
-import '../../dist/Tracer-b07052e2.esm.js';
-import '../../dist/circular-cff58c30.esm.js';
-import '../../dist/Exit-e31718e3.esm.js';
-import '../../dist/ExecutionStrategy-c6f7c490.esm.js';
-import '../../dist/fiber-1511340a.esm.js';
-import '../../dist/FiberStatus-90291b8c.esm.js';
-import '../../dist/fiberRuntime-98f09d31.esm.js';
-import '../../dist/Boolean-f564d31a.esm.js';
-import '../../dist/Deferred-554d3588.esm.js';
-import '../../dist/FiberRefsPatch-f84453c3.esm.js';
-import '../../dist/boundaries-8475a9b4.esm.js';
-import '../../dist/key-215ea6fd.esm.js';
-import '../../dist/keyType-fefd9ef8.esm.js';
-import '../../dist/registry-38f0ed9d.esm.js';
-import '../../dist/hook-8fc9006f.esm.js';
-import '../../dist/state-38610229.esm.js';
-import '../../dist/pair-cb46f77c.esm.js';
-import '../../dist/MutableHashMap-b3ab7261.esm.js';
-import '../../dist/SortedSet-3339ea7f.esm.js';
-import '../../dist/RedBlackTree-22839235.esm.js';
-import '../../dist/Scheduler-d2f7e5c7.esm.js';
-import '../../dist/schedule-0d31f4cc.esm.js';
-import '../../dist/Random-14987953.esm.js';
-import '../../dist/ScheduleDecision-e794f66d.esm.js';
-import '../../dist/ScheduleIntervals-ef5cd7c5.esm.js';
-import '../../dist/ScheduleInterval-94e80ec4.esm.js';
-import '../../dist/layer-f8ec8454.esm.js';
-import '../../dist/runtime-f91ca239.esm.js';
-import '../../dist/Fiber-38517971.esm.js';
-import '../../dist/synchronizedRef-f7077a5f.esm.js';
-import '../../dist/Scope-0ffde3bb.esm.js';
-import '../../dist/circular-3ebc9b78.esm.js';
-import '../../dist/Layer-f7be72db.esm.js';
-import '../../dist/query-1685a476.esm.js';
-import '../../dist/cache-2fa366f0.esm.js';
-import '../../dist/MutableQueue-54a4b584.esm.js';
-import '../../dist/MutableList-8c671944.esm.js';
-import '../../dist/Hub-9f3d5c5d.esm.js';
-import '../../dist/queue-b79c472d.esm.js';
-import '../../dist/Queue-bbebbeda.esm.js';
-import '../../dist/childExecutorDecision-49f0f19c.esm.js';
-import '../../dist/upstreamPullStrategy-d1505fa4.esm.js';
-import '../../dist/upstreamPullRequest-be86e51c.esm.js';
-import '../../dist/mergeDecision-32146c34.esm.js';
-import '../../dist/mergeState-21728f0b.esm.js';
-import '../../dist/mergeStrategy-84dd9011.esm.js';
-import '../../dist/singleProducerAsyncInput-c67ef1c6.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 };