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

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

@@ -1,107 +1,1001 @@
-import '../../dist/sink-637a9670.esm.js';
-import '../../dist/stream-e44fba40.esm.js';
-export { aP as ChannelException, b as ChannelExceptionTypeId, a as ChannelTypeId, d as acquireReleaseOut, c as acquireUseRelease, e as as, f as asUnit, g as buffer, h as bufferChunk, i as catchAll, j as catchAllCause, p as collect, k as concatAll, l as concatAllWith, m as concatMap, n as concatMapWith, o as concatMapWithCustom, q as concatOut, E as context, F as contextWith, G as contextWithChannel, H as contextWithEffect, x as doneCollect, y as drain, z as embedInput, A as emitCollect, B as ensuring, D as ensuringWith, I as fail, K as failCause, L as failCauseSync, J as failSync, M as flatMap, N as flatten, P as foldCauseChannel, O as foldChannel, Q as fromEffect, R as fromEither, T as fromHub, U as fromHubScoped, S as fromInput, V as fromOption, W as fromQueue, X as identity, Y as interruptWhen, Z as interruptWhenDeferred, aQ as isChannelException, _ as map, $ as mapEffect, a0 as mapError, a1 as mapErrorCause, r as mapInput, al as mapInputContext, s as mapInputEffect, t as mapInputError, u as mapInputErrorEffect, v as mapInputIn, w as mapInputInEffect, a2 as mapOut, a3 as mapOutEffect, a4 as mapOutEffectPar, a5 as mergeAll, a6 as mergeAllUnbounded, a7 as mergeAllUnboundedWith, a8 as mergeAllWith, a9 as mergeMap, aa as mergeOut, ab as mergeOutWith, ac as mergeWith, ad as never, ae as orDie, af as orDieWith, ag as orElse, ah as pipeTo, ai as pipeToOrFail, aj as provideContext, ak as provideLayer, an as provideService, am as provideSomeLayer, ao as read, ap as readOrFail, aq as readWith, ar as readWithCause, as as repeated, at as run, au as runCollect, av as runDrain, aw as scoped, ax as succeed, ay as sync, az as toHub, aA as toPull, aB as toQueue, aC as toSink, aD as toStream, aE as unit, aF as unwrap, aG as unwrapScoped, aH as updateService, aI as withSpan, aJ as write, aK as writeAll, aL as writeChunk, aM as zip, aN as zipLeft, aO as zipRight } from '../../dist/Channel-4bba5096.esm.js';
-import '../../dist/Cause-5946c7a3.esm.js';
-import '../../dist/core-64ab7ff5.esm.js';
-import '../../dist/Chunk-4c1f4599.esm.js';
-import '../../dist/Equal-2a99fde3.esm.js';
-import '../../dist/Hash-7910f34f.esm.js';
-import '../../dist/Function-12511160.esm.js';
-import '../../dist/GlobalValue-b5edf230.esm.js';
-import '../../dist/Utils-80c21479.esm.js';
-import '../../dist/Predicate-6b61b95b.esm.js';
-import '../../dist/Equivalence-cf2752b1.esm.js';
-import '../../dist/Inspectable-b0c51e90.esm.js';
-import '../../dist/Option-df40d2b9.esm.js';
-import '../../dist/Either-408d23a8.esm.js';
-import '../../dist/Effectable-a292d920.esm.js';
-import '../../dist/Data-dee529b9.esm.js';
-import '../../dist/Pipeable-10760a1d.esm.js';
-import '../../dist/Number-4b836a09.esm.js';
-import '../../dist/Order-a875fe30.esm.js';
-import '../../dist/ReadonlyArray-0a71b226.esm.js';
-import '../../dist/Either-aa46c018.esm.js';
-import '../../dist/ReadonlyArray-c8b1f51c.esm.js';
-import '../../dist/ReadonlyRecord-c9f03980.esm.js';
-import '../../dist/Context-c41aa832.esm.js';
-import '../../dist/Context-149c432f.esm.js';
-import '../../dist/Differ-a249bf4d.esm.js';
-import '../../dist/HashMap-6c230bde.esm.js';
-import '../../dist/HashSet-69824ba8.esm.js';
-import '../../dist/Stack-765c2298.esm.js';
-import '../../dist/HashSet-ae2856c1.esm.js';
-import '../../dist/FiberId-17e50f05.esm.js';
-import '../../dist/MutableRef-2734b082.esm.js';
-import '../../dist/List-6e58a1e9.esm.js';
-import '../../dist/RuntimeFlagsPatch-51f77dce.esm.js';
-import '../../dist/Clock-f8b987d7.esm.js';
-import '../../dist/defaultServices-b9ca1236.esm.js';
-import '../../dist/Duration-98bca14c.esm.js';
-import '../../dist/timeout-4180303d.esm.js';
-import '../../dist/configProvider-c997961d.esm.js';
-import '../../dist/config-b039b99f.esm.js';
-import '../../dist/ConfigError-41421a53.esm.js';
-import '../../dist/configError-8b2e2999.esm.js';
-import '../../dist/configSecret-6e9eaf9d.esm.js';
-import '../../dist/pathPatch-f393ab1b.esm.js';
-import '../../dist/Effect-ee05a487.esm.js';
-import '../../dist/core-effect-57445976.esm.js';
-import '../../dist/FiberRefs-f705c1b5.esm.js';
-import '../../dist/fiberRefs-69cce1a0.esm.js';
-import '../../dist/patch-743d675c.esm.js';
-import '../../dist/label-0cc6c9a0.esm.js';
-import '../../dist/LogLevel-5a4fa506.esm.js';
-import '../../dist/LogSpan-f36e9619.esm.js';
-import '../../dist/Ref-5eefaff1.esm.js';
-import '../../dist/Tracer-da65ce12.esm.js';
-import '../../dist/circular-08fb0138.esm.js';
-import '../../dist/Exit-666b4f01.esm.js';
-import '../../dist/ExecutionStrategy-e3775e86.esm.js';
-import '../../dist/fiber-8fb398f3.esm.js';
-import '../../dist/FiberStatus-7a24d5ef.esm.js';
-import '../../dist/fiberRuntime-bfcf5f49.esm.js';
-import '../../dist/Boolean-bf38e241.esm.js';
-import '../../dist/Deferred-9010d2ac.esm.js';
-import '../../dist/FiberRefsPatch-04e0adc7.esm.js';
-import '../../dist/boundaries-52029180.esm.js';
-import '../../dist/key-340a2bae.esm.js';
-import '../../dist/keyType-869d90f8.esm.js';
-import '../../dist/registry-c59aeb06.esm.js';
-import '../../dist/hook-fd61107b.esm.js';
-import '../../dist/state-2c6abdb1.esm.js';
-import '../../dist/pair-5bb3eef4.esm.js';
-import '../../dist/MutableHashMap-02b39969.esm.js';
-import '../../dist/SortedSet-ffc2cefd.esm.js';
-import '../../dist/RedBlackTree-611b3b4c.esm.js';
-import '../../dist/Scheduler-844c1a90.esm.js';
-import '../../dist/schedule-566ae18c.esm.js';
-import '../../dist/Random-5ed16d23.esm.js';
-import '../../dist/ScheduleDecision-e0b221dc.esm.js';
-import '../../dist/ScheduleIntervals-c4dc0500.esm.js';
-import '../../dist/ScheduleInterval-cc7fc624.esm.js';
-import '../../dist/layer-35828af7.esm.js';
-import '../../dist/runtime-bcdd4416.esm.js';
-import '../../dist/Fiber-ebef9c60.esm.js';
-import '../../dist/synchronizedRef-1ceb6bd3.esm.js';
-import '../../dist/Scope-0253ac82.esm.js';
-import '../../dist/circular-e463e1e6.esm.js';
-import '../../dist/Layer-8586a429.esm.js';
-import '../../dist/query-242f7fda.esm.js';
-import '../../dist/cache-d62912e6.esm.js';
-import '../../dist/MutableQueue-446ac662.esm.js';
-import '../../dist/MutableList-76401868.esm.js';
-import '../../dist/Hub-121dbf51.esm.js';
-import '../../dist/queue-f74db567.esm.js';
-import '../../dist/Queue-d99be5de.esm.js';
-import '../../dist/childExecutorDecision-a7b466d2.esm.js';
-import '../../dist/upstreamPullStrategy-d5d1aa92.esm.js';
-import '../../dist/upstreamPullRequest-fed99e29.esm.js';
-import '../../dist/mergeDecision-d31cb28c.esm.js';
-import '../../dist/mergeState-1325df20.esm.js';
-import '../../dist/mergeStrategy-a88b5442.esm.js';
-import '../../dist/singleProducerAsyncInput-5b2ede75.esm.js';
-import '../../dist/ChannelMergeDecision-e5f34de0.esm.js';
-import '../../dist/Runtime-7b6c0a8b.esm.js';
-import '../../dist/Schedule-8502145c.esm.js';
-import '../../dist/StreamHaltStrategy-592df221.esm.js';
-import '../../dist/take-0d5e0eab.esm.js';
+import { ChannelExceptionTypeId as ChannelExceptionTypeId$1, acquireUseRelease as acquireUseRelease$1, as as as$1, asUnit as asUnit$1, buffer as buffer$1, bufferChunk as bufferChunk$1, catchAll as catchAll$1, concatMap as concatMap$1, collect as collect$1, concatOut as concatOut$1, mapInput as mapInput$1, mapInputEffect as mapInputEffect$1, mapInputError as mapInputError$1, mapInputErrorEffect as mapInputErrorEffect$1, mapInputIn as mapInputIn$1, mapInputInEffect as mapInputInEffect$1, doneCollect as doneCollect$1, drain as drain$1, emitCollect as emitCollect$1, ensuring as ensuring$1, context as context$1, contextWith as contextWith$1, contextWithChannel as contextWithChannel$1, contextWithEffect as contextWithEffect$1, flatten as flatten$1, foldChannel as foldChannel$1, fromEither as fromEither$1, fromInput as fromInput$1, fromHub as fromHub$1, fromHubScoped as fromHubScoped$1, fromOption as fromOption$1, fromQueue as fromQueue$1, identityChannel, interruptWhen as interruptWhen$1, interruptWhenDeferred as interruptWhenDeferred$1, map as map$1, mapEffect as mapEffect$1, mapError as mapError$1, mapErrorCause as mapErrorCause$1, mapOut as mapOut$1, mapOutEffect as mapOutEffect$1, mapOutEffectPar as mapOutEffectPar$1, mergeAll as mergeAll$1, mergeAllUnbounded as mergeAllUnbounded$1, mergeAllUnboundedWith as mergeAllUnboundedWith$1, mergeAllWith as mergeAllWith$1, mergeMap as mergeMap$1, mergeOut as mergeOut$1, mergeOutWith as mergeOutWith$1, mergeWith as mergeWith$1, never as never$1, orDie as orDie$1, orDieWith as orDieWith$1, orElse as orElse$1, pipeToOrFail as pipeToOrFail$1, provideLayer as provideLayer$1, mapInputContext as mapInputContext$1, provideSomeLayer as provideSomeLayer$1, provideService as provideService$1, read as read$1, repeated as repeated$1, run as run$1, runCollect as runCollect$1, runDrain as runDrain$1, scoped as scoped$1, toHub as toHub$1, toPull as toPull$1, toQueue as toQueue$1, unwrap as unwrap$1, unwrapScoped as unwrapScoped$1, updateService as updateService$1, withSpan as withSpan$1, writeAll as writeAll$1, writeChunk as writeChunk$1, zip as zip$1, zipLeft as zipLeft$1, zipRight as zipRight$1, ChannelException as ChannelException$1, isChannelException as isChannelException$1 } from '../../internal/channel.esm.js';
+import { ChannelTypeId as ChannelTypeId$1, acquireReleaseOut as acquireReleaseOut$1, catchAllCause as catchAllCause$1, concatAll as concatAll$1, concatAllWith as concatAllWith$1, concatMapWith as concatMapWith$1, concatMapWithCustom as concatMapWithCustom$1, embedInput as embedInput$1, ensuringWith as ensuringWith$1, fail as fail$1, failSync as failSync$1, failCause as failCause$1, failCauseSync as failCauseSync$1, flatMap as flatMap$1, foldCauseChannel as foldCauseChannel$1, fromEffect as fromEffect$1, pipeTo as pipeTo$1, provideContext as provideContext$1, readOrFail as readOrFail$1, readWith as readWith$1, readWithCause as readWithCause$1, succeed as succeed$1, sync as sync$1, unit as unit$1, write as write$1 } from '../../internal/core-stream.esm.js';
+import { channelToSink } from '../../internal/sink.esm.js';
+import { channelToStream } from '../../internal/stream.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;
+
+export { ChannelException, ChannelExceptionTypeId, ChannelTypeId, acquireReleaseOut, acquireUseRelease, as, asUnit, buffer, bufferChunk, catchAll, catchAllCause, collect, concatAll, concatAllWith, concatMap, concatMapWith, concatMapWithCustom, concatOut, context, contextWith, contextWithChannel, contextWithEffect, doneCollect, drain, embedInput, emitCollect, ensuring, ensuringWith, fail, failCause, failCauseSync, failSync, flatMap, flatten, foldCauseChannel, foldChannel, fromEffect, fromEither, fromHub, fromHubScoped, fromInput, fromOption, fromQueue, identity, interruptWhen, interruptWhenDeferred, isChannelException, map, mapEffect, mapError, mapErrorCause, mapInput, mapInputContext, mapInputEffect, mapInputError, mapInputErrorEffect, mapInputIn, mapInputInEffect, mapOut, mapOutEffect, mapOutEffectPar, mergeAll, mergeAllUnbounded, mergeAllUnboundedWith, mergeAllWith, mergeMap, mergeOut, mergeOutWith, mergeWith, never, orDie, orDieWith, orElse, pipeTo, pipeToOrFail, provideContext, provideLayer, provideService, provideSomeLayer, read, readOrFail, readWith, readWithCause, repeated, run, runCollect, runDrain, scoped, succeed, sync, toHub, toPull, toQueue, toSink, toStream, unit, unwrap, unwrapScoped, updateService, withSpan, write, writeAll, writeChunk, zip, zipLeft, zipRight };