effect 2.0.0-next.41 → 2.0.0-next.43

package/Stream/dist/effect-Stream.cjs.dev.js

@@ -2,406 +2,3278 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/groupBy-fa001ed8.cjs.dev.js');
-require('../../dist/stream-42bee6fa.cjs.dev.js');
-var Stream_dist_effectStream = require('../../dist/Stream-f833c9da.cjs.dev.js');
-require('../../dist/Cause-96c29074.cjs.dev.js');
-require('../../dist/core-ac668be0.cjs.dev.js');
-require('../../dist/Chunk-bd290b8e.cjs.dev.js');
-require('../../dist/Equal-281b6ca8.cjs.dev.js');
-require('../../dist/Hash-bd154268.cjs.dev.js');
-require('../../dist/Function-41ce433d.cjs.dev.js');
-require('../../dist/GlobalValue-81ab6908.cjs.dev.js');
-require('../../dist/Utils-b0c14d1b.cjs.dev.js');
-require('../../dist/Predicate-9e859c9c.cjs.dev.js');
-require('../../dist/Equivalence-de7a0d51.cjs.dev.js');
-require('../../dist/Inspectable-ac929af4.cjs.dev.js');
-require('../../dist/Option-03997d77.cjs.dev.js');
-require('../../dist/Either-9c349424.cjs.dev.js');
-require('../../dist/Effectable-a6403e5f.cjs.dev.js');
-require('../../dist/Data-85559fb3.cjs.dev.js');
-require('../../dist/Pipeable-4698db72.cjs.dev.js');
-require('../../dist/Number-588f6483.cjs.dev.js');
-require('../../dist/Order-28bdebd2.cjs.dev.js');
-require('../../dist/ReadonlyArray-48949ee7.cjs.dev.js');
-require('../../dist/Either-a806809d.cjs.dev.js');
+var groupBy$1 = require('../../dist/groupBy-bd943372.cjs.dev.js');
+var stream = require('../../dist/stream-adef675d.cjs.dev.js');
+require('../../Cause/dist/effect-Cause.cjs.dev.js');
+require('../../dist/core-b4d7b4f5.cjs.dev.js');
+require('../../Chunk/dist/effect-Chunk.cjs.dev.js');
+require('../../Equal/dist/effect-Equal.cjs.dev.js');
+require('../../Hash/dist/effect-Hash.cjs.dev.js');
+require('../../Function/dist/effect-Function.cjs.dev.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
+require('../../Utils/dist/effect-Utils.cjs.dev.js');
+require('../../Predicate/dist/effect-Predicate.cjs.dev.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.dev.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.dev.js');
+require('../../Option/dist/effect-Option.cjs.dev.js');
+require('../../dist/Either-12bbe00c.cjs.dev.js');
+require('../../dist/Effectable-2f022879.cjs.dev.js');
+require('../../Data/dist/effect-Data.cjs.dev.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
+require('../../Number/dist/effect-Number.cjs.dev.js');
+require('../../Order/dist/effect-Order.cjs.dev.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
+require('../../Either/dist/effect-Either.cjs.dev.js');
 require('../../dist/ReadonlyArray-9a1474f6.cjs.dev.js');
-require('../../dist/ReadonlyRecord-605a625b.cjs.dev.js');
-require('../../dist/Context-3c9e986b.cjs.dev.js');
-require('../../dist/Context-96739709.cjs.dev.js');
-require('../../dist/Differ-0122f60e.cjs.dev.js');
-require('../../dist/HashMap-68e290b6.cjs.dev.js');
-require('../../dist/HashSet-ece2cfe8.cjs.dev.js');
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js');
+require('../../Context/dist/effect-Context.cjs.dev.js');
+require('../../dist/Context-593661f6.cjs.dev.js');
+require('../../Differ/dist/effect-Differ.cjs.dev.js');
+require('../../HashMap/dist/effect-HashMap.cjs.dev.js');
+require('../../dist/HashSet-0b4ff1e4.cjs.dev.js');
 require('../../dist/Stack-ada2d201.cjs.dev.js');
-require('../../dist/HashSet-6978c08e.cjs.dev.js');
-require('../../dist/FiberId-929dcce4.cjs.dev.js');
-require('../../dist/MutableRef-724c4082.cjs.dev.js');
-require('../../dist/List-c6ea7efe.cjs.dev.js');
-require('../../dist/RuntimeFlagsPatch-130e990c.cjs.dev.js');
-require('../../dist/Deferred-5d5c886c.cjs.dev.js');
-require('../../dist/Effect-cf226187.cjs.dev.js');
-require('../../dist/defaultServices-60c753dc.cjs.dev.js');
-require('../../dist/Duration-604874d1.cjs.dev.js');
-require('../../dist/timeout-0245c158.cjs.dev.js');
-require('../../dist/configProvider-e2eb112d.cjs.dev.js');
-require('../../dist/config-10f2a1d1.cjs.dev.js');
-require('../../dist/ConfigError-c1f762d2.cjs.dev.js');
-require('../../dist/configError-1686533e.cjs.dev.js');
-require('../../dist/configSecret-5812fa69.cjs.dev.js');
-require('../../dist/pathPatch-e46d4168.cjs.dev.js');
-require('../../dist/core-effect-a9b8ee08.cjs.dev.js');
-require('../../dist/Clock-bec722c1.cjs.dev.js');
-require('../../dist/FiberRefs-43bfd8b9.cjs.dev.js');
-require('../../dist/fiberRefs-a7e00f7e.cjs.dev.js');
-require('../../dist/patch-4671ab7f.cjs.dev.js');
-require('../../dist/label-246fb11d.cjs.dev.js');
-require('../../dist/LogLevel-99f64f82.cjs.dev.js');
-require('../../dist/LogSpan-e345ba58.cjs.dev.js');
-require('../../dist/Ref-af783b72.cjs.dev.js');
-require('../../dist/Tracer-da182c8c.cjs.dev.js');
-require('../../dist/circular-4cb0b79d.cjs.dev.js');
-require('../../dist/Exit-a23874e1.cjs.dev.js');
-require('../../dist/ExecutionStrategy-89fbe735.cjs.dev.js');
-require('../../dist/fiber-da1a207c.cjs.dev.js');
-require('../../dist/FiberStatus-bac7d58d.cjs.dev.js');
-require('../../dist/fiberRuntime-e9680313.cjs.dev.js');
-require('../../dist/Boolean-f0bc3abf.cjs.dev.js');
-require('../../dist/FiberRefsPatch-5236f61e.cjs.dev.js');
-require('../../dist/boundaries-03c7494a.cjs.dev.js');
-require('../../dist/key-a474fc0d.cjs.dev.js');
-require('../../dist/keyType-1e916ae2.cjs.dev.js');
-require('../../dist/registry-c883cf52.cjs.dev.js');
-require('../../dist/hook-822704ea.cjs.dev.js');
-require('../../dist/state-8a8a647c.cjs.dev.js');
-require('../../dist/pair-08a8685e.cjs.dev.js');
-require('../../dist/MutableHashMap-74e83e84.cjs.dev.js');
-require('../../dist/SortedSet-f90b14a2.cjs.dev.js');
-require('../../dist/RedBlackTree-e6bd147c.cjs.dev.js');
-require('../../dist/Scheduler-d080442d.cjs.dev.js');
-require('../../dist/schedule-479d8fcc.cjs.dev.js');
-require('../../dist/Random-35304046.cjs.dev.js');
-require('../../dist/ScheduleDecision-ba8d0e87.cjs.dev.js');
-require('../../dist/ScheduleIntervals-b0bfcf3b.cjs.dev.js');
-require('../../dist/ScheduleInterval-51f42533.cjs.dev.js');
-require('../../dist/layer-7991a9d1.cjs.dev.js');
-require('../../dist/runtime-3ae98f19.cjs.dev.js');
-require('../../dist/Fiber-6432d5f7.cjs.dev.js');
-require('../../dist/synchronizedRef-58a64ffe.cjs.dev.js');
-require('../../dist/Scope-6ba9ec6d.cjs.dev.js');
-require('../../dist/circular-81e1906f.cjs.dev.js');
-require('../../dist/Layer-b05441ff.cjs.dev.js');
-require('../../dist/query-193d0a89.cjs.dev.js');
-require('../../dist/cache-6cdc31f7.cjs.dev.js');
-require('../../dist/MutableQueue-0e9f2466.cjs.dev.js');
-require('../../dist/MutableList-58124ef2.cjs.dev.js');
-require('../../dist/Queue-8d082fe4.cjs.dev.js');
-require('../../dist/queue-04ae7ec7.cjs.dev.js');
-require('../../dist/sink-3a597454.cjs.dev.js');
-require('../../dist/Hub-74834668.cjs.dev.js');
-require('../../dist/childExecutorDecision-ad3db696.cjs.dev.js');
-require('../../dist/upstreamPullStrategy-0ccf2960.cjs.dev.js');
-require('../../dist/upstreamPullRequest-c08f06a4.cjs.dev.js');
-require('../../dist/mergeDecision-e457a76b.cjs.dev.js');
-require('../../dist/mergeState-83204f38.cjs.dev.js');
-require('../../dist/mergeStrategy-b19dc19a.cjs.dev.js');
-require('../../dist/singleProducerAsyncInput-18fc5896.cjs.dev.js');
-require('../../dist/take-84a0722c.cjs.dev.js');
-require('../../dist/ChannelMergeDecision-eeaf4779.cjs.dev.js');
-require('../../dist/Runtime-c4b887ff.cjs.dev.js');
-require('../../dist/Schedule-b6c7b49a.cjs.dev.js');
-require('../../dist/StreamHaltStrategy-66a53f66.cjs.dev.js');
-
-
-
-exports.DefaultChunkSize = Stream_dist_effectStream.DefaultChunkSize;
-exports.Do = Stream_dist_effectStream.Do;
-exports.StreamTypeId = Stream_dist_effectStream.StreamTypeId;
-exports.acquireRelease = Stream_dist_effectStream.acquireRelease;
-exports.aggregate = Stream_dist_effectStream.aggregate;
-exports.aggregateWithin = Stream_dist_effectStream.aggregateWithin;
-exports.aggregateWithinEither = Stream_dist_effectStream.aggregateWithinEither;
-exports.as = Stream_dist_effectStream.as;
-exports.async = Stream_dist_effectStream._async;
-exports.asyncEffect = Stream_dist_effectStream.asyncEffect;
-exports.asyncInterrupt = Stream_dist_effectStream.asyncInterrupt;
-exports.asyncOption = Stream_dist_effectStream.asyncOption;
-exports.asyncScoped = Stream_dist_effectStream.asyncScoped;
-exports.bind = Stream_dist_effectStream.bind;
-exports.bindEffect = Stream_dist_effectStream.bindEffect;
-exports.bindTo = Stream_dist_effectStream.bindTo;
-exports.branchAfter = Stream_dist_effectStream.branchAfter;
-exports.broadcast = Stream_dist_effectStream.broadcast;
-exports.broadcastDynamic = Stream_dist_effectStream.broadcastDynamic;
-exports.broadcastedQueues = Stream_dist_effectStream.broadcastedQueues;
-exports.broadcastedQueuesDynamic = Stream_dist_effectStream.broadcastedQueuesDynamic;
-exports.buffer = Stream_dist_effectStream.buffer;
-exports.bufferChunks = Stream_dist_effectStream.bufferChunks;
-exports.catchAll = Stream_dist_effectStream.catchAll;
-exports.catchAllCause = Stream_dist_effectStream.catchAllCause;
-exports.catchSome = Stream_dist_effectStream.catchSome;
-exports.catchSomeCause = Stream_dist_effectStream.catchSomeCause;
-exports.catchTag = Stream_dist_effectStream.catchTag;
-exports.catchTags = Stream_dist_effectStream.catchTags;
-exports.changes = Stream_dist_effectStream.changes;
-exports.changesWith = Stream_dist_effectStream.changesWith;
-exports.changesWithEffect = Stream_dist_effectStream.changesWithEffect;
-exports.chunks = Stream_dist_effectStream.chunks;
-exports.chunksWith = Stream_dist_effectStream.chunksWith;
-exports.combine = Stream_dist_effectStream.combine;
-exports.combineChunks = Stream_dist_effectStream.combineChunks;
-exports.concat = Stream_dist_effectStream.concat;
-exports.concatAll = Stream_dist_effectStream.concatAll;
-exports.context = Stream_dist_effectStream.context;
-exports.contextWith = Stream_dist_effectStream.contextWith;
-exports.contextWithEffect = Stream_dist_effectStream.contextWithEffect;
-exports.contextWithStream = Stream_dist_effectStream.contextWithStream;
-exports.cross = Stream_dist_effectStream.cross;
-exports.crossLeft = Stream_dist_effectStream.crossLeft;
-exports.crossRight = Stream_dist_effectStream.crossRight;
-exports.crossWith = Stream_dist_effectStream.crossWith;
-exports.debounce = Stream_dist_effectStream.debounce;
-exports.decodeText = Stream_dist_effectStream.decodeText;
-exports.die = Stream_dist_effectStream.die;
-exports.dieMessage = Stream_dist_effectStream.dieMessage;
-exports.dieSync = Stream_dist_effectStream.dieSync;
-exports.distributedWith = Stream_dist_effectStream.distributedWith;
-exports.distributedWithDynamic = Stream_dist_effectStream.distributedWithDynamic;
-exports.drain = Stream_dist_effectStream.drain;
-exports.drainFork = Stream_dist_effectStream.drainFork;
-exports.drop = Stream_dist_effectStream.drop;
-exports.dropRight = Stream_dist_effectStream.dropRight;
-exports.dropUntil = Stream_dist_effectStream.dropUntil;
-exports.dropUntilEffect = Stream_dist_effectStream.dropUntilEffect;
-exports.dropWhile = Stream_dist_effectStream.dropWhile;
-exports.dropWhileEffect = Stream_dist_effectStream.dropWhileEffect;
-exports.either = Stream_dist_effectStream.either;
-exports.empty = Stream_dist_effectStream.empty;
-exports.encodeText = Stream_dist_effectStream.encodeText;
-exports.ensuring = Stream_dist_effectStream.ensuring;
-exports.ensuringWith = Stream_dist_effectStream.ensuringWith;
-exports.execute = Stream_dist_effectStream.execute;
-exports.fail = Stream_dist_effectStream.fail;
-exports.failCause = Stream_dist_effectStream.failCause;
-exports.failCauseSync = Stream_dist_effectStream.failCauseSync;
-exports.failSync = Stream_dist_effectStream.failSync;
-exports.filter = Stream_dist_effectStream.filter;
-exports.filterEffect = Stream_dist_effectStream.filterEffect;
-exports.filterMap = Stream_dist_effectStream.filterMap;
-exports.filterMapEffect = Stream_dist_effectStream.filterMapEffect;
-exports.filterMapWhile = Stream_dist_effectStream.filterMapWhile;
-exports.filterMapWhileEffect = Stream_dist_effectStream.filterMapWhileEffect;
-exports.finalizer = Stream_dist_effectStream.finalizer;
-exports.find = Stream_dist_effectStream.find;
-exports.findEffect = Stream_dist_effectStream.findEffect;
-exports.flatMap = Stream_dist_effectStream.flatMap;
-exports.flatten = Stream_dist_effectStream.flatten;
-exports.flattenChunks = Stream_dist_effectStream.flattenChunks;
-exports.flattenEffect = Stream_dist_effectStream.flattenEffect;
-exports.flattenExitOption = Stream_dist_effectStream.flattenExitOption;
-exports.flattenIterables = Stream_dist_effectStream.flattenIterables;
-exports.flattenTake = Stream_dist_effectStream.flattenTake;
-exports.forever = Stream_dist_effectStream.forever;
-exports.fromAsyncIterable = Stream_dist_effectStream.fromAsyncIterable;
-exports.fromChannel = Stream_dist_effectStream.fromChannel;
-exports.fromChunk = Stream_dist_effectStream.fromChunk;
-exports.fromChunkHub = Stream_dist_effectStream.fromChunkHub;
-exports.fromChunkQueue = Stream_dist_effectStream.fromChunkQueue;
-exports.fromChunks = Stream_dist_effectStream.fromChunks;
-exports.fromEffect = Stream_dist_effectStream.fromEffect;
-exports.fromEffectOption = Stream_dist_effectStream.fromEffectOption;
-exports.fromHub = Stream_dist_effectStream.fromHub;
-exports.fromIterable = Stream_dist_effectStream.fromIterable;
-exports.fromIterableEffect = Stream_dist_effectStream.fromIterableEffect;
-exports.fromIteratorSucceed = Stream_dist_effectStream.fromIteratorSucceed;
-exports.fromPull = Stream_dist_effectStream.fromPull;
-exports.fromQueue = Stream_dist_effectStream.fromQueue;
-exports.fromReadableStream = Stream_dist_effectStream.fromReadableStream;
-exports.fromReadableStreamByob = Stream_dist_effectStream.fromReadableStreamByob;
-exports.fromSchedule = Stream_dist_effectStream.fromSchedule;
-exports.groupAdjacentBy = Stream_dist_effectStream.groupAdjacentBy;
-exports.groupBy = Stream_dist_effectStream.groupBy;
-exports.groupByKey = Stream_dist_effectStream.groupByKey;
-exports.grouped = Stream_dist_effectStream.grouped;
-exports.groupedWithin = Stream_dist_effectStream.groupedWithin;
-exports.haltAfter = Stream_dist_effectStream.haltAfter;
-exports.haltWhen = Stream_dist_effectStream.haltWhen;
-exports.haltWhenDeferred = Stream_dist_effectStream.haltWhenDeferred;
-exports.identity = Stream_dist_effectStream.identity;
-exports.interleave = Stream_dist_effectStream.interleave;
-exports.interleaveWith = Stream_dist_effectStream.interleaveWith;
-exports.interruptAfter = Stream_dist_effectStream.interruptAfter;
-exports.interruptWhen = Stream_dist_effectStream.interruptWhen;
-exports.interruptWhenDeferred = Stream_dist_effectStream.interruptWhenDeferred;
-exports.intersperse = Stream_dist_effectStream.intersperse;
-exports.intersperseAffixes = Stream_dist_effectStream.intersperseAffixes;
-exports.iterate = Stream_dist_effectStream.iterate;
-exports["let"] = Stream_dist_effectStream.let_;
-exports.make = Stream_dist_effectStream.make;
-exports.map = Stream_dist_effectStream.map;
-exports.mapAccum = Stream_dist_effectStream.mapAccum;
-exports.mapAccumEffect = Stream_dist_effectStream.mapAccumEffect;
-exports.mapBoth = Stream_dist_effectStream.mapBoth;
-exports.mapChunks = Stream_dist_effectStream.mapChunks;
-exports.mapChunksEffect = Stream_dist_effectStream.mapChunksEffect;
-exports.mapConcat = Stream_dist_effectStream.mapConcat;
-exports.mapConcatChunk = Stream_dist_effectStream.mapConcatChunk;
-exports.mapConcatChunkEffect = Stream_dist_effectStream.mapConcatChunkEffect;
-exports.mapConcatEffect = Stream_dist_effectStream.mapConcatEffect;
-exports.mapEffect = Stream_dist_effectStream.mapEffect;
-exports.mapError = Stream_dist_effectStream.mapError;
-exports.mapErrorCause = Stream_dist_effectStream.mapErrorCause;
-exports.mapInputContext = Stream_dist_effectStream.mapInputContext;
-exports.merge = Stream_dist_effectStream.merge;
-exports.mergeAll = Stream_dist_effectStream.mergeAll;
-exports.mergeEither = Stream_dist_effectStream.mergeEither;
-exports.mergeLeft = Stream_dist_effectStream.mergeLeft;
-exports.mergeRight = Stream_dist_effectStream.mergeRight;
-exports.mergeWith = Stream_dist_effectStream.mergeWith;
-exports.mkString = Stream_dist_effectStream.mkString;
-exports.never = Stream_dist_effectStream.never;
-exports.onDone = Stream_dist_effectStream.onDone;
-exports.onError = Stream_dist_effectStream.onError;
-exports.orDie = Stream_dist_effectStream.orDie;
-exports.orDieWith = Stream_dist_effectStream.orDieWith;
-exports.orElse = Stream_dist_effectStream.orElse;
-exports.orElseEither = Stream_dist_effectStream.orElseEither;
-exports.orElseFail = Stream_dist_effectStream.orElseFail;
-exports.orElseIfEmpty = Stream_dist_effectStream.orElseIfEmpty;
-exports.orElseIfEmptyChunk = Stream_dist_effectStream.orElseIfEmptyChunk;
-exports.orElseIfEmptyStream = Stream_dist_effectStream.orElseIfEmptyStream;
-exports.orElseSucceed = Stream_dist_effectStream.orElseSucceed;
-exports.paginate = Stream_dist_effectStream.paginate;
-exports.paginateChunk = Stream_dist_effectStream.paginateChunk;
-exports.paginateChunkEffect = Stream_dist_effectStream.paginateChunkEffect;
-exports.paginateEffect = Stream_dist_effectStream.paginateEffect;
-exports.partition = Stream_dist_effectStream.partition;
-exports.partitionEither = Stream_dist_effectStream.partitionEither;
-exports.peel = Stream_dist_effectStream.peel;
-exports.pipeThrough = Stream_dist_effectStream.pipeThrough;
-exports.pipeThroughChannel = Stream_dist_effectStream.pipeThroughChannel;
-exports.pipeThroughChannelOrFail = Stream_dist_effectStream.pipeThroughChannelOrFail;
-exports.prepend = Stream_dist_effectStream.prepend;
-exports.provideContext = Stream_dist_effectStream.provideContext;
-exports.provideLayer = Stream_dist_effectStream.provideLayer;
-exports.provideService = Stream_dist_effectStream.provideService;
-exports.provideServiceEffect = Stream_dist_effectStream.provideServiceEffect;
-exports.provideServiceStream = Stream_dist_effectStream.provideServiceStream;
-exports.provideSomeLayer = Stream_dist_effectStream.provideSomeLayer;
-exports.range = Stream_dist_effectStream.range;
-exports.rechunk = Stream_dist_effectStream.rechunk;
-exports.refineOrDie = Stream_dist_effectStream.refineOrDie;
-exports.refineOrDieWith = Stream_dist_effectStream.refineOrDieWith;
-exports.repeat = Stream_dist_effectStream.repeat;
-exports.repeatEffect = Stream_dist_effectStream.repeatEffect;
-exports.repeatEffectChunk = Stream_dist_effectStream.repeatEffectChunk;
-exports.repeatEffectChunkOption = Stream_dist_effectStream.repeatEffectChunkOption;
-exports.repeatEffectOption = Stream_dist_effectStream.repeatEffectOption;
-exports.repeatEffectWithSchedule = Stream_dist_effectStream.repeatEffectWithSchedule;
-exports.repeatEither = Stream_dist_effectStream.repeatEither;
-exports.repeatElements = Stream_dist_effectStream.repeatElements;
-exports.repeatElementsWith = Stream_dist_effectStream.repeatElementsWith;
-exports.repeatValue = Stream_dist_effectStream.repeatValue;
-exports.repeatWith = Stream_dist_effectStream.repeatWith;
-exports.retry = Stream_dist_effectStream.retry;
-exports.run = Stream_dist_effectStream.run;
-exports.runCollect = Stream_dist_effectStream.runCollect;
-exports.runCount = Stream_dist_effectStream.runCount;
-exports.runDrain = Stream_dist_effectStream.runDrain;
-exports.runFold = Stream_dist_effectStream.runFold;
-exports.runFoldEffect = Stream_dist_effectStream.runFoldEffect;
-exports.runFoldScoped = Stream_dist_effectStream.runFoldScoped;
-exports.runFoldScopedEffect = Stream_dist_effectStream.runFoldScopedEffect;
-exports.runFoldWhile = Stream_dist_effectStream.runFoldWhile;
-exports.runFoldWhileEffect = Stream_dist_effectStream.runFoldWhileEffect;
-exports.runFoldWhileScoped = Stream_dist_effectStream.runFoldWhileScoped;
-exports.runFoldWhileScopedEffect = Stream_dist_effectStream.runFoldWhileScopedEffect;
-exports.runForEach = Stream_dist_effectStream.runForEach;
-exports.runForEachChunk = Stream_dist_effectStream.runForEachChunk;
-exports.runForEachChunkScoped = Stream_dist_effectStream.runForEachChunkScoped;
-exports.runForEachScoped = Stream_dist_effectStream.runForEachScoped;
-exports.runForEachWhile = Stream_dist_effectStream.runForEachWhile;
-exports.runForEachWhileScoped = Stream_dist_effectStream.runForEachWhileScoped;
-exports.runHead = Stream_dist_effectStream.runHead;
-exports.runIntoHub = Stream_dist_effectStream.runIntoHub;
-exports.runIntoHubScoped = Stream_dist_effectStream.runIntoHubScoped;
-exports.runIntoQueue = Stream_dist_effectStream.runIntoQueue;
-exports.runIntoQueueElementsScoped = Stream_dist_effectStream.runIntoQueueElementsScoped;
-exports.runIntoQueueScoped = Stream_dist_effectStream.runIntoQueueScoped;
-exports.runLast = Stream_dist_effectStream.runLast;
-exports.runScoped = Stream_dist_effectStream.runScoped;
-exports.runSum = Stream_dist_effectStream.runSum;
-exports.scan = Stream_dist_effectStream.scan;
-exports.scanEffect = Stream_dist_effectStream.scanEffect;
-exports.scanReduce = Stream_dist_effectStream.scanReduce;
-exports.scanReduceEffect = Stream_dist_effectStream.scanReduceEffect;
-exports.schedule = Stream_dist_effectStream.schedule;
-exports.scheduleWith = Stream_dist_effectStream.scheduleWith;
-exports.scoped = Stream_dist_effectStream.scoped;
-exports.sliding = Stream_dist_effectStream.sliding;
-exports.slidingSize = Stream_dist_effectStream.slidingSize;
-exports.some = Stream_dist_effectStream.some;
-exports.someOrElse = Stream_dist_effectStream.someOrElse;
-exports.someOrFail = Stream_dist_effectStream.someOrFail;
-exports.split = Stream_dist_effectStream.split;
-exports.splitLines = Stream_dist_effectStream.splitLines;
-exports.splitOnChunk = Stream_dist_effectStream.splitOnChunk;
-exports.succeed = Stream_dist_effectStream.succeed;
-exports.suspend = Stream_dist_effectStream.suspend;
-exports.sync = Stream_dist_effectStream.sync;
-exports.take = Stream_dist_effectStream.take;
-exports.takeRight = Stream_dist_effectStream.takeRight;
-exports.takeUntil = Stream_dist_effectStream.takeUntil;
-exports.takeUntilEffect = Stream_dist_effectStream.takeUntilEffect;
-exports.takeWhile = Stream_dist_effectStream.takeWhile;
-exports.tap = Stream_dist_effectStream.tap;
-exports.tapBoth = Stream_dist_effectStream.tapBoth;
-exports.tapError = Stream_dist_effectStream.tapError;
-exports.tapErrorCause = Stream_dist_effectStream.tapErrorCause;
-exports.tapSink = Stream_dist_effectStream.tapSink;
-exports.throttle = Stream_dist_effectStream.throttle;
-exports.throttleEffect = Stream_dist_effectStream.throttleEffect;
-exports.tick = Stream_dist_effectStream.tick;
-exports.timeout = Stream_dist_effectStream.timeout;
-exports.timeoutFail = Stream_dist_effectStream.timeoutFail;
-exports.timeoutFailCause = Stream_dist_effectStream.timeoutFailCause;
-exports.timeoutTo = Stream_dist_effectStream.timeoutTo;
-exports.toChannel = Stream_dist_effectStream.toChannel;
-exports.toHub = Stream_dist_effectStream.toHub;
-exports.toPull = Stream_dist_effectStream.toPull;
-exports.toQueue = Stream_dist_effectStream.toQueue;
-exports.toQueueOfElements = Stream_dist_effectStream.toQueueOfElements;
-exports.toReadableStream = Stream_dist_effectStream.toReadableStream;
-exports.transduce = Stream_dist_effectStream.transduce;
-exports.unfold = Stream_dist_effectStream.unfold;
-exports.unfoldChunk = Stream_dist_effectStream.unfoldChunk;
-exports.unfoldChunkEffect = Stream_dist_effectStream.unfoldChunkEffect;
-exports.unfoldEffect = Stream_dist_effectStream.unfoldEffect;
-exports.unit = Stream_dist_effectStream.unit;
-exports.unwrap = Stream_dist_effectStream.unwrap;
-exports.unwrapScoped = Stream_dist_effectStream.unwrapScoped;
-exports.updateService = Stream_dist_effectStream.updateService;
-exports.when = Stream_dist_effectStream.when;
-exports.whenCase = Stream_dist_effectStream.whenCase;
-exports.whenCaseEffect = Stream_dist_effectStream.whenCaseEffect;
-exports.whenEffect = Stream_dist_effectStream.whenEffect;
-exports.withSpan = Stream_dist_effectStream.withSpan;
-exports.zip = Stream_dist_effectStream.zip;
-exports.zipAll = Stream_dist_effectStream.zipAll;
-exports.zipAllLeft = Stream_dist_effectStream.zipAllLeft;
-exports.zipAllRight = Stream_dist_effectStream.zipAllRight;
-exports.zipAllSortedByKey = Stream_dist_effectStream.zipAllSortedByKey;
-exports.zipAllSortedByKeyLeft = Stream_dist_effectStream.zipAllSortedByKeyLeft;
-exports.zipAllSortedByKeyRight = Stream_dist_effectStream.zipAllSortedByKeyRight;
-exports.zipAllSortedByKeyWith = Stream_dist_effectStream.zipAllSortedByKeyWith;
-exports.zipAllWith = Stream_dist_effectStream.zipAllWith;
-exports.zipFlatten = Stream_dist_effectStream.zipFlatten;
-exports.zipLatest = Stream_dist_effectStream.zipLatest;
-exports.zipLatestWith = Stream_dist_effectStream.zipLatestWith;
-exports.zipLeft = Stream_dist_effectStream.zipLeft;
-exports.zipRight = Stream_dist_effectStream.zipRight;
-exports.zipWith = Stream_dist_effectStream.zipWith;
-exports.zipWithChunks = Stream_dist_effectStream.zipWithChunks;
-exports.zipWithIndex = Stream_dist_effectStream.zipWithIndex;
-exports.zipWithNext = Stream_dist_effectStream.zipWithNext;
-exports.zipWithPrevious = Stream_dist_effectStream.zipWithPrevious;
-exports.zipWithPreviousAndNext = Stream_dist_effectStream.zipWithPreviousAndNext;
+require('../../HashSet/dist/effect-HashSet.cjs.dev.js');
+require('../../dist/FiberId-557db880.cjs.dev.js');
+require('../../MutableRef/dist/effect-MutableRef.cjs.dev.js');
+require('../../List/dist/effect-List.cjs.dev.js');
+require('../../dist/RuntimeFlagsPatch-ea268c50.cjs.dev.js');
+require('../../Deferred/dist/effect-Deferred.cjs.dev.js');
+require('../../Effect/dist/effect-Effect.cjs.dev.js');
+require('../../dist/defaultServices-5530ff0e.cjs.dev.js');
+require('../../Duration/dist/effect-Duration.cjs.dev.js');
+require('../../dist/timeout-d380d3f8.cjs.dev.js');
+require('../../dist/configProvider-ce43fdbf.cjs.dev.js');
+require('../../dist/config-80900693.cjs.dev.js');
+require('../../ConfigError/dist/effect-ConfigError.cjs.dev.js');
+require('../../dist/configError-240e9b61.cjs.dev.js');
+require('../../dist/configSecret-e34c1b14.cjs.dev.js');
+require('../../dist/pathPatch-d9d41297.cjs.dev.js');
+require('../../dist/core-effect-892f3686.cjs.dev.js');
+require('../../Clock/dist/effect-Clock.cjs.dev.js');
+require('../../FiberRefs/dist/effect-FiberRefs.cjs.dev.js');
+require('../../dist/fiberRefs-be4fae6a.cjs.dev.js');
+require('../../dist/patch-a1b2802f.cjs.dev.js');
+require('../../dist/label-011edbe7.cjs.dev.js');
+require('../../LogLevel/dist/effect-LogLevel.cjs.dev.js');
+require('../../LogSpan/dist/effect-LogSpan.cjs.dev.js');
+require('../../dist/Ref-74b592a4.cjs.dev.js');
+require('../../Tracer/dist/effect-Tracer.cjs.dev.js');
+require('../../dist/circular-a4887ee9.cjs.dev.js');
+require('../../Exit/dist/effect-Exit.cjs.dev.js');
+require('../../dist/ExecutionStrategy-70f1a920.cjs.dev.js');
+require('../../dist/fiber-1bfb4c1d.cjs.dev.js');
+require('../../FiberStatus/dist/effect-FiberStatus.cjs.dev.js');
+require('../../dist/fiberRuntime-e0db0ab6.cjs.dev.js');
+require('../../Boolean/dist/effect-Boolean.cjs.dev.js');
+require('../../FiberRefsPatch/dist/effect-FiberRefsPatch.cjs.dev.js');
+require('../../dist/boundaries-3810d885.cjs.dev.js');
+require('../../dist/key-f0a1408a.cjs.dev.js');
+require('../../dist/keyType-55f27f07.cjs.dev.js');
+require('../../dist/registry-1099de3f.cjs.dev.js');
+require('../../dist/hook-e72b20fd.cjs.dev.js');
+require('../../dist/state-8fbec044.cjs.dev.js');
+require('../../dist/pair-291b78d7.cjs.dev.js');
+require('../../MutableHashMap/dist/effect-MutableHashMap.cjs.dev.js');
+require('../../SortedSet/dist/effect-SortedSet.cjs.dev.js');
+require('../../RedBlackTree/dist/effect-RedBlackTree.cjs.dev.js');
+require('../../Scheduler/dist/effect-Scheduler.cjs.dev.js');
+require('../../dist/schedule-e0f55cab.cjs.dev.js');
+require('../../Random/dist/effect-Random.cjs.dev.js');
+require('../../ScheduleDecision/dist/effect-ScheduleDecision.cjs.dev.js');
+require('../../ScheduleIntervals/dist/effect-ScheduleIntervals.cjs.dev.js');
+require('../../ScheduleInterval/dist/effect-ScheduleInterval.cjs.dev.js');
+require('../../dist/layer-9cbb61ce.cjs.dev.js');
+require('../../dist/runtime-15cc9cc5.cjs.dev.js');
+require('../../Fiber/dist/effect-Fiber.cjs.dev.js');
+require('../../dist/synchronizedRef-37e32854.cjs.dev.js');
+require('../../Scope/dist/effect-Scope.cjs.dev.js');
+require('../../dist/circular-2162b720.cjs.dev.js');
+require('../../Layer/dist/effect-Layer.cjs.dev.js');
+require('../../dist/query-67a7c448.cjs.dev.js');
+require('../../dist/cache-83d14f6e.cjs.dev.js');
+require('../../MutableQueue/dist/effect-MutableQueue.cjs.dev.js');
+require('../../MutableList/dist/effect-MutableList.cjs.dev.js');
+require('../../Queue/dist/effect-Queue.cjs.dev.js');
+require('../../dist/queue-997d6e51.cjs.dev.js');
+require('../../dist/sink-1ac24bca.cjs.dev.js');
+require('../../Hub/dist/effect-Hub.cjs.dev.js');
+require('../../dist/childExecutorDecision-2eed6e25.cjs.dev.js');
+require('../../dist/upstreamPullStrategy-f9f1ab57.cjs.dev.js');
+require('../../dist/upstreamPullRequest-7a694281.cjs.dev.js');
+require('../../dist/mergeDecision-be41e797.cjs.dev.js');
+require('../../dist/mergeState-8153ce39.cjs.dev.js');
+require('../../dist/mergeStrategy-81ea5b80.cjs.dev.js');
+require('../../dist/singleProducerAsyncInput-998b8fac.cjs.dev.js');
+require('../../dist/take-4857b6af.cjs.dev.js');
+require('../../ChannelMergeDecision/dist/effect-ChannelMergeDecision.cjs.dev.js');
+require('../../Runtime/dist/effect-Runtime.cjs.dev.js');
+require('../../Schedule/dist/effect-Schedule.cjs.dev.js');
+require('../../dist/StreamHaltStrategy-9a61b88d.cjs.dev.js');
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const StreamTypeId = stream.StreamTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * A `Stream<R, E, A>` is a description of a program that, when evaluated, may
+ * emit zero or more values of type `A`, may fail with errors of type `E`, and
+ * uses an context of type `R`. One way to think of `Stream` is as a
+ * `Effect` program that could emit multiple values.
+ *
+ * `Stream` is a purely functional *pull* based stream. Pull based streams offer
+ * inherent laziness and backpressure, relieving users of the need to manage
+ * buffers between operators. As an optimization, `Stream` does not emit
+ * single values, but rather an array of values. This allows the cost of effect
+ * evaluation to be amortized.
+ *
+ * `Stream` forms a monad on its `A` type parameter, and has error management
+ * facilities for its `E` type parameter, modeled similarly to `Effect` (with
+ * some adjustments for the multiple-valued nature of `Stream`). These aspects
+ * allow for rich and expressive composition of streams.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * The default chunk size used by the various combinators and constructors of
+ * `Stream`.
+ *
+ * @since 2.0.0
+ * @category constants
+ */
+const DefaultChunkSize = stream.DefaultChunkSize;
+
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireRelease = stream.acquireRelease;
+
+/**
+ * Aggregates elements of this stream using the provided sink for as long as
+ * the downstream operators on the stream are busy.
+ *
+ * This operator divides the stream into two asynchronous "islands". Operators
+ * upstream of this operator run on one fiber, while downstream operators run
+ * on another. Whenever the downstream fiber is busy processing elements, the
+ * upstream fiber will feed elements into the sink until it signals
+ * completion.
+ *
+ * Any sink can be used here, but see `Sink.foldWeightedEffect` and
+ * `Sink.foldUntilEffect` for sinks that cover the common usecases.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const aggregate = stream.aggregate;
+
+/**
+ * Like `aggregateWithinEither`, but only returns the `Right` results.
+ *
+ * @param sink A `Sink` used to perform the aggregation.
+ * @param schedule A `Schedule` used to signal when to stop the aggregation.
+ * @since 2.0.0
+ * @category utils
+ */
+const aggregateWithin = stream.aggregateWithin;
+
+/**
+ * Aggregates elements using the provided sink until it completes, or until
+ * the delay signalled by the schedule has passed.
+ *
+ * This operator divides the stream into two asynchronous islands. Operators
+ * upstream of this operator run on one fiber, while downstream operators run
+ * on another. Elements will be aggregated by the sink until the downstream
+ * fiber pulls the aggregated value, or until the schedule's delay has passed.
+ *
+ * Aggregated elements will be fed into the schedule to determine the delays
+ * between pulls.
+ *
+ * @param sink A `Sink` used to perform the aggregation.
+ * @param schedule A `Schedule` used to signal when to stop the aggregation.
+ * @since 2.0.0
+ * @category utils
+ */
+const aggregateWithinEither = stream.aggregateWithinEither;
+
+/**
+ * Maps the success values of this stream to the specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = stream.as;
+const _async = stream._async;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times The registration of the callback itself returns an effect. The
+ * optionality of the error type `E` can be used to signal the end of the
+ * stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncEffect = stream.asyncEffect;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback returns either a canceler or
+ * synchronously returns a stream. The optionality of the error type `E` can
+ * be used to signal the end of the stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncInterrupt = stream.asyncInterrupt;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback can possibly return the stream
+ * synchronously. The optionality of the error type `E` can be used to signal
+ * the end of the stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncOption = stream.asyncOption;
+
+/**
+ * Creates a stream from an asynchronous callback that can be called multiple
+ * times. The registration of the callback itself returns an a scoped
+ * resource. The optionality of the error type `E` can be used to signal the
+ * end of the stream, by setting it to `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const asyncScoped = stream.asyncScoped;
+
+/**
+ * Returns a `Stream` that first collects `n` elements from the input `Stream`,
+ * and then creates a new `Stream` using the specified function, and sends all
+ * the following elements through that.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const branchAfter = stream.branchAfter;
+
+/**
+ * Fan out the stream, producing a list of streams that have the same elements
+ * as this stream. The driver stream will only ever advance the `maximumLag`
+ * chunks before the slowest downstream stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcast = stream.broadcast;
+
+/**
+ * Fan out the stream, producing a dynamic number of streams that have the
+ * same elements as this stream. The driver stream will only ever advance the
+ * `maximumLag` chunks before the slowest downstream stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcastDynamic = stream.broadcastDynamic;
+
+/**
+ * Converts the stream to a scoped list of queues. Every value will be
+ * replicated to every queue with the slowest queue being allowed to buffer
+ * `maximumLag` chunks before the driver is back pressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcastedQueues = stream.broadcastedQueues;
+
+/**
+ * Converts the stream to a scoped dynamic amount of queues. Every chunk will
+ * be replicated to every queue with the slowest queue being allowed to buffer
+ * `maximumLag` chunks before the driver is back pressured.
+ *
+ * Queues can unsubscribe from upstream by shutting down.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const broadcastedQueuesDynamic = stream.broadcastedQueuesDynamic;
+
+/**
+ * Allows a faster producer to progress independently of a slower consumer by
+ * buffering up to `capacity` elements in a queue.
+ *
+ * @note This combinator destroys the chunking structure. It's recommended to
+ *       use rechunk afterwards. Additionally, prefer capacities that are powers
+ *       of 2 for better performance.
+ * @since 2.0.0
+ * @category utils
+ */
+const buffer = stream.buffer;
+
+/**
+ * Allows a faster producer to progress independently of a slower consumer by
+ * buffering up to `capacity` chunks in a queue.
+ *
+ * @note Prefer capacities that are powers of 2 for better performance.
+ * @since 2.0.0
+ * @category utils
+ */
+const bufferChunks = stream.bufferChunks;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with a typed error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = stream.catchAll;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails. Allows recovery from all causes of failure, including
+ * interruption if the stream is uninterruptible.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAllCause = stream.catchAllCause;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with some typed error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSome = stream.catchSome;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with an error matching the given `_tag`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTag = stream.catchTag;
+
+/**
+ * Switches over to the stream produced by one of the provided functions, in
+ * case this one fails with an error matching one of the given `_tag`'s.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTags = stream.catchTags;
+
+/**
+ * Switches over to the stream produced by the provided function in case this
+ * one fails with some errors. Allows recovery from all causes of failure,
+ * including interruption if the stream is uninterruptible.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSomeCause = stream.catchSomeCause;
+
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using natural equality to determine whether two
+ * elements are equal.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const changes = stream.changes;
+
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified function to determine whether
+ * two elements are equal.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const changesWith = stream.changesWith;
+
+/**
+ * Returns a new stream that only emits elements that are not equal to the
+ * previous element emitted, using the specified effectual function to
+ * determine whether two elements are equal.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const changesWithEffect = stream.changesWithEffect;
+
+/**
+ * Exposes the underlying chunks of the stream as a stream of chunks of
+ * elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const chunks = stream.chunks;
+
+/**
+ * Performs the specified stream transformation with the chunk structure of
+ * the stream exposed.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const chunksWith = stream.chunksWith;
+
+/**
+ * Combines the elements from this stream and the specified stream by
+ * repeatedly applying the function `f` to extract an element using both sides
+ * and conceptually "offer" it to the destination stream. `f` can maintain
+ * some internal state to control the combining process, with the initial
+ * state being specified by `s`.
+ *
+ * Where possible, prefer `Stream.combineChunks` for a more efficient
+ * implementation.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const combine = stream.combine;
+
+/**
+ * Combines the chunks from this stream and the specified stream by repeatedly
+ * applying the function `f` to extract a chunk using both sides and
+ * conceptually "offer" it to the destination stream. `f` can maintain some
+ * internal state to control the combining process, with the initial state
+ * being specified by `s`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const combineChunks = stream.combineChunks;
+
+/**
+ * Concatenates the specified stream with this stream, resulting in a stream
+ * that emits the elements from this stream and then the elements from the
+ * specified stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const concat = stream.concat;
+
+/**
+ * Concatenates all of the streams in the chunk to one stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const concatAll = stream.concatAll;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements. The `that` stream would be run multiple times, for
+ * every element in the `this` stream.
+ *
+ * See also `Stream.zip` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const cross = stream.cross;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements, but keeps only elements from this stream. The `that`
+ * stream would be run multiple times, for every element in the `this` stream.
+ *
+ * See also `Stream.zipLeft` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const crossLeft = stream.crossLeft;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements, but keeps only elements from the other stream. The
+ * `that` stream would be run multiple times, for every element in the `this`
+ * stream.
+ *
+ * See also `Stream.zipRight` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const crossRight = stream.crossRight;
+
+/**
+ * Composes this stream with the specified stream to create a cartesian
+ * product of elements with a specified function. The `that` stream would be
+ * run multiple times, for every element in the `this` stream.
+ *
+ * See also `Stream.zipWith` for the more common point-wise variant.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const crossWith = stream.crossWith;
+
+/**
+ * Delays the emission of values by holding new values for a set duration. If
+ * no new values arrive during that time the value is emitted, however if a
+ * new value is received during the holding period the previous value is
+ * discarded and the process is repeated with the new value.
+ *
+ * This operator is useful if you have a stream of "bursty" events which
+ * eventually settle down and you only need the final event of the burst. For
+ * example, a search engine may only want to initiate a search after a user
+ * has paused typing so as to not prematurely recommend results.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const debounce = stream.debounce;
+
+/**
+ * The stream that dies with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = stream.die;
+
+/**
+ * The stream that dies with the specified lazily evaluated defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = stream.dieSync;
+
+/**
+ * The stream that dies with an exception described by `message`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = stream.dieMessage;
+
+/**
+ * More powerful version of `Stream.broadcast`. Allows to provide a function
+ * that determines what queues should receive which elements. The decide
+ * function will receive the indices of the queues in the resulting list.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const distributedWith = stream.distributedWith;
+
+/**
+ * More powerful version of `Stream.distributedWith`. This returns a function
+ * that will produce new queues and corresponding indices. You can also
+ * provide a function that will be executed after the final events are
+ * enqueued in all queues. Shutdown of the queues is handled by the driver.
+ * Downstream users can also shutdown queues manually. In this case the driver
+ * will continue but no longer backpressure on them.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const distributedWithDynamic = stream.distributedWithDynamic;
+
+/**
+ * Converts this stream to a stream that executes its effects but emits no
+ * elements. Useful for sequencing effects using streams:
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drain = stream.drain;
+
+/**
+ * Drains the provided stream in the background for as long as this stream is
+ * running. If this stream ends before `other`, `other` will be interrupted.
+ * If `other` fails, this stream will fail with that error.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drainFork = stream.drainFork;
+
+/**
+ * Drops the specified number of elements from this stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const drop = stream.drop;
+
+/**
+ * Drops the last specified number of elements from this stream.
+ *
+ * @note This combinator keeps `n` elements in memory. Be careful with big
+ *       numbers.
+ * @since 2.0.0
+ * @category utils
+ */
+const dropRight = stream.dropRight;
+
+/**
+ * Drops all elements of the stream until the specified predicate evaluates to
+ * `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropUntil = stream.dropUntil;
+
+/**
+ * Drops all elements of the stream until the specified effectful predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropUntilEffect = stream.dropUntilEffect;
+
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropWhile = stream.dropWhile;
+
+/**
+ * Drops all elements of the stream for as long as the specified predicate
+ * produces an effect that evalutates to `true`
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const dropWhileEffect = stream.dropWhileEffect;
+
+/**
+ * Returns a stream whose failures and successes have been lifted into an
+ * `Either`. The resulting stream cannot fail, because the failures have been
+ * exposed as part of the `Either` success case.
+ *
+ * @note The stream will end as soon as the first error occurs.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const either = stream.either;
+
+/**
+ * The empty stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = stream.empty;
+
+/**
+ * Executes the provided finalizer after this stream's finalizers run.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ensuring = stream.ensuring;
+
+/**
+ * Executes the provided finalizer after this stream's finalizers run.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const ensuringWith = stream.ensuringWith;
+
+/**
+ * Accesses the whole context of the stream.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const context = stream.context;
+
+/**
+ * Accesses the context of the stream.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWith = stream.contextWith;
+
+/**
+ * Accesses the context of the stream in the context of an effect.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithEffect = stream.contextWithEffect;
+
+/**
+ * Accesses the context of the stream in the context of a stream.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const contextWithStream = stream.contextWithStream;
+
+/**
+ * Creates a stream that executes the specified effect but emits no elements.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const execute = stream.execute;
+
+/**
+ * Terminates with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = stream.fail;
+
+/**
+ * Terminates with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = stream.failSync;
+
+/**
+ * The stream that always fails with the specified `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = stream.failCause;
+
+/**
+ * The stream that always fails with the specified lazily evaluated `Cause`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCauseSync = stream.failCauseSync;
+
+/**
+ * Filters the elements emitted by this stream using the provided function.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filter = stream.filter;
+
+/**
+ * Effectfully filters the elements emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterEffect = stream.filterEffect;
+
+/**
+ * Performs a filter and map in a single step.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMap = stream.filterMap;
+
+/**
+ * Performs an effectful filter and map in a single step.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMapEffect = stream.filterMapEffect;
+
+/**
+ * Transforms all elements of the stream for as long as the specified partial
+ * function is defined.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMapWhile = stream.filterMapWhile;
+
+/**
+ * Effectfully transforms all elements of the stream for as long as the
+ * specified partial function is defined.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const filterMapWhileEffect = stream.filterMapWhileEffect;
+
+/**
+ * Creates a one-element stream that never fails and executes the finalizer
+ * when it ends.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const finalizer = stream.finalizer;
+
+/**
+ * Finds the first element emitted by this stream that satisfies the provided
+ * predicate.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const find = stream.find;
+
+/**
+ * Finds the first element emitted by this stream that satisfies the provided
+ * effectful predicate.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const findEffect = stream.findEffect;
+
+/**
+ * Returns a stream made of the concatenation in strict order of all the
+ * streams produced by passing each element of this stream to `f0`
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = stream.flatMap;
+
+/**
+ * Flattens this stream-of-streams into a stream made of the concatenation in
+ * strict order of all the streams.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = stream.flatten;
+
+/**
+ * Submerges the chunks carried by this stream into the stream's structure,
+ * while still preserving them.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenChunks = stream.flattenChunks;
+
+/**
+ * Flattens `Effect` values into the stream's structure, preserving all
+ * information about the effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenEffect = stream.flattenEffect;
+
+/**
+ * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
+ *
+ * For `Exit` values that do not signal end-of-stream, prefer:
+ *
+ * ```ts
+ * stream.mapZIO(ZIO.done(_))
+ * ```
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenExitOption = stream.flattenExitOption;
+
+/**
+ * Submerges the iterables carried by this stream into the stream's structure,
+ * while still preserving them.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenIterables = stream.flattenIterables;
+
+/**
+ * Unwraps `Exit` values and flatten chunks that also signify end-of-stream
+ * by failing with `None`.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flattenTake = stream.flattenTake;
+
+/**
+ * Repeats this stream forever.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const forever = stream.forever;
+
+/**
+ * Creates a stream from an `AsyncIterable`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromAsyncIterable = stream.fromAsyncIterable;
+
+/**
+ * Creates a stream from a `Channel`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChannel = stream.fromChannel;
+
+/**
+ * Creates a channel from a `Stream`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const toChannel = stream.toChannel;
+
+/**
+ * Creates a stream from a `Chunk` of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunk = stream.fromChunk;
+
+/**
+ * Creates a stream from a subscription to a `Hub`.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunkHub = stream.fromChunkHub;
+
+/**
+ * Creates a stream from a `Queue` of values.
+ *
+ * @param shutdown If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunkQueue = stream.fromChunkQueue;
+
+/**
+ * Creates a stream from an arbitrary number of chunks.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromChunks = stream.fromChunks;
+
+/**
+ * Either emits the success value of this effect or terminates the stream
+ * with the failure value of this effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffect = stream.fromEffect;
+
+/**
+ * Creates a stream from an effect producing a value of type `A` or an empty
+ * `Stream`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEffectOption = stream.fromEffectOption;
+
+/**
+ * Creates a stream from a subscription to a `Hub`.
+ *
+ * @param shutdown If `true`, the hub will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromHub = stream.fromHub;
+
+/**
+ * Creates a stream from an `Iterable` collection of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterable = stream.fromIterable;
+
+/**
+ * Creates a stream from an effect producing a value of type `Iterable<A>`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIterableEffect = stream.fromIterableEffect;
+
+/**
+ * Creates a stream from an iterator
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromIteratorSucceed = stream.fromIteratorSucceed;
+
+/**
+ * Creates a stream from an effect that pulls elements from another stream.
+ *
+ * See `Stream.toPull` for reference.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromPull = stream.fromPull;
+
+/**
+ * Creates a stream from a queue of values
+ *
+ * @param maxChunkSize The maximum number of queued elements to put in one chunk in the stream
+ * @param shutdown If `true`, the queue will be shutdown after the stream is evaluated (defaults to `false`)
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromQueue = stream.fromQueue;
+
+/**
+ * Creates a stream from a `ReadableStream`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromReadableStream = stream.fromReadableStream;
+
+/**
+ * Creates a stream from a `ReadableStreamBYOBReader`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader.
+ *
+ * @param allocSize Controls the size of the underlying `ArrayBuffer` (defaults to `4096`).
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromReadableStreamByob = stream.fromReadableStreamByob;
+
+/**
+ * Creates a stream from a `Schedule` that does not require any further
+ * input. The stream will emit an element for each value output from the
+ * schedule, continuing for as long as the schedule continues.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromSchedule = stream.fromSchedule;
+
+/**
+ * Creates a pipeline that groups on adjacent keys, calculated by the
+ * specified function.
+ *
+ * @since 2.0.0
+ * @category grouping
+ */
+const groupAdjacentBy = stream.groupAdjacentBy;
+
+/**
+ * More powerful version of `Stream.groupByKey`.
+ *
+ * @since 2.0.0
+ * @category grouping
+ */
+const groupBy = groupBy$1.groupBy;
+
+/**
+ * Partition a stream using a function and process each stream individually.
+ * This returns a data structure that can be used to further filter down which
+ * groups shall be processed.
+ *
+ * After calling apply on the GroupBy object, the remaining groups will be
+ * processed in parallel and the resulting streams merged in a
+ * nondeterministic fashion.
+ *
+ * Up to `buffer` elements may be buffered in any group stream before the
+ * producer is backpressured. Take care to consume from all streams in order
+ * to prevent deadlocks.
+ *
+ * For example, to collect the first 2 words for every starting letter from a
+ * stream of words:
+ *
+ * ```ts
+ * import * as GroupBy from "./GroupBy"
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.fromIterable(["hello", "world", "hi", "holla"]),
+ *   Stream.groupByKey((word) => word[0]),
+ *   GroupBy.evaluate((key, stream) =>
+ *     pipe(
+ *       stream,
+ *       Stream.take(2),
+ *       Stream.map((words) => [key, words] as const)
+ *     )
+ *   )
+ * )
+ * ```
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const groupByKey = groupBy$1.groupByKey;
+
+/**
+ * Partitions the stream with specified `chunkSize`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const grouped = stream.grouped;
+
+/**
+ * Partitions the stream with the specified `chunkSize` or until the specified
+ * `duration` has passed, whichever is satisfied first.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const groupedWithin = stream.groupedWithin;
+
+/**
+ * Specialized version of haltWhen which halts the evaluation of this stream
+ * after the given duration.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * given duration completes. See `interruptAfter` for this behavior.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const haltAfter = stream.haltAfter;
+
+/**
+ * Halts the evaluation of this stream when the provided effect completes. The
+ * given effect will be forked as part of the returned stream, and its success
+ * will be discarded.
+ *
+ * An element in the process of being pulled will not be interrupted when the
+ * effect completes. See `interruptWhen` for this behavior.
+ *
+ * If the effect completes with a failure, the stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const haltWhen = stream.haltWhen;
+
+/**
+ * Halts the evaluation of this stream when the provided promise resolves.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const haltWhenDeferred = stream.haltWhenDeferred;
+
+/**
+ * The identity pipeline, which does not modify streams in any way.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const identity = stream.identityStream;
+
+/**
+ * Interleaves this stream and the specified stream deterministically by
+ * alternating pulling values from this stream and the specified stream. When
+ * one stream is exhausted all remaining values in the other stream will be
+ * pulled.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interleave = stream.interleave;
+
+/**
+ * Combines this stream and the specified stream deterministically using the
+ * stream of boolean values `pull` to control which stream to pull from next.
+ * A value of `true` indicates to pull from this stream and a value of `false`
+ * indicates to pull from the specified stream. Only consumes as many elements
+ * as requested by the `pull` stream. If either this stream or the specified
+ * stream are exhausted further requests for values from that stream will be
+ * ignored.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interleaveWith = stream.interleaveWith;
+
+/**
+ * Intersperse stream with provided `element`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const intersperse = stream.intersperse;
+
+/**
+ * Intersperse the specified element, also adding a prefix and a suffix.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const intersperseAffixes = stream.intersperseAffixes;
+
+/**
+ * Specialized version of `Stream.interruptWhen` which interrupts the
+ * evaluation of this stream after the given `Duration`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptAfter = stream.interruptAfter;
+
+/**
+ * Interrupts the evaluation of this stream when the provided effect
+ * completes. The given effect will be forked as part of this stream, and its
+ * success will be discarded. This combinator will also interrupt any
+ * in-progress element being pulled from upstream.
+ *
+ * If the effect completes with a failure before the stream completes, the
+ * returned stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptWhen = stream.interruptWhen;
+
+/**
+ * Interrupts the evaluation of this stream when the provided promise
+ * resolves. This combinator will also interrupt any in-progress element being
+ * pulled from upstream.
+ *
+ * If the promise completes with a failure, the stream will emit that failure.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interruptWhenDeferred = stream.interruptWhenDeferred;
+
+/**
+ * The infinite stream of iterative function application: a, f(a), f(f(a)),
+ * f(f(f(a))), ...
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const iterate = stream.iterate;
+
+/**
+ * Creates a stream from an sequence of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = stream.make;
+
+/**
+ * Transforms the elements of this stream using the supplied function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = stream.map;
+
+/**
+ * Statefully maps over the elements of this stream to produce new elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapAccum = stream.mapAccum;
+
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * new elements.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapAccumEffect = stream.mapAccumEffect;
+
+/**
+ * Returns a stream whose failure and success channels have been mapped by the
+ * specified `onFailure` and `onSuccess` functions.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mapBoth = stream.mapBoth;
+
+/**
+ * Transforms the chunks emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapChunks = stream.mapChunks;
+
+/**
+ * Effectfully transforms the chunks emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapChunksEffect = stream.mapChunksEffect;
+
+/**
+ * Maps each element to an iterable, and flattens the iterables into the
+ * output of this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcat = stream.mapConcat;
+
+/**
+ * Maps each element to a chunk, and flattens the chunks into the output of
+ * this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcatChunk = stream.mapConcatChunk;
+
+/**
+ * Effectfully maps each element to a chunk, and flattens the chunks into the
+ * output of this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcatChunkEffect = stream.mapConcatChunkEffect;
+
+/**
+ * Effectfully maps each element to an iterable, and flattens the iterables
+ * into the output of this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapConcatEffect = stream.mapConcatEffect;
+
+/**
+ * Maps over elements of the stream with the specified effectful function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapEffect = groupBy$1.mapEffectOptions;
+
+/**
+ * Transforms the errors emitted by this stream using `f`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = stream.mapError;
+
+/**
+ * Transforms the full causes of failures emitted by this stream.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapErrorCause = stream.mapErrorCause;
+
+/**
+ * Merges this stream and the specified stream together.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const merge = stream.merge;
+
+/**
+ * Merges a variable list of streams in a non-deterministic fashion. Up to `n`
+ * streams may be consumed in parallel and up to `outputBuffer` chunks may be
+ * buffered by this operator.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeAll = stream.mergeAll;
+
+/**
+ * Merges this stream and the specified stream together to a common element
+ * type with the specified mapping functions.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeWith = stream.mergeWith;
+
+/**
+ * Merges this stream and the specified stream together to produce a stream of
+ * eithers.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeEither = stream.mergeEither;
+
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the right stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeLeft = stream.mergeLeft;
+
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mergeRight = stream.mergeRight;
+
+/**
+ * Returns a combined string resulting from concatenating each of the values
+ * from the stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const mkString = stream.mkString;
+
+/**
+ * The stream that never produces any value or fails with any error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const never = stream.never;
+
+/**
+ * Runs the specified effect if this stream fails, providing the error to the
+ * effect if it exists.
+ *
+ * Note: Unlike `Effect.onError` there is no guarantee that the provided
+ * effect will not be interrupted.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const onError = stream.onError;
+
+/**
+ * Runs the specified effect if this stream ends.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const onDone = stream.onDone;
+
+/**
+ * Translates any failure into a stream termination, making the stream
+ * infallible and all failures unchecked.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDie = stream.orDie;
+
+/**
+ * Keeps none of the errors, and terminates the stream with them, using the
+ * specified function to convert the `E` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDieWith = stream.orDieWith;
+
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = stream.orElse;
+
+/**
+ * Switches to the provided stream in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseEither = stream.orElseEither;
+
+/**
+ * Fails with given error in case this one fails with a typed error.
+ *
+ * See also `Stream.catchAll`.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseFail = stream.orElseFail;
+
+/**
+ * Produces the specified element if this stream is empty.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseIfEmpty = stream.orElseIfEmpty;
+
+/**
+ * Produces the specified chunk if this stream is empty.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseIfEmptyChunk = stream.orElseIfEmptyChunk;
+
+/**
+ * Switches to the provided stream in case this one is empty.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseIfEmptyStream = stream.orElseIfEmptyStream;
+
+/**
+ * Succeeds with the specified value if this one fails with a typed error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseSucceed = stream.orElseSucceed;
+
+/**
+ * Like `Stream.unfold`, but allows the emission of values to end one step further
+ * than the unfolding of the state. This is useful for embedding paginated
+ * APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginate = stream.paginate;
+
+/**
+ * Like `Stream.unfoldChunk`, but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginateChunk = stream.paginateChunk;
+
+/**
+ * Like `Stream.unfoldChunkEffect`, but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginateChunkEffect = stream.paginateChunkEffect;
+
+/**
+ * Like `Stream.unfoldEffect` but allows the emission of values to end one step
+ * further than the unfolding of the state. This is useful for embedding
+ * paginated APIs, hence the name.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const paginateEffect = stream.paginateEffect;
+
+/**
+ * Partition a stream using a predicate. The first stream will contain all
+ * element evaluated to true and the second one will contain all element
+ * evaluated to false. The faster stream may advance by up to buffer elements
+ * further than the slower one.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const partition = stream.partition;
+
+/**
+ * Split a stream by an effectful predicate. The faster stream may advance by
+ * up to buffer elements further than the slower one.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const partitionEither = stream.partitionEither;
+
+/**
+ * Peels off enough material from the stream to construct a `Z` using the
+ * provided `Sink` and then returns both the `Z` and the rest of the
+ * `Stream` in a scope. Like all scoped values, the provided stream is
+ * valid only within the scope.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const peel = stream.peel;
+
+/**
+ * Pipes all of the values from this stream through the provided sink.
+ *
+ * See also `Stream.transduce`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeThrough = stream.pipeThrough;
+
+/**
+ * Pipes all the values from this stream through the provided channel.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeThroughChannel = stream.pipeThroughChannel;
+
+/**
+ * Pipes all values from this stream through the provided channel, passing
+ * through any error emitted by this stream unchanged.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const pipeThroughChannelOrFail = stream.pipeThroughChannelOrFail;
+
+/**
+ * Emits the provided chunk before emitting any other value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const prepend = stream.prepend;
+
+/**
+ * Provides the stream with its required context, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = stream.provideContext;
+
+/**
+ * Provides a `Layer` to the stream, which translates it to another level.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideLayer = stream.provideLayer;
+
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideService = stream.provideService;
+
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideServiceEffect = stream.provideServiceEffect;
+
+/**
+ * Provides the stream with the single service it requires. If the stream
+ * requires more than one service use `Stream.provideContext` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideServiceStream = stream.provideServiceStream;
+
+/**
+ * Transforms the context being provided to the stream with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = stream.mapInputContext;
+
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `R0`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideSomeLayer = stream.provideSomeLayer;
+
+/**
+ * Constructs a stream from a range of integers, including both endpoints.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const range = stream.range;
+
+/**
+ * Re-chunks the elements of the stream into chunks of `n` elements each. The
+ * last chunk might contain less than `n` elements.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const rechunk = stream.rechunk;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDie = stream.refineOrDie;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest, using the
+ * specified function to convert the `E` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const refineOrDieWith = stream.refineOrDieWith;
+
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeat = stream.repeat;
+
+/**
+ * Creates a stream from an effect producing a value of type `A` which repeats
+ * forever.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffect = stream.repeatEffect;
+
+/**
+ * Creates a stream from an effect producing chunks of `A` values which
+ * repeats forever.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectChunk = stream.repeatEffectChunk;
+
+/**
+ * Creates a stream from an effect producing chunks of `A` values until it
+ * fails with `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectChunkOption = stream.repeatEffectChunkOption;
+
+/**
+ * Creates a stream from an effect producing values of type `A` until it fails
+ * with `None`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectOption = stream.repeatEffectOption;
+
+/**
+ * Creates a stream from an effect producing a value of type `A`, which is
+ * repeated using the specified schedule.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatEffectWithSchedule = stream.repeatEffectWithSchedule;
+
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ * The schedule output will be emitted at the end of each repetition.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatEither = stream.repeatEither;
+
+/**
+ * Repeats each element of the stream using the provided schedule. Repetitions
+ * are done in addition to the first execution, which means using
+ * `Schedule.recurs(1)` actually results in the original effect, plus an
+ * additional recurrence, for a total of two repetitions of each value in the
+ * stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatElements = stream.repeatElements;
+
+/**
+ * Repeats each element of the stream using the provided schedule. When the
+ * schedule is finished, then the output of the schedule will be emitted into
+ * the stream. Repetitions are done in addition to the first execution, which
+ * means using `Schedule.recurs(1)` actually results in the original effect,
+ * plus an additional recurrence, for a total of two repetitions of each value
+ * in the stream.
+ *
+ * This function accepts two conversion functions, which allow the output of
+ * this stream and the output of the provided schedule to be unified into a
+ * single type. For example, `Either` or similar data type.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatElementsWith = stream.repeatElementsWith;
+
+/**
+ * Repeats the provided value infinitely.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const repeatValue = stream.repeatValue;
+
+/**
+ * Repeats the entire stream using the specified schedule. The stream will
+ * execute normally, and then repeat again according to the provided schedule.
+ * The schedule output will be emitted at the end of each repetition and can
+ * be unified with the stream elements using the provided functions.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const repeatWith = stream.repeatWith;
+
+/**
+ * When the stream fails, retry it according to the given schedule
+ *
+ * This retries the entire stream, so will re-execute all of the stream's
+ * acquire operations.
+ *
+ * The schedule is reset as soon as the first element passes through the
+ * stream again.
+ *
+ * @param schedule A `Schedule` receiving as input the errors of the stream.
+ * @since 2.0.0
+ * @category utils
+ */
+const retry = stream.retry;
+
+/**
+ * Runs the sink on the stream to produce either the sink's result or an error.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const run = stream.run;
+
+/**
+ * Runs the stream and collects all of its elements to a chunk.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runCollect = stream.runCollect;
+
+/**
+ * Runs the stream and emits the number of elements processed
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runCount = stream.runCount;
+
+/**
+ * Runs the stream only for its effects. The emitted elements are discarded.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runDrain = stream.runDrain;
+
+/**
+ * Executes a pure fold over the stream of values - reduces all elements in
+ * the stream to a value of type `S`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFold = stream.runFold;
+
+/**
+ * Executes an effectful fold over the stream of values.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldEffect = stream.runFoldEffect;
+
+/**
+ * Executes a pure fold over the stream of values. Returns a scoped value that
+ * represents the scope of the stream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldScoped = stream.runFoldScoped;
+
+/**
+ * Executes an effectful fold over the stream of values. Returns a scoped
+ * value that represents the scope of the stream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldScopedEffect = stream.runFoldScopedEffect;
+
+/**
+ * Reduces the elements in the stream to a value of type `S`. Stops the fold
+ * early when the condition is not fulfilled. Example:
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhile = stream.runFoldWhile;
+
+/**
+ * Executes an effectful fold over the stream of values. Stops the fold early
+ * when the condition is not fulfilled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhileEffect = stream.runFoldWhileEffect;
+
+/**
+ * Executes a pure fold over the stream of values. Returns a scoped value that
+ * represents the scope of the stream. Stops the fold early when the condition
+ * is not fulfilled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhileScoped = stream.runFoldWhileScoped;
+
+/**
+ * Executes an effectful fold over the stream of values. Returns a scoped
+ * value that represents the scope of the stream. Stops the fold early when
+ * the condition is not fulfilled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runFoldWhileScopedEffect = stream.runFoldWhileScopedEffect;
+
+/**
+ * Consumes all elements of the stream, passing them to the specified
+ * callback.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEach = stream.runForEach;
+
+/**
+ * Consumes all elements of the stream, passing them to the specified
+ * callback.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachChunk = stream.runForEachChunk;
+
+/**
+ * Like `Stream.runForEachChunk`, but returns a scoped effect so the
+ * finalization order can be controlled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachChunkScoped = stream.runForEachChunkScoped;
+
+/**
+ * Like `Stream.forEach`, but returns a scoped effect so the finalization
+ * order can be controlled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachScoped = stream.runForEachScoped;
+
+/**
+ * Consumes elements of the stream, passing them to the specified callback,
+ * and terminating consumption when the callback returns `false`.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachWhile = stream.runForEachWhile;
+
+/**
+ * Like `Stream.runForEachWhile`, but returns a scoped effect so the
+ * finalization order can be controlled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runForEachWhileScoped = stream.runForEachWhileScoped;
+
+/**
+ * Runs the stream to completion and yields the first value emitted by it,
+ * discarding the rest of the elements.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runHead = stream.runHead;
+
+/**
+ * Publishes elements of this stream to a hub. Stream failure and ending will
+ * also be signalled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoHub = stream.runIntoHub;
+
+/**
+ * Like `Stream.runIntoHub`, but provides the result as a scoped effect to
+ * allow for scope composition.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoHubScoped = stream.runIntoHubScoped;
+
+/**
+ * Enqueues elements of this stream into a queue. Stream failure and ending
+ * will also be signalled.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoQueue = stream.runIntoQueue;
+
+/**
+ * Like `Stream.runIntoQueue`, but provides the result as a scoped [[ZIO]]
+ * to allow for scope composition.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoQueueElementsScoped = stream.runIntoQueueElementsScoped;
+
+/**
+ * Like `Stream.runIntoQueue`, but provides the result as a scoped effect
+ * to allow for scope composition.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runIntoQueueScoped = stream.runIntoQueueScoped;
+
+/**
+ * Runs the stream to completion and yields the last value emitted by it,
+ * discarding the rest of the elements.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runLast = stream.runLast;
+
+/**
+ * @since 2.0.0
+ * @category destructors
+ */
+const runScoped = stream.runScoped;
+
+/**
+ * Runs the stream to a sink which sums elements, provided they are Numeric.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const runSum = stream.runSum;
+
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results of type `S` given an initial S.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scan = stream.scan;
+
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results of type `S` given an initial S.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scanEffect = stream.scanEffect;
+
+/**
+ * Statefully maps over the elements of this stream to produce all
+ * intermediate results.
+ *
+ * See also `Stream.scan`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scanReduce = stream.scanReduce;
+
+/**
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * all intermediate results.
+ *
+ * See also `Stream.scanEffect`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scanReduceEffect = stream.scanReduceEffect;
+
+/**
+ * Schedules the output of the stream using the provided `schedule`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const schedule = stream.schedule;
+
+/**
+ * Schedules the output of the stream using the provided `schedule` and emits
+ * its output at the end (if `schedule` is finite). Uses the provided function
+ * to align the stream and schedule outputs on the same type.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const scheduleWith = stream.scheduleWith;
+
+/**
+ * Creates a single-valued stream from a scoped resource.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const scoped = stream.scoped;
+
+/**
+ * Emits a sliding window of `n` elements.
+ *
+ * ```ts
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.make(1, 2, 3, 4),
+ *   Stream.sliding(2),
+ *   Stream.runCollect
+ * )
+ * // => Chunk(Chunk(1, 2), Chunk(2, 3), Chunk(3, 4))
+ * ```
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const sliding = stream.sliding;
+
+/**
+ * Like `sliding`, but with a configurable `stepSize` parameter.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const slidingSize = stream.slidingSize;
+
+/**
+ * Converts an option on values into an option on errors.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const some = stream.some;
+
+/**
+ * Extracts the optional value, or returns the given 'default'.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const someOrElse = stream.someOrElse;
+
+/**
+ * Extracts the optional value, or fails with the given error 'e'.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const someOrFail = stream.someOrFail;
+
+/**
+ * Splits elements based on a predicate.
+ *
+ * ```ts
+ * import * as Stream from "./Stream"
+ * import { pipe } from "./Function"
+ *
+ * pipe(
+ *   Stream.range(1, 10),
+ *   Stream.split((n) => n % 4 === 0),
+ *   Stream.runCollect
+ * )
+ * // => Chunk(Chunk(1, 2, 3), Chunk(5, 6, 7), Chunk(9))
+ * ```
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const split = stream.split;
+
+/**
+ * Splits elements on a delimiter and transforms the splits into desired output.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const splitOnChunk = stream.splitOnChunk;
+
+/**
+ * Splits strings on newlines. Handles both Windows newlines (`\r\n`) and UNIX
+ * newlines (`\n`).
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+const splitLines = stream.splitLines;
+
+/**
+ * Creates a single-valued pure stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = stream.succeed;
+
+/**
+ * Creates a single-valued pure stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = stream.sync;
+
+/**
+ * Returns a lazily constructed stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = stream.suspend;
+
+/**
+ * Takes the specified number of elements from this stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const take = stream.take;
+
+/**
+ * Takes the last specified number of elements from this stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeRight = stream.takeRight;
+
+/**
+ * Takes all elements of the stream until the specified predicate evaluates to
+ * `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeUntil = stream.takeUntil;
+
+/**
+ * Takes all elements of the stream until the specified effectual predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeUntilEffect = stream.takeUntilEffect;
+
+/**
+ * Takes all elements of the stream for as long as the specified predicate
+ * evaluates to `true`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const takeWhile = stream.takeWhile;
+
+/**
+ * Adds an effect to consumption of every element of the stream.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = stream.tap;
+
+/**
+ * Returns a stream that effectfully "peeks" at the failure or success of
+ * the stream.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapBoth = stream.tapBoth;
+
+/**
+ * Returns a stream that effectfully "peeks" at the failure of the stream.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = stream.tapError;
+
+/**
+ * Returns a stream that effectfully "peeks" at the cause of failure of the
+ * stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const tapErrorCause = stream.tapErrorCause;
+
+/**
+ * Sends all elements emitted by this stream to the specified sink in addition
+ * to emitting them.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapSink = stream.tapSink;
+
+/**
+ * Delays the chunks of this stream according to the given bandwidth
+ * parameters using the token bucket algorithm. Allows for burst in the
+ * processing of elements by allowing the token bucket to accumulate tokens up
+ * to a `units + burst` threshold. The weight of each chunk is determined by
+ * the `costFn` function.
+ *
+ * If using the "enforce" strategy, chunks that do not meet the bandwidth
+ * constraints are dropped. If using the "shape" strategy, chunks are delayed
+ * until they can be emitted without exceeding the bandwidth constraints.
+ *
+ * Defaults to the "shape" strategy.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const throttle = stream.throttle;
+
+/**
+ * Delays the chunks of this stream according to the given bandwidth
+ * parameters using the token bucket algorithm. Allows for burst in the
+ * processing of elements by allowing the token bucket to accumulate tokens up
+ * to a `units + burst` threshold. The weight of each chunk is determined by
+ * the effectful `costFn` function.
+ *
+ * If using the "enforce" strategy, chunks that do not meet the bandwidth
+ * constraints are dropped. If using the "shape" strategy, chunks are delayed
+ * until they can be emitted without exceeding the bandwidth constraints.
+ *
+ * Defaults to the "shape" strategy.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const throttleEffect = stream.throttleEffect;
+
+/**
+ * A stream that emits Unit values spaced by the specified duration.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const tick = stream.tick;
+
+/**
+ * Ends the stream if it does not produce a value after the specified duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeout = stream.timeout;
+
+/**
+ * Fails the stream with given error if it does not produce a value after d
+ * duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeoutFail = stream.timeoutFail;
+
+/**
+ * Fails the stream with given cause if it does not produce a value after d
+ * duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeoutFailCause = stream.timeoutFailCause;
+
+/**
+ * Switches the stream if it does not produce a value after the specified
+ * duration.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const timeoutTo = stream.timeoutTo;
+
+/**
+ * Converts the stream to a scoped hub of chunks. After the scope is closed,
+ * the hub will never again produce values and should be discarded.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toHub = stream.toHub;
+
+/**
+ * Returns in a scope a ZIO effect that can be used to repeatedly pull chunks
+ * from the stream. The pull effect fails with None when the stream is
+ * finished, or with Some error if it fails, otherwise it returns a chunk of
+ * the stream's output.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toPull = stream.toPull;
+
+/**
+ * Converts the stream to a scoped queue of chunks. After the scope is closed,
+ * the queue will never again produce values and should be discarded.
+ *
+ * Defaults to the "suspend" back pressure strategy with a capacity of 2.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toQueue = stream.toQueue;
+
+/**
+ * Converts the stream to a scoped queue of elements. After the scope is
+ * closed, the queue will never again produce values and should be discarded.
+ *
+ * Defaults to a capacity of 2.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toQueueOfElements = stream.toQueueOfElements;
+
+/**
+ * Converts the stream to a `ReadableStream`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const toReadableStream = stream.toReadableStream;
+
+/**
+ * Applies the transducer to the stream and emits its outputs.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const transduce = stream.transduce;
+
+/**
+ * Creates a stream by peeling off the "layers" of a value of type `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfold = stream.unfold;
+
+/**
+ * Creates a stream by peeling off the "layers" of a value of type `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfoldChunk = stream.unfoldChunk;
+
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type
+ * `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfoldChunkEffect = stream.unfoldChunkEffect;
+
+/**
+ * Creates a stream by effectfully peeling off the "layers" of a value of type
+ * `S`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unfoldEffect = stream.unfoldEffect;
+
+/**
+ * A stream that contains a single `Unit` value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unit = stream.unit;
+
+/**
+ * Creates a stream produced from an `Effect`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrap = stream.unwrap;
+
+/**
+ * Creates a stream produced from a scoped `Effect`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unwrapScoped = stream.unwrapScoped;
+
+/**
+ * Updates the specified service within the context of the `Stream`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const updateService = stream.updateService;
+
+/**
+ * Returns the specified stream if the given condition is satisfied, otherwise
+ * returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const when = stream.when;
+
+/**
+ * Returns the resulting stream when the given `PartialFunction` is defined
+ * for the given value, otherwise returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const whenCase = stream.whenCase;
+
+/**
+ * Returns the stream when the given partial function is defined for the given
+ * effectful value, otherwise returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whenCaseEffect = stream.whenCaseEffect;
+
+/**
+ * Returns the stream if the given effectful condition is satisfied, otherwise
+ * returns an empty stream.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const whenEffect = stream.whenEffect;
+
+/**
+ * Wraps the stream with a new span for tracing.
+ *
+ * @since 2.0.0
+ * @category tracing
+ */
+const withSpan = stream.withSpan;
+
+/**
+ * Zips this stream with another point-wise and emits tuples of elements from
+ * both streams.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = stream.zip;
+
+/**
+ * Zips this stream with another point-wise and emits tuples of elements from
+ * both streams.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipFlatten = stream.zipFlatten;
+
+/**
+ * Zips this stream with another point-wise, creating a new stream of pairs of
+ * elements from both sides.
+ *
+ * The defaults `defaultLeft` and `defaultRight` will be used if the streams
+ * have different lengths and one of the streams has ended before the other.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAll = stream.zipAll;
+
+/**
+ * Zips this stream with another point-wise, and keeps only elements from this
+ * stream.
+ *
+ * The provided default value will be used if the other stream ends before
+ * this one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllLeft = stream.zipAllLeft;
+
+/**
+ * Zips this stream with another point-wise, and keeps only elements from the
+ * other stream.
+ *
+ * The provided default value will be used if this stream ends before the
+ * other one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllRight = stream.zipAllRight;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Combines values associated with each key into a tuple,
+ * using the specified values `defaultLeft` and `defaultRight` to fill in
+ * missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKey = stream.zipAllSortedByKey;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Keeps only values from this stream, using the specified
+ * value `default` to fill in missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKeyLeft = stream.zipAllSortedByKeyLeft;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Keeps only values from that stream, using the specified
+ * value `default` to fill in missing values.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKeyRight = stream.zipAllSortedByKeyRight;
+
+/**
+ * Zips this stream that is sorted by distinct keys and the specified stream
+ * that is sorted by distinct keys to produce a new stream that is sorted by
+ * distinct keys. Uses the functions `left`, `right`, and `both` to handle
+ * the cases where a key and value exist in this stream, that stream, or
+ * both streams.
+ *
+ * This allows zipping potentially unbounded streams of data by key in
+ * constant space but the caller is responsible for ensuring that the
+ * streams are sorted by distinct keys.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllSortedByKeyWith = stream.zipAllSortedByKeyWith;
+
+/**
+ * Zips this stream with another point-wise. The provided functions will be
+ * used to create elements for the composed stream.
+ *
+ * The functions `left` and `right` will be used if the streams have different
+ * lengths and one of the streams has ended before the other.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipAllWith = stream.zipAllWith;
+
+/**
+ * Zips the two streams so that when a value is emitted by either of the two
+ * streams, it is combined with the latest value from the other stream to
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLatest = stream.zipLatest;
+
+/**
+ * Zips the two streams so that when a value is emitted by either of the two
+ * streams, it is combined with the latest value from the other stream to
+ * produce a result.
+ *
+ * Note: tracking the latest value is done on a per-chunk basis. That means
+ * that emitted elements that are not the last value in chunks will never be
+ * used for zipping.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLatestWith = stream.zipLatestWith;
+
+/**
+ * Zips this stream with another point-wise, but keeps only the outputs of
+ * this stream.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = stream.zipLeft;
+
+/**
+ * Zips this stream with another point-wise, but keeps only the outputs of the
+ * other stream.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = stream.zipRight;
+
+/**
+ * Zips this stream with another point-wise and applies the function to the
+ * paired elements.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = stream.zipWith;
+
+/**
+ * Zips this stream with another point-wise and applies the function to the
+ * paired elements.
+ *
+ * The new stream will end when one of the sides ends.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithChunks = stream.zipWithChunks;
+
+/**
+ * Zips each element with the next element if present.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithNext = stream.zipWithNext;
+
+/**
+ * Zips each element with the previous element. Initially accompanied by
+ * `None`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithPrevious = stream.zipWithPrevious;
+
+/**
+ * Zips each element with both the previous and next element.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithPreviousAndNext = stream.zipWithPreviousAndNext;
+
+/**
+ * Zips this stream together with the index of elements.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWithIndex = stream.zipWithIndex;
+
+// -------------------------------------------------------------------------------------
+// Do notation
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 2.0.0
+ * @category do notation
+ */
+const Do = stream.Do;
+
+/**
+ * Binds a value from a stream in a `do` scope
+ *
+ * @since 2.0.0
+ * @category do notation
+ */
+const bind = stream.bind;
+
+/**
+ * Binds an effectful value in a `do` scope
+ *
+ * @since 2.0.0
+ * @category do notation
+ */
+const bindEffect = groupBy$1.bindEffect;
+
+/**
+ * @since 2.0.0
+ * @category do notation
+ */
+const bindTo = stream.bindTo;
+const let_ = stream.let_;
+
+// -------------------------------------------------------------------------------------
+// encoding
+// -------------------------------------------------------------------------------------
+
+/**
+ * Decode Uint8Array chunks into a stream of strings using the specified encoding.
+ *
+ * @since 2.0.0
+ * @category encoding
+ */
+const decodeText = stream.decodeText;
+
+/**
+ * Encode a stream of strings into a stream of Uint8Array chunks using the specified encoding.
+ *
+ * @since 2.0.0
+ * @category encoding
+ */
+const encodeText = stream.encodeText;
+
+exports.DefaultChunkSize = DefaultChunkSize;
+exports.Do = Do;
+exports.StreamTypeId = StreamTypeId;
+exports.acquireRelease = acquireRelease;
+exports.aggregate = aggregate;
+exports.aggregateWithin = aggregateWithin;
+exports.aggregateWithinEither = aggregateWithinEither;
+exports.as = as;
+exports.async = _async;
+exports.asyncEffect = asyncEffect;
+exports.asyncInterrupt = asyncInterrupt;
+exports.asyncOption = asyncOption;
+exports.asyncScoped = asyncScoped;
+exports.bind = bind;
+exports.bindEffect = bindEffect;
+exports.bindTo = bindTo;
+exports.branchAfter = branchAfter;
+exports.broadcast = broadcast;
+exports.broadcastDynamic = broadcastDynamic;
+exports.broadcastedQueues = broadcastedQueues;
+exports.broadcastedQueuesDynamic = broadcastedQueuesDynamic;
+exports.buffer = buffer;
+exports.bufferChunks = bufferChunks;
+exports.catchAll = catchAll;
+exports.catchAllCause = catchAllCause;
+exports.catchSome = catchSome;
+exports.catchSomeCause = catchSomeCause;
+exports.catchTag = catchTag;
+exports.catchTags = catchTags;
+exports.changes = changes;
+exports.changesWith = changesWith;
+exports.changesWithEffect = changesWithEffect;
+exports.chunks = chunks;
+exports.chunksWith = chunksWith;
+exports.combine = combine;
+exports.combineChunks = combineChunks;
+exports.concat = concat;
+exports.concatAll = concatAll;
+exports.context = context;
+exports.contextWith = contextWith;
+exports.contextWithEffect = contextWithEffect;
+exports.contextWithStream = contextWithStream;
+exports.cross = cross;
+exports.crossLeft = crossLeft;
+exports.crossRight = crossRight;
+exports.crossWith = crossWith;
+exports.debounce = debounce;
+exports.decodeText = decodeText;
+exports.die = die;
+exports.dieMessage = dieMessage;
+exports.dieSync = dieSync;
+exports.distributedWith = distributedWith;
+exports.distributedWithDynamic = distributedWithDynamic;
+exports.drain = drain;
+exports.drainFork = drainFork;
+exports.drop = drop;
+exports.dropRight = dropRight;
+exports.dropUntil = dropUntil;
+exports.dropUntilEffect = dropUntilEffect;
+exports.dropWhile = dropWhile;
+exports.dropWhileEffect = dropWhileEffect;
+exports.either = either;
+exports.empty = empty;
+exports.encodeText = encodeText;
+exports.ensuring = ensuring;
+exports.ensuringWith = ensuringWith;
+exports.execute = execute;
+exports.fail = fail;
+exports.failCause = failCause;
+exports.failCauseSync = failCauseSync;
+exports.failSync = failSync;
+exports.filter = filter;
+exports.filterEffect = filterEffect;
+exports.filterMap = filterMap;
+exports.filterMapEffect = filterMapEffect;
+exports.filterMapWhile = filterMapWhile;
+exports.filterMapWhileEffect = filterMapWhileEffect;
+exports.finalizer = finalizer;
+exports.find = find;
+exports.findEffect = findEffect;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flattenChunks = flattenChunks;
+exports.flattenEffect = flattenEffect;
+exports.flattenExitOption = flattenExitOption;
+exports.flattenIterables = flattenIterables;
+exports.flattenTake = flattenTake;
+exports.forever = forever;
+exports.fromAsyncIterable = fromAsyncIterable;
+exports.fromChannel = fromChannel;
+exports.fromChunk = fromChunk;
+exports.fromChunkHub = fromChunkHub;
+exports.fromChunkQueue = fromChunkQueue;
+exports.fromChunks = fromChunks;
+exports.fromEffect = fromEffect;
+exports.fromEffectOption = fromEffectOption;
+exports.fromHub = fromHub;
+exports.fromIterable = fromIterable;
+exports.fromIterableEffect = fromIterableEffect;
+exports.fromIteratorSucceed = fromIteratorSucceed;
+exports.fromPull = fromPull;
+exports.fromQueue = fromQueue;
+exports.fromReadableStream = fromReadableStream;
+exports.fromReadableStreamByob = fromReadableStreamByob;
+exports.fromSchedule = fromSchedule;
+exports.groupAdjacentBy = groupAdjacentBy;
+exports.groupBy = groupBy;
+exports.groupByKey = groupByKey;
+exports.grouped = grouped;
+exports.groupedWithin = groupedWithin;
+exports.haltAfter = haltAfter;
+exports.haltWhen = haltWhen;
+exports.haltWhenDeferred = haltWhenDeferred;
+exports.identity = identity;
+exports.interleave = interleave;
+exports.interleaveWith = interleaveWith;
+exports.interruptAfter = interruptAfter;
+exports.interruptWhen = interruptWhen;
+exports.interruptWhenDeferred = interruptWhenDeferred;
+exports.intersperse = intersperse;
+exports.intersperseAffixes = intersperseAffixes;
+exports.iterate = iterate;
+exports["let"] = let_;
+exports.make = make;
+exports.map = map;
+exports.mapAccum = mapAccum;
+exports.mapAccumEffect = mapAccumEffect;
+exports.mapBoth = mapBoth;
+exports.mapChunks = mapChunks;
+exports.mapChunksEffect = mapChunksEffect;
+exports.mapConcat = mapConcat;
+exports.mapConcatChunk = mapConcatChunk;
+exports.mapConcatChunkEffect = mapConcatChunkEffect;
+exports.mapConcatEffect = mapConcatEffect;
+exports.mapEffect = mapEffect;
+exports.mapError = mapError;
+exports.mapErrorCause = mapErrorCause;
+exports.mapInputContext = mapInputContext;
+exports.merge = merge;
+exports.mergeAll = mergeAll;
+exports.mergeEither = mergeEither;
+exports.mergeLeft = mergeLeft;
+exports.mergeRight = mergeRight;
+exports.mergeWith = mergeWith;
+exports.mkString = mkString;
+exports.never = never;
+exports.onDone = onDone;
+exports.onError = onError;
+exports.orDie = orDie;
+exports.orDieWith = orDieWith;
+exports.orElse = orElse;
+exports.orElseEither = orElseEither;
+exports.orElseFail = orElseFail;
+exports.orElseIfEmpty = orElseIfEmpty;
+exports.orElseIfEmptyChunk = orElseIfEmptyChunk;
+exports.orElseIfEmptyStream = orElseIfEmptyStream;
+exports.orElseSucceed = orElseSucceed;
+exports.paginate = paginate;
+exports.paginateChunk = paginateChunk;
+exports.paginateChunkEffect = paginateChunkEffect;
+exports.paginateEffect = paginateEffect;
+exports.partition = partition;
+exports.partitionEither = partitionEither;
+exports.peel = peel;
+exports.pipeThrough = pipeThrough;
+exports.pipeThroughChannel = pipeThroughChannel;
+exports.pipeThroughChannelOrFail = pipeThroughChannelOrFail;
+exports.prepend = prepend;
+exports.provideContext = provideContext;
+exports.provideLayer = provideLayer;
+exports.provideService = provideService;
+exports.provideServiceEffect = provideServiceEffect;
+exports.provideServiceStream = provideServiceStream;
+exports.provideSomeLayer = provideSomeLayer;
+exports.range = range;
+exports.rechunk = rechunk;
+exports.refineOrDie = refineOrDie;
+exports.refineOrDieWith = refineOrDieWith;
+exports.repeat = repeat;
+exports.repeatEffect = repeatEffect;
+exports.repeatEffectChunk = repeatEffectChunk;
+exports.repeatEffectChunkOption = repeatEffectChunkOption;
+exports.repeatEffectOption = repeatEffectOption;
+exports.repeatEffectWithSchedule = repeatEffectWithSchedule;
+exports.repeatEither = repeatEither;
+exports.repeatElements = repeatElements;
+exports.repeatElementsWith = repeatElementsWith;
+exports.repeatValue = repeatValue;
+exports.repeatWith = repeatWith;
+exports.retry = retry;
+exports.run = run;
+exports.runCollect = runCollect;
+exports.runCount = runCount;
+exports.runDrain = runDrain;
+exports.runFold = runFold;
+exports.runFoldEffect = runFoldEffect;
+exports.runFoldScoped = runFoldScoped;
+exports.runFoldScopedEffect = runFoldScopedEffect;
+exports.runFoldWhile = runFoldWhile;
+exports.runFoldWhileEffect = runFoldWhileEffect;
+exports.runFoldWhileScoped = runFoldWhileScoped;
+exports.runFoldWhileScopedEffect = runFoldWhileScopedEffect;
+exports.runForEach = runForEach;
+exports.runForEachChunk = runForEachChunk;
+exports.runForEachChunkScoped = runForEachChunkScoped;
+exports.runForEachScoped = runForEachScoped;
+exports.runForEachWhile = runForEachWhile;
+exports.runForEachWhileScoped = runForEachWhileScoped;
+exports.runHead = runHead;
+exports.runIntoHub = runIntoHub;
+exports.runIntoHubScoped = runIntoHubScoped;
+exports.runIntoQueue = runIntoQueue;
+exports.runIntoQueueElementsScoped = runIntoQueueElementsScoped;
+exports.runIntoQueueScoped = runIntoQueueScoped;
+exports.runLast = runLast;
+exports.runScoped = runScoped;
+exports.runSum = runSum;
+exports.scan = scan;
+exports.scanEffect = scanEffect;
+exports.scanReduce = scanReduce;
+exports.scanReduceEffect = scanReduceEffect;
+exports.schedule = schedule;
+exports.scheduleWith = scheduleWith;
+exports.scoped = scoped;
+exports.sliding = sliding;
+exports.slidingSize = slidingSize;
+exports.some = some;
+exports.someOrElse = someOrElse;
+exports.someOrFail = someOrFail;
+exports.split = split;
+exports.splitLines = splitLines;
+exports.splitOnChunk = splitOnChunk;
+exports.succeed = succeed;
+exports.suspend = suspend;
+exports.sync = sync;
+exports.take = take;
+exports.takeRight = takeRight;
+exports.takeUntil = takeUntil;
+exports.takeUntilEffect = takeUntilEffect;
+exports.takeWhile = takeWhile;
+exports.tap = tap;
+exports.tapBoth = tapBoth;
+exports.tapError = tapError;
+exports.tapErrorCause = tapErrorCause;
+exports.tapSink = tapSink;
+exports.throttle = throttle;
+exports.throttleEffect = throttleEffect;
+exports.tick = tick;
+exports.timeout = timeout;
+exports.timeoutFail = timeoutFail;
+exports.timeoutFailCause = timeoutFailCause;
+exports.timeoutTo = timeoutTo;
+exports.toChannel = toChannel;
+exports.toHub = toHub;
+exports.toPull = toPull;
+exports.toQueue = toQueue;
+exports.toQueueOfElements = toQueueOfElements;
+exports.toReadableStream = toReadableStream;
+exports.transduce = transduce;
+exports.unfold = unfold;
+exports.unfoldChunk = unfoldChunk;
+exports.unfoldChunkEffect = unfoldChunkEffect;
+exports.unfoldEffect = unfoldEffect;
+exports.unit = unit;
+exports.unwrap = unwrap;
+exports.unwrapScoped = unwrapScoped;
+exports.updateService = updateService;
+exports.when = when;
+exports.whenCase = whenCase;
+exports.whenCaseEffect = whenCaseEffect;
+exports.whenEffect = whenEffect;
+exports.withSpan = withSpan;
+exports.zip = zip;
+exports.zipAll = zipAll;
+exports.zipAllLeft = zipAllLeft;
+exports.zipAllRight = zipAllRight;
+exports.zipAllSortedByKey = zipAllSortedByKey;
+exports.zipAllSortedByKeyLeft = zipAllSortedByKeyLeft;
+exports.zipAllSortedByKeyRight = zipAllSortedByKeyRight;
+exports.zipAllSortedByKeyWith = zipAllSortedByKeyWith;
+exports.zipAllWith = zipAllWith;
+exports.zipFlatten = zipFlatten;
+exports.zipLatest = zipLatest;
+exports.zipLatestWith = zipLatestWith;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;
+exports.zipWithChunks = zipWithChunks;
+exports.zipWithIndex = zipWithIndex;
+exports.zipWithNext = zipWithNext;
+exports.zipWithPrevious = zipWithPrevious;
+exports.zipWithPreviousAndNext = zipWithPreviousAndNext;