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

package/dist/Channel-4bba5096.esm.js

@@ -0,0 +1,1109 @@
+import { C as ChannelTypeId$1, bB as ChannelExceptionTypeId$1, bC as acquireUseRelease$1, bD as acquireReleaseOut$1, bE as as$1, bF as asUnit$1, bG as buffer$1, bH as bufferChunk$1, X as catchAll$1, l as catchAllCause$1, bI as concatAll$1, bJ as concatAllWith$1, m as concatMap$1, bK as concatMapWith$1, bL as concatMapWithCustom$1, bM as collect$1, bN as concatOut$1, bO as mapInput$1, bP as mapInputEffect$1, bQ as mapInputError$1, bR as mapInputErrorEffect$1, bS as mapInputIn$1, bT as mapInputInEffect$1, bU as doneCollect$1, d as drain$1, ac as embedInput$1, bV as emitCollect$1, x as ensuring$1, y as ensuringWith$1, bW as context$1, bX as contextWith$1, bY as contextWithChannel$1, bZ as contextWithEffect$1, k as fail$1, b_ as failSync$1, c as failCause$1, b$ as failCauseSync$1, f as flatMap$1, c0 as flatten$1, c1 as foldChannel$1, a9 as foldCauseChannel$1, b as fromEffect$1, c2 as fromEither$1, ab as fromInput$1, c3 as fromHub$1, c4 as fromHubScoped$1, c5 as fromOption$1, c6 as fromQueue$1, q as identityChannel, G as interruptWhen$1, H as interruptWhenDeferred$1, c7 as map$1, c8 as mapEffect$1, J as mapError$1, K as mapErrorCause$1, B as mapOut$1, I as mapOutEffect$1, D as mapOutEffectPar$1, c9 as mergeAll$1, ca as mergeAllUnbounded$1, cb as mergeAllUnboundedWith$1, cc as mergeAllWith$1, ad as mergeMap$1, cd as mergeOut$1, ce as mergeOutWith$1, L as mergeWith$1, cf as never$1, cg as orDie$1, N as orDieWith$1, O as orElse$1, p as pipeTo$1, h as pipeToOrFail$1, W as provideContext$1, ch as provideLayer$1, ci as mapInputContext$1, cj as provideSomeLayer$1, ck as provideService$1, cl as read$1, cm as readOrFail$1, o as readWith$1, a as readWithCause$1, E as repeated$1, cn as run$1, co as runCollect$1, Y as runDrain$1, a8 as scoped$1, A as succeed$1, ae as sync$1, cp as toHub$1, aa as toPull$1, cq as toQueue$1, cr as channelToSink, e as unit$1, u as unwrap$1, j as unwrapScoped$1, cs as updateService$1, ct as withSpan$1, w as write$1, af as writeAll$1, n as writeChunk$1, cu as zip$1, cv as zipLeft$1, z as zipRight$1, cw as ChannelException$1, cx as isChannelException$1 } from './sink-637a9670.esm.js';
+import { dL as channelToStream } from './stream-e44fba40.esm.js';
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ChannelTypeId = ChannelTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Channel` is a nexus of I/O operations, which supports both reading and
+ * writing. A channel may read values of type `InElem` and write values of type
+ * `OutElem`. When the channel finishes, it yields a value of type `OutDone`. A
+ * channel may fail with a value of type `OutErr`.
+ *
+ * Channels are the foundation of Streams: both streams and sinks are built on
+ * channels. Most users shouldn't have to use channels directly, as streams and
+ * sinks are much more convenient and cover all common use cases. However, when
+ * adding new stream and sink operators, or doing something highly specialized,
+ * it may be useful to use channels directly.
+ *
+ * Channels compose in a variety of ways:
+ *
+ *  - **Piping**: One channel can be piped to another channel, assuming the
+ *    input type of the second is the same as the output type of the first.
+ *  - **Sequencing**: The terminal value of one channel can be used to create
+ *    another channel, and both the first channel and the function that makes
+ *    the second channel can be composed into a channel.
+ *  - **Concatenating**: The output of one channel can be used to create other
+ *    channels, which are all concatenated together. The first channel and the
+ *    function that makes the other channels can be composed into a channel.
+ *
+ * @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
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const ChannelExceptionTypeId = ChannelExceptionTypeId$1;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * Represents a generic checked exception which occurs when a `Channel` is
+ * executed.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireUseRelease = acquireUseRelease$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireReleaseOut = acquireReleaseOut$1;
+
+/**
+ * Returns a new channel that is the same as this one, except the terminal
+ * value of the channel is the specified constant value.
+ *
+ * This method produces the same result as mapping this channel to the
+ * specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = as$1;
+
+/**
+ * @since 2.0.0
+ * @category mapping
+ */
+const asUnit = asUnit$1;
+
+/**
+ * Creates a channel backed by a buffer. When the buffer is empty, the channel
+ * will simply passthrough its input as output. However, when the buffer is
+ * non-empty, the value inside the buffer will be passed along as output.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const buffer = buffer$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const bufferChunk = bufferChunk$1;
+
+/**
+ * Returns a new channel that is the same as this one, except if this channel
+ * errors for any typed error, then the returned channel will switch over to
+ * using the fallback channel returned by the specified error handler.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = catchAll$1;
+
+/**
+ * Returns a new channel that is the same as this one, except if this channel
+ * errors for any typed error, then the returned channel will switch over to
+ * using the fallback channel returned by the specified error handler.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAllCause = catchAllCause$1;
+
+/**
+ * Concat sequentially a channel of channels.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const concatAll = concatAll$1;
+
+/**
+ * Concat sequentially a channel of channels.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const concatAllWith = concatAllWith$1;
+
+/**
+ * Returns a new channel whose outputs are fed to the specified factory
+ * function, which creates new channels in response. These new channels are
+ * sequentially concatenated together, and all their outputs appear as outputs
+ * of the newly returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const concatMap = concatMap$1;
+
+/**
+ * Returns a new channel whose outputs are fed to the specified factory
+ * function, which creates new channels in response. These new channels are
+ * sequentially concatenated together, and all their outputs appear as outputs
+ * of the newly returned channel. The provided merging function is used to
+ * merge the terminal values of all channels into the single terminal value of
+ * the returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const concatMapWith = concatMapWith$1;
+
+/**
+ * Returns a new channel whose outputs are fed to the specified factory
+ * function, which creates new channels in response. These new channels are
+ * sequentially concatenated together, and all their outputs appear as outputs
+ * of the newly returned channel. The provided merging function is used to
+ * merge the terminal values of all channels into the single terminal value of
+ * the returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const concatMapWithCustom = concatMapWithCustom$1;
+
+/**
+ * Returns a new channel, which is the same as this one, except its outputs
+ * are filtered and transformed by the specified partial function.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const collect = collect$1;
+
+/**
+ * Returns a new channel, which is the concatenation of all the channels that
+ * are written out by this channel. This method may only be called on channels
+ * that output other channels.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const concatOut = concatOut$1;
+
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * function to the input channel's done value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapInput = mapInput$1;
+
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * effectual function to the input channel's done value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapInputEffect = mapInputEffect$1;
+
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * function to the input channel's error value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapInputError = mapInputError$1;
+
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * effectual function to the input channel's error value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapInputErrorEffect = mapInputErrorEffect$1;
+
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * function to the input channel's output elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapInputIn = mapInputIn$1;
+
+/**
+ * Returns a new channel which is the same as this one but applies the given
+ * effectual function to the input channel's output elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapInputInEffect = mapInputInEffect$1;
+
+/**
+ * Returns a new channel, which is the same as this one, except that all the
+ * outputs are collected and bundled into a tuple together with the terminal
+ * value of this channel.
+ *
+ * As the channel returned from this channel collects all of this channel's
+ * output into an in- memory chunk, it is not safe to call this method on
+ * channels that output a large or unbounded number of values.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const doneCollect = doneCollect$1;
+
+/**
+ * Returns a new channel which reads all the elements from upstream's output
+ * channel and ignores them, then terminates with the upstream result value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drain = drain$1;
+
+/**
+ * Returns a new channel which connects the given `AsyncInputProducer` as
+ * this channel's input.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const embedInput = embedInput$1;
+
+/**
+ * Returns a new channel that collects the output and terminal value of this
+ * channel, which it then writes as output of the returned channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const emitCollect = emitCollect$1;
+
+/**
+ * Returns a new channel with an attached finalizer. The finalizer is
+ * guaranteed to be executed so long as the channel begins execution (and
+ * regardless of whether or not it completes).
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ensuring = ensuring$1;
+
+/**
+ * Returns a new channel with an attached finalizer. The finalizer is
+ * guaranteed to be executed so long as the channel begins execution (and
+ * regardless of whether or not it completes).
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ensuringWith = ensuringWith$1;
+
+/**
+ * Accesses the whole context of the channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const context = context$1;
+
+/**
+ * Accesses the context of the channel with the specified function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWith = contextWith$1;
+
+/**
+ * Accesses the context of the channel in the context of a channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithChannel = contextWithChannel$1;
+
+/**
+ * Accesses the context of the channel in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithEffect = contextWithEffect$1;
+
+/**
+ * Constructs a channel that fails immediately with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * Constructs a channel that succeeds immediately with the specified lazily
+ * evaluated value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = failSync$1;
+
+/**
+ * Constructs a channel that fails immediately with the specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = failCause$1;
+
+/**
+ * Constructs a channel that succeeds immediately with the specified lazily
+ * evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = failCauseSync$1;
+
+/**
+ * Returns a new channel, which sequentially combines this channel, together
+ * with the provided factory function, which creates a second channel based on
+ * the terminal value of this channel. The result is a channel that will first
+ * perform the functions of this channel, before performing the functions of
+ * the created channel (including yielding its terminal value).
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = flatMap$1;
+
+/**
+ * Returns a new channel, which flattens the terminal value of this channel.
+ * This function may only be called if the terminal value of this channel is
+ * another channel of compatible types.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = flatten$1;
+
+/**
+ * Folds over the result of this channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const foldChannel = foldChannel$1;
+
+/**
+ * Folds over the result of this channel including any cause of termination.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const foldCauseChannel = foldCauseChannel$1;
+
+/**
+ * Use an effect to end a channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = fromEffect$1;
+
+/**
+ * Constructs a channel from an `Either`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEither = fromEither$1;
+
+/**
+ * Construct a `Channel` from an `AsyncInputConsumer`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromInput = fromInput$1;
+
+/**
+ * Construct a `Channel` from a `Hub`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromHub = fromHub$1;
+
+/**
+ * Construct a `Channel` from a `Hub` within a scoped effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromHubScoped = fromHubScoped$1;
+
+/**
+ * Construct a `Channel` from an `Option`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromOption = fromOption$1;
+
+/**
+ * Construct a `Channel` from a `Queue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromQueue = fromQueue$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const identity = identityChannel;
+
+/**
+ * Returns a new channel, which is the same as this one, except it will be
+ * interrupted when the specified effect completes. If the effect completes
+ * successfully before the underlying channel is done, then the returned
+ * channel will yield the success value of the effect as its terminal value.
+ * On the other hand, if the underlying channel finishes first, then the
+ * returned channel will yield the success value of the underlying channel as
+ * its terminal value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptWhen = interruptWhen$1;
+
+/**
+ * Returns a new channel, which is the same as this one, except it will be
+ * interrupted when the specified deferred is completed. If the deferred is
+ * completed before the underlying channel is done, then the returned channel
+ * will yield the value of the deferred. Otherwise, if the underlying channel
+ * finishes first, then the returned channel will yield the value of the
+ * underlying channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptWhenDeferred = interruptWhenDeferred$1;
+
+/**
+ * Returns a new channel, which is the same as this one, except the terminal
+ * value of the returned channel is created by applying the specified function
+ * to the terminal value of this channel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Returns a new channel, which is the same as this one, except the terminal
+ * value of the returned channel is created by applying the specified
+ * effectful function to the terminal value of this channel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = mapEffect$1;
+
+/**
+ * Returns a new channel, which is the same as this one, except the failure
+ * value of the returned channel is created by applying the specified function
+ * to the failure value of this channel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = mapError$1;
+
+/**
+ * A more powerful version of `mapError` which also surfaces the `Cause`
+ * of the channel failure.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapErrorCause = mapErrorCause$1;
+
+/**
+ * Maps the output of this channel using the specified function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapOut = mapOut$1;
+
+/**
+ * Creates a channel that is like this channel but the given effectful function
+ * gets applied to each emitted output element.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapOutEffect = mapOutEffect$1;
+
+/**
+ * Creates a channel that is like this channel but the given ZIO function gets
+ * applied to each emitted output element, taking `n` elements at once and
+ * mapping them in parallel.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapOutEffectPar = mapOutEffectPar$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAll = mergeAll$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAllUnbounded = mergeAllUnbounded$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAllUnboundedWith = mergeAllUnboundedWith$1;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAllWith = mergeAllWith$1;
+
+/**
+ * Returns a new channel which creates a new channel for each emitted element
+ * and merges some of them together. Different merge strategies control what
+ * happens if there are more than the given maximum number of channels gets
+ * created. See `Channel.mergeAll`.
+ *
+ * @param n The maximum number of channels to merge.
+ * @param f The function that creates a new channel from each emitted element.
+ * @since 2.0.0
+ * @category mapping
+ */
+const mergeMap = mergeMap$1;
+
+/**
+ * Returns a new channel which merges a number of channels emitted by this
+ * channel using the back pressuring merge strategy. See `Channel.mergeAll`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeOut = mergeOut$1;
+
+/**
+ * Returns a new channel which merges a number of channels emitted by this
+ * channel using the back pressuring merge strategy and uses a given function
+ * to merge each completed subchannel's result value. See
+ * `Channel.mergeAll`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeOutWith = mergeOutWith$1;
+
+/**
+ * Returns a new channel, which is the merge of this channel and the specified
+ * channel, where the behavior of the returned channel on left or right early
+ * termination is decided by the specified `leftDone` and `rightDone` merge
+ * decisions.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeWith = mergeWith$1;
+
+/**
+ * Returns a channel that never completes
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = never$1;
+
+/**
+ * Translates channel failure into death of the fiber, making all failures
+ * unchecked and not a part of the type of the channel.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDie = orDie$1;
+
+/**
+ * Keeps none of the errors, and terminates the fiber with them, using the
+ * specified function to convert the `OutErr` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDieWith = orDieWith$1;
+
+/**
+ * Returns a new channel that will perform the operations of this one, until
+ * failure, and then it will switch over to the operations of the specified
+ * fallback channel.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = orElse$1;
+
+/**
+ * Returns a new channel that pipes the output of this channel into the
+ * specified channel. The returned channel has the input type of this channel,
+ * and the output type of the specified channel, terminating with the value of
+ * the specified channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeTo = pipeTo$1;
+
+/**
+ * Returns a new channel that pipes the output of this channel into the
+ * specified channel and preserves this channel's failures without providing
+ * them to the other channel for observation.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeToOrFail = pipeToOrFail$1;
+
+/**
+ * Provides the channel with its required context, which eliminates its
+ * dependency on `Env`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = provideContext$1;
+
+/**
+ * Provides a layer to the channel, which translates it to another level.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideLayer = provideLayer$1;
+
+/**
+ * Transforms the context being provided to the channel with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = mapInputContext$1;
+
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `Env0`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideSomeLayer = provideSomeLayer$1;
+
+/**
+ * Provides the effect with the single service it requires. If the effect
+ * requires more than one service use `provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideService = provideService$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const read = read$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const readOrFail = readOrFail$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const readWith = readWith$1;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const readWithCause = readWithCause$1;
+
+/**
+ * Creates a channel which repeatedly runs this channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeated = repeated$1;
+
+/**
+ * Runs a channel until the end is received.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const run = run$1;
+
+/**
+ * Run the channel until it finishes with a done value or fails with an error
+ * and collects its emitted output elements.
+ *
+ * The channel must not read any input.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runCollect = runCollect$1;
+
+/**
+ * Runs a channel until the end is received.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runDrain = runDrain$1;
+
+/**
+ * Use a scoped effect to emit an output element.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scoped = scoped$1;
+
+/**
+ * Constructs a channel that succeeds immediately with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * Constructs a channel that succeeds immediately with the specified lazy value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = sync$1;
+
+/**
+ * Converts a `Channel` to a `Hub`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toHub = toHub$1;
+
+/**
+ * Returns a scoped `Effect` that can be used to repeatedly pull elements from
+ * the constructed `Channel`. The pull effect fails with the channel's failure
+ * in case the channel fails, or returns either the channel's done value or an
+ * emitted element.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toPull = toPull$1;
+
+/**
+ * Converts a `Channel` to a `Queue`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toQueue = toQueue$1;
+
+/** Converts this channel to a `Sink`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toSink = channelToSink;
+
+/**
+ * Converts this channel to a `Stream`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toStream = channelToStream;
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const unit = unit$1;
+
+/**
+ * Makes a channel from an effect that returns a channel in case of success.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = unwrap$1;
+
+/**
+ * Makes a channel from a managed that returns a channel in case of success.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrapScoped = unwrapScoped$1;
+
+/**
+ * Updates a service in the context of this channel.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const updateService = updateService$1;
+
+/**
+ * Wraps the channel with a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category tracing
+ */
+const withSpan = withSpan$1;
+
+/**
+ * Writes a single value to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const write = write$1;
+
+/**
+ * Writes a sequence of values to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const writeAll = writeAll$1;
+
+/**
+ * Writes a `Chunk` of values to the channel.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const writeChunk = writeChunk$1;
+
+/**
+ * Returns a new channel that is the sequential composition of this channel
+ * and the specified channel. The returned channel terminates with a tuple of
+ * the terminal values of both channels.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = zip$1;
+
+/**
+ * Returns a new channel that is the sequential composition of this channel
+ * and the specified channel. The returned channel terminates with the
+ * terminal value of this channel.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = zipLeft$1;
+
+/**
+ * Returns a new channel that is the sequential composition of this channel
+ * and the specified channel. The returned channel terminates with the
+ * terminal value of that channel.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = zipRight$1;
+
+/**
+ * Represents a generic checked exception which occurs when a `Channel` is
+ * executed.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+const ChannelException = ChannelException$1;
+
+/**
+ * Returns `true` if the specified value is an `ChannelException`, `false`
+ * otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isChannelException = isChannelException$1;
+
+var Channel = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ChannelTypeId: ChannelTypeId,
+  ChannelExceptionTypeId: ChannelExceptionTypeId,
+  acquireUseRelease: acquireUseRelease,
+  acquireReleaseOut: acquireReleaseOut,
+  as: as,
+  asUnit: asUnit,
+  buffer: buffer,
+  bufferChunk: bufferChunk,
+  catchAll: catchAll,
+  catchAllCause: catchAllCause,
+  concatAll: concatAll,
+  concatAllWith: concatAllWith,
+  concatMap: concatMap,
+  concatMapWith: concatMapWith,
+  concatMapWithCustom: concatMapWithCustom,
+  collect: collect,
+  concatOut: concatOut,
+  mapInput: mapInput,
+  mapInputEffect: mapInputEffect,
+  mapInputError: mapInputError,
+  mapInputErrorEffect: mapInputErrorEffect,
+  mapInputIn: mapInputIn,
+  mapInputInEffect: mapInputInEffect,
+  doneCollect: doneCollect,
+  drain: drain,
+  embedInput: embedInput,
+  emitCollect: emitCollect,
+  ensuring: ensuring,
+  ensuringWith: ensuringWith,
+  context: context,
+  contextWith: contextWith,
+  contextWithChannel: contextWithChannel,
+  contextWithEffect: contextWithEffect,
+  fail: fail,
+  failSync: failSync,
+  failCause: failCause,
+  failCauseSync: failCauseSync,
+  flatMap: flatMap,
+  flatten: flatten,
+  foldChannel: foldChannel,
+  foldCauseChannel: foldCauseChannel,
+  fromEffect: fromEffect,
+  fromEither: fromEither,
+  fromInput: fromInput,
+  fromHub: fromHub,
+  fromHubScoped: fromHubScoped,
+  fromOption: fromOption,
+  fromQueue: fromQueue,
+  identity: identity,
+  interruptWhen: interruptWhen,
+  interruptWhenDeferred: interruptWhenDeferred,
+  map: map,
+  mapEffect: mapEffect,
+  mapError: mapError,
+  mapErrorCause: mapErrorCause,
+  mapOut: mapOut,
+  mapOutEffect: mapOutEffect,
+  mapOutEffectPar: mapOutEffectPar,
+  mergeAll: mergeAll,
+  mergeAllUnbounded: mergeAllUnbounded,
+  mergeAllUnboundedWith: mergeAllUnboundedWith,
+  mergeAllWith: mergeAllWith,
+  mergeMap: mergeMap,
+  mergeOut: mergeOut,
+  mergeOutWith: mergeOutWith,
+  mergeWith: mergeWith,
+  never: never,
+  orDie: orDie,
+  orDieWith: orDieWith,
+  orElse: orElse,
+  pipeTo: pipeTo,
+  pipeToOrFail: pipeToOrFail,
+  provideContext: provideContext,
+  provideLayer: provideLayer,
+  mapInputContext: mapInputContext,
+  provideSomeLayer: provideSomeLayer,
+  provideService: provideService,
+  read: read,
+  readOrFail: readOrFail,
+  readWith: readWith,
+  readWithCause: readWithCause,
+  repeated: repeated,
+  run: run,
+  runCollect: runCollect,
+  runDrain: runDrain,
+  scoped: scoped,
+  succeed: succeed,
+  sync: sync,
+  toHub: toHub,
+  toPull: toPull,
+  toQueue: toQueue,
+  toSink: toSink,
+  toStream: toStream,
+  unit: unit,
+  unwrap: unwrap,
+  unwrapScoped: unwrapScoped,
+  updateService: updateService,
+  withSpan: withSpan,
+  write: write,
+  writeAll: writeAll,
+  writeChunk: writeChunk,
+  zip: zip,
+  zipLeft: zipLeft,
+  zipRight: zipRight,
+  ChannelException: ChannelException,
+  isChannelException: isChannelException
+});
+
+export { mapEffect as $, emitCollect as A, ensuring as B, Channel as C, ensuringWith as D, context as E, contextWith as F, contextWithChannel as G, contextWithEffect as H, fail as I, failSync as J, failCause as K, failCauseSync as L, flatMap as M, flatten as N, foldChannel as O, foldCauseChannel as P, fromEffect as Q, fromEither as R, fromInput as S, fromHub as T, fromHubScoped as U, fromOption as V, fromQueue as W, identity as X, interruptWhen as Y, interruptWhenDeferred as Z, map as _, ChannelTypeId as a, mapError as a0, mapErrorCause as a1, mapOut as a2, mapOutEffect as a3, mapOutEffectPar as a4, mergeAll as a5, mergeAllUnbounded as a6, mergeAllUnboundedWith as a7, mergeAllWith as a8, mergeMap as a9, toPull as aA, toQueue as aB, toSink as aC, toStream as aD, unit as aE, unwrap as aF, unwrapScoped as aG, updateService as aH, withSpan as aI, write as aJ, writeAll as aK, writeChunk as aL, zip as aM, zipLeft as aN, zipRight as aO, ChannelException as aP, isChannelException as aQ, mergeOut as aa, mergeOutWith as ab, mergeWith as ac, never as ad, orDie as ae, orDieWith as af, orElse as ag, pipeTo as ah, pipeToOrFail as ai, provideContext as aj, provideLayer as ak, mapInputContext as al, provideSomeLayer as am, provideService as an, read as ao, readOrFail as ap, readWith as aq, readWithCause as ar, repeated as as, run as at, runCollect as au, runDrain as av, scoped as aw, succeed as ax, sync as ay, toHub as az, ChannelExceptionTypeId as b, acquireUseRelease as c, acquireReleaseOut as d, as as e, asUnit as f, buffer as g, bufferChunk as h, catchAll as i, catchAllCause as j, concatAll as k, concatAllWith as l, concatMap as m, concatMapWith as n, concatMapWithCustom as o, collect as p, concatOut as q, mapInput as r, mapInputEffect as s, mapInputError as t, mapInputErrorEffect as u, mapInputIn as v, mapInputInEffect as w, doneCollect as x, drain as y, embedInput as z };