effect 2.0.0-next.37 → 2.0.0-next.38

package/dist/Sink-fa1f105b.cjs.dev.js

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