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

package/internal/sink.esm.js

@@ -0,0 +1,918 @@
+import { die as die$1, RuntimeException } from '../Cause/dist/effect-Cause.esm.js';
+import { appendAll, empty, append, toReadonlyArray, unsafeFromArray, drop as drop$1, isEmpty, flatten, map as map$3, dropWhile as dropWhile$1, filter, of, unsafeGet as unsafeGet$1, splitAt, isNonEmpty, last as last$1, reduce } from '../Chunk/dist/effect-Chunk.esm.js';
+import { currentTimeMillis } from '../Clock/dist/effect-Clock.esm.js';
+import { millis } from '../Duration/dist/effect-Duration.esm.js';
+import { takeWhile, map as map$1, zip as zip$1, forEach as forEach$1, context as context$1, contextWith as contextWith$1, filter as filter$1, succeed as succeed$2, dieMessage as dieMessage$1, acquireRelease, never as never$1, gen, suspend as suspend$2, isEffect, failCause as failCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, flatMap as flatMap$2 } from '../Effect/dist/effect-Effect.esm.js';
+import { match, merge, left, right } from '../Either/dist/effect-Either.esm.js';
+import { match as match$2 } from '../Exit/dist/effect-Exit.esm.js';
+import { dual, pipe, constTrue, identity } from '../Function/dist/effect-Function.esm.js';
+import { empty as empty$1, has, unsafeGet, set } from '../HashMap/dist/effect-HashMap.esm.js';
+import { empty as empty$2, has as has$1, add } from '../HashSet/dist/effect-HashSet.esm.js';
+import { bounded } from '../Hub/dist/effect-Hub.esm.js';
+import { some as some$1, none, match as match$1, isNone, orElse as orElse$2 } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { shutdown, offerAll } from '../Queue/dist/effect-Queue.esm.js';
+import { span } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { make, set as set$1, get } from '../Ref/dist/effect-Ref.esm.js';
+import { zipRight as zipRight$1, as as as$1, bufferChunk, foldChannel, doneCollect, map as map$2, pipeToOrFail, drain as drain$1, identityChannel, ensuring as ensuring$1, unwrap as unwrap$1, catchAll, unwrapScoped as unwrapScoped$1, mapEffect as mapEffect$1, mapError as mapError$1, mapOut, orElse as orElse$1, fromHubScoped, toHub, mergeWith, writeChunk } from './channel.esm.js';
+import { Done, Await } from './channel/mergeDecision.esm.js';
+import { suspend as suspend$1, readWithCause, failCause as failCause$1, succeed as succeed$1, readWith, write, fail as fail$1, flatMap as flatMap$1, fromEffect as fromEffect$1, pipeTo, collectElements, succeedNow, ensuringWith as ensuringWith$1, failSync as failSync$1, failCauseSync as failCauseSync$1, unit, provideContext as provideContext$1, sync as sync$1 } from './core-stream.esm.js';
+
+/** @internal */
+const SinkTypeId = /*#__PURE__*/Symbol.for("effect/Sink");
+
+/** @internal */
+const sinkVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _In: _ => _,
+  _L: _ => _,
+  _Z: _ => _
+};
+
+/** @internal */
+class SinkImpl {
+  [SinkTypeId] = sinkVariance;
+  constructor(channel) {
+    this.channel = channel;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isSink = u => typeof u === "object" && u != null && SinkTypeId in u;
+
+/** @internal */
+const suspend = evaluate => new SinkImpl(suspend$1(() => toChannel(evaluate())));
+
+/** @internal */
+const as = /*#__PURE__*/dual(2, (self, z) => pipe(self, map(() => z)));
+
+/** @internal */
+const collectAll = () => new SinkImpl(collectAllLoop(empty()));
+
+/** @internal */
+const collectAllLoop = acc => readWithCause({
+  onInput: chunk => collectAllLoop(pipe(acc, appendAll(chunk))),
+  onFailure: failCause$1,
+  onDone: () => succeed$1(acc)
+});
+
+/** @internal */
+const collectAllN = n => suspend(() => fromChannel(collectAllNLoop(n, empty())));
+
+/** @internal */
+const collectAllNLoop = (n, acc) => readWithCause({
+  onInput: chunk => {
+    const [collected, leftovers] = splitAt(chunk, n);
+    if (collected.length < n) {
+      return collectAllNLoop(n - collected.length, appendAll(acc, collected));
+    }
+    if (isEmpty(leftovers)) {
+      return succeed$1(appendAll(acc, collected));
+    }
+    return flatMap$1(write(leftovers), () => succeed$1(appendAll(acc, collected)));
+  },
+  onFailure: failCause$1,
+  onDone: () => succeed$1(acc)
+});
+
+/** @internal */
+const collectAllFrom = self => collectAllWhileWith(self, {
+  initial: empty(),
+  while: constTrue,
+  body: (chunk, z) => pipe(chunk, append(z))
+});
+
+/** @internal */
+const collectAllToMap = (key, merge) => {
+  return pipe(foldLeftChunks(empty$1(), (map, chunk) => pipe(chunk, reduce(map, (map, input) => {
+    const k = key(input);
+    const v = pipe(map, has(k)) ? merge(pipe(map, unsafeGet(k)), input) : input;
+    return pipe(map, set(k, v));
+  }))));
+};
+
+/** @internal */
+const collectAllToMapN = (n, key, merge) => {
+  return foldWeighted({
+    initial: empty$1(),
+    maxCost: n,
+    cost: (acc, input) => pipe(acc, has(key(input))) ? 0 : 1,
+    body: (acc, input) => {
+      const k = key(input);
+      const v = pipe(acc, has(k)) ? merge(pipe(acc, unsafeGet(k)), input) : input;
+      return pipe(acc, set(k, v));
+    }
+  });
+};
+
+/** @internal */
+const collectAllToSet = () => foldLeftChunks(empty$2(), (acc, chunk) => pipe(chunk, reduce(acc, (acc, input) => pipe(acc, add(input)))));
+
+/** @internal */
+const collectAllToSetN = n => foldWeighted({
+  initial: empty$2(),
+  maxCost: n,
+  cost: (acc, input) => has$1(acc, input) ? 0 : 1,
+  body: (acc, input) => add(acc, input)
+});
+
+/** @internal */
+const collectAllUntil = p => {
+  return pipe(fold([empty(), true], tuple => tuple[1], ([chunk, _], input) => [pipe(chunk, append(input)), !p(input)]), map(tuple => tuple[0]));
+};
+
+/** @internal */
+const collectAllUntilEffect = p => {
+  return pipe(foldEffect([empty(), true], tuple => tuple[1], ([chunk, _], input) => pipe(p(input), map$1(bool => [pipe(chunk, append(input)), !bool]))), map(tuple => tuple[0]));
+};
+
+/** @internal */
+const collectAllWhile = predicate => fromChannel(collectAllWhileReader(predicate, empty()));
+
+/** @internal */
+const collectAllWhileReader = (predicate, done) => readWith({
+  onInput: input => {
+    const [collected, leftovers] = pipe(toReadonlyArray(input), span(predicate));
+    if (leftovers.length === 0) {
+      return collectAllWhileReader(predicate, pipe(done, appendAll(unsafeFromArray(collected))));
+    }
+    return pipe(write(unsafeFromArray(leftovers)), zipRight$1(succeed$1(pipe(done, appendAll(unsafeFromArray(collected))))));
+  },
+  onFailure: fail$1,
+  onDone: () => succeed$1(done)
+});
+
+/** @internal */
+const collectAllWhileEffect = predicate => fromChannel(collectAllWhileEffectReader(predicate, empty()));
+
+/** @internal */
+const collectAllWhileEffectReader = (predicate, done) => readWith({
+  onInput: input => pipe(fromEffect$1(pipe(input, takeWhile(predicate), map$1(unsafeFromArray))), flatMap$1(collected => {
+    const leftovers = pipe(input, drop$1(collected.length));
+    if (isEmpty(leftovers)) {
+      return collectAllWhileEffectReader(predicate, pipe(done, appendAll(collected)));
+    }
+    return pipe(write(leftovers), zipRight$1(succeed$1(pipe(done, appendAll(collected)))));
+  })),
+  onFailure: fail$1,
+  onDone: () => succeed$1(done)
+});
+
+/** @internal */
+const collectAllWhileWith = /*#__PURE__*/dual(2, (self, options) => {
+  const refs = pipe(make(empty()), zip$1(make(false)));
+  const newChannel = pipe(fromEffect$1(refs), flatMap$1(([leftoversRef, upstreamDoneRef]) => {
+    const upstreamMarker = readWith({
+      onInput: input => pipe(write(input), flatMap$1(() => upstreamMarker)),
+      onFailure: fail$1,
+      onDone: done => pipe(fromEffect$1(set$1(upstreamDoneRef, true)), as$1(done))
+    });
+    return pipe(upstreamMarker, pipeTo(bufferChunk(leftoversRef)), pipeTo(collectAllWhileWithLoop(self, leftoversRef, upstreamDoneRef, options.initial, options.while, options.body)));
+  }));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const collectAllWhileWithLoop = (self, leftoversRef, upstreamDoneRef, currentResult, p, f) => {
+  return pipe(toChannel(self), doneCollect, foldChannel({
+    onFailure: fail$1,
+    onSuccess: ([leftovers, doneValue]) => p(doneValue) ? pipe(fromEffect$1(set$1(leftoversRef, flatten(leftovers))), flatMap$1(() => pipe(fromEffect$1(get(upstreamDoneRef)), flatMap$1(upstreamDone => {
+      const accumulatedResult = f(currentResult, doneValue);
+      return upstreamDone ? pipe(write(flatten(leftovers)), as$1(accumulatedResult)) : collectAllWhileWithLoop(self, leftoversRef, upstreamDoneRef, accumulatedResult, p, f);
+    })))) : pipe(write(flatten(leftovers)), as$1(currentResult))
+  }));
+};
+
+/** @internal */
+const collectLeftover = self => new SinkImpl(pipe(collectElements(toChannel(self)), map$2(([chunks, z]) => [z, flatten(chunks)])));
+
+/** @internal */
+const mapInput = /*#__PURE__*/dual(2, (self, f) => pipe(self, mapInputChunks(map$3(f))));
+
+/** @internal */
+const mapInputEffect = /*#__PURE__*/dual(2, (self, f) => mapInputChunksEffect(self, chunk => map$1(forEach$1(chunk, v => f(v)), unsafeFromArray)));
+
+/** @internal */
+const mapInputChunks = /*#__PURE__*/dual(2, (self, f) => {
+  const loop = readWith({
+    onInput: chunk => pipe(write(f(chunk)), flatMap$1(() => loop)),
+    onFailure: fail$1,
+    onDone: succeed$1
+  });
+  return new SinkImpl(pipe(loop, pipeTo(toChannel(self))));
+});
+
+/** @internal */
+const mapInputChunksEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const loop = readWith({
+    onInput: chunk => pipe(fromEffect$1(f(chunk)), flatMap$1(write), flatMap$1(() => loop)),
+    onFailure: fail$1,
+    onDone: succeed$1
+  });
+  return new SinkImpl(pipe(loop, pipeToOrFail(toChannel(self))));
+});
+
+/** @internal */
+const die = defect => failCause(die$1(defect));
+
+/** @internal */
+const dieMessage = message => failCause(die$1(RuntimeException(message)));
+
+/** @internal */
+const dieSync = evaluate => failCauseSync(() => die$1(evaluate()));
+
+/** @internal */
+const dimap = /*#__PURE__*/dual(2, (self, options) => map(mapInput(self, options.onInput), options.onDone));
+
+/** @internal */
+const dimapEffect = /*#__PURE__*/dual(2, (self, options) => mapEffect(mapInputEffect(self, options.onInput), options.onDone));
+
+/** @internal */
+const dimapChunks = /*#__PURE__*/dual(2, (self, options) => map(mapInputChunks(self, options.onInput), options.onDone));
+
+/** @internal */
+const dimapChunksEffect = /*#__PURE__*/dual(2, (self, options) => mapEffect(mapInputChunksEffect(self, options.onInput), options.onDone));
+
+/** @internal */
+const drain = /*#__PURE__*/new SinkImpl( /*#__PURE__*/drain$1( /*#__PURE__*/identityChannel()));
+
+/** @internal */
+const drop = n => suspend(() => new SinkImpl(dropLoop(n)));
+
+/** @internal */
+const dropLoop = n => readWith({
+  onInput: input => {
+    const dropped = pipe(input, drop$1(n));
+    const leftover = Math.max(n - input.length, 0);
+    const more = isEmpty(input) || leftover > 0;
+    if (more) {
+      return dropLoop(leftover);
+    }
+    return pipe(write(dropped), zipRight$1(identityChannel()));
+  },
+  onFailure: fail$1,
+  onDone: () => unit
+});
+
+/** @internal */
+const dropUntil = predicate => new SinkImpl(pipe(toChannel(dropWhile(input => !predicate(input))), pipeToOrFail(toChannel(drop(1)))));
+
+/** @internal */
+const dropUntilEffect = predicate => suspend(() => new SinkImpl(dropUntilEffectReader(predicate)));
+
+/** @internal */
+const dropUntilEffectReader = predicate => readWith({
+  onInput: input => pipe(input, dropUntil$1(predicate), map$1(leftover => {
+    const more = leftover.length === 0;
+    return more ? dropUntilEffectReader(predicate) : pipe(write(unsafeFromArray(leftover)), zipRight$1(identityChannel()));
+  }), unwrap$1),
+  onFailure: fail$1,
+  onDone: () => unit
+});
+
+/** @internal */
+const dropWhile = predicate => new SinkImpl(dropWhileReader(predicate));
+
+/** @internal */
+const dropWhileReader = predicate => readWith({
+  onInput: input => {
+    const out = pipe(input, dropWhile$1(predicate));
+    if (isEmpty(out)) {
+      return dropWhileReader(predicate);
+    }
+    return pipe(write(out), zipRight$1(identityChannel()));
+  },
+  onFailure: fail$1,
+  onDone: succeedNow
+});
+
+/** @internal */
+const dropWhileEffect = predicate => suspend(() => new SinkImpl(dropWhileEffectReader(predicate)));
+
+/** @internal */
+const dropWhileEffectReader = predicate => readWith({
+  onInput: input => pipe(input, dropWhile$2(predicate), map$1(leftover => {
+    const more = leftover.length === 0;
+    return more ? dropWhileEffectReader(predicate) : pipe(write(unsafeFromArray(leftover)), zipRight$1(identityChannel()));
+  }), unwrap$1),
+  onFailure: fail$1,
+  onDone: () => unit
+});
+
+/** @internal */
+const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => new SinkImpl(pipe(self, toChannel, ensuring$1(finalizer))));
+
+/** @internal */
+const ensuringWith = /*#__PURE__*/dual(2, (self, finalizer) => new SinkImpl(pipe(self, toChannel, ensuringWith$1(finalizer))));
+
+/** @internal */
+const context = () => fromEffect(context$1());
+
+/** @internal */
+const contextWith = f => pipe(context(), map(f));
+
+/** @internal */
+const contextWithEffect = f => pipe(context(), mapEffect(f));
+
+/** @internal */
+const contextWithSink = f => new SinkImpl(unwrap$1(pipe(contextWith$1(context => toChannel(f(context))))));
+
+/** @internal */
+const every = predicate => fold(true, identity, (acc, input) => acc && predicate(input));
+
+/** @internal */
+const fail = e => new SinkImpl(fail$1(e));
+
+/** @internal */
+const failSync = evaluate => new SinkImpl(failSync$1(evaluate));
+
+/** @internal */
+const failCause = cause => new SinkImpl(failCause$1(cause));
+
+/** @internal */
+const failCauseSync = evaluate => new SinkImpl(failCauseSync$1(evaluate));
+
+/** @internal */
+const filterInput = f => {
+  return self => pipe(self, mapInputChunks(filter(f)));
+};
+
+/** @internal */
+const filterInputEffect = /*#__PURE__*/dual(2, (self, f) => mapInputChunksEffect(self, chunk => map$1(filter$1(chunk, f), unsafeFromArray)));
+
+/** @internal */
+const findEffect = /*#__PURE__*/dual(2, (self, f) => {
+  const newChannel = pipe(fromEffect$1(pipe(make(empty()), zip$1(make(false)))), flatMap$1(([leftoversRef, upstreamDoneRef]) => {
+    const upstreamMarker = readWith({
+      onInput: input => pipe(write(input), flatMap$1(() => upstreamMarker)),
+      onFailure: fail$1,
+      onDone: done => pipe(fromEffect$1(set$1(upstreamDoneRef, true)), as$1(done))
+    });
+    const loop = foldChannel(collectElements(toChannel(self)), {
+      onFailure: fail$1,
+      onSuccess: ([leftovers, doneValue]) => pipe(fromEffect$1(f(doneValue)), flatMap$1(satisfied => pipe(fromEffect$1(set$1(leftoversRef, flatten(leftovers))), zipRight$1(pipe(fromEffect$1(get(upstreamDoneRef)), flatMap$1(upstreamDone => {
+        if (satisfied) {
+          return pipe(write(flatten(leftovers)), as$1(some$1(doneValue)));
+        }
+        if (upstreamDone) {
+          return pipe(write(flatten(leftovers)), as$1(none()));
+        }
+        return loop;
+      }))))))
+    });
+    return pipe(upstreamMarker, pipeTo(bufferChunk(leftoversRef)), pipeTo(loop));
+  }));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const fold = (s, contFn, f) => suspend(() => new SinkImpl(foldReader(s, contFn, f)));
+
+/** @internal */
+const foldReader = (s, contFn, f) => {
+  if (!contFn(s)) {
+    return succeedNow(s);
+  }
+  return readWith({
+    onInput: input => {
+      const [nextS, leftovers] = foldChunkSplit(s, input, contFn, f, 0, input.length);
+      if (isNonEmpty(leftovers)) {
+        return pipe(write(leftovers), as$1(nextS));
+      }
+      return foldReader(nextS, contFn, f);
+    },
+    onFailure: fail$1,
+    onDone: () => succeedNow(s)
+  });
+};
+
+/** @internal */
+const foldChunkSplit = (s, chunk, contFn, f, index, length) => {
+  if (index === length) {
+    return [s, empty()];
+  }
+  const s1 = f(s, pipe(chunk, unsafeGet$1(index)));
+  if (contFn(s1)) {
+    return foldChunkSplit(s1, chunk, contFn, f, index + 1, length);
+  }
+  return [s1, pipe(chunk, drop$1(index + 1))];
+};
+
+/** @internal */
+const foldSink = /*#__PURE__*/dual(2, (self, options) => {
+  const newChannel = pipe(toChannel(self), collectElements, foldChannel({
+    onFailure: error => toChannel(options.onFailure(error)),
+    onSuccess: ([leftovers, z]) => suspend$1(() => {
+      const leftoversRef = {
+        ref: pipe(leftovers, filter(isNonEmpty))
+      };
+      const refReader = pipe(sync$1(() => {
+        const ref = leftoversRef.ref;
+        leftoversRef.ref = empty();
+        return ref;
+      }),
+      // This cast is safe because of the L1 >: L <: In1 bound. It follows that
+      // L <: In1 and therefore Chunk[L] can be safely cast to Chunk[In1].
+      flatMap$1(chunk => writeChunk(chunk)));
+      const passthrough = identityChannel();
+      const continuationSink = pipe(refReader, zipRight$1(passthrough), pipeTo(toChannel(options.onSuccess(z))));
+      return flatMap$1(collectElements(continuationSink), ([newLeftovers, z1]) => pipe(succeed$1(leftoversRef.ref), flatMap$1(writeChunk), zipRight$1(writeChunk(newLeftovers)), as$1(z1)));
+    })
+  }));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const foldChunks = (s, contFn, f) => suspend(() => new SinkImpl(foldChunksReader(s, contFn, f)));
+
+/** @internal */
+const foldChunksReader = (s, contFn, f) => {
+  if (!contFn(s)) {
+    return succeedNow(s);
+  }
+  return readWith({
+    onInput: input => foldChunksReader(f(s, input), contFn, f),
+    onFailure: fail$1,
+    onDone: () => succeedNow(s)
+  });
+};
+
+/** @internal */
+const foldChunksEffect = (s, contFn, f) => suspend(() => new SinkImpl(foldChunksEffectReader(s, contFn, f)));
+
+/** @internal */
+const foldChunksEffectReader = (s, contFn, f) => {
+  if (!contFn(s)) {
+    return succeedNow(s);
+  }
+  return readWith({
+    onInput: input => pipe(fromEffect$1(f(s, input)), flatMap$1(s => foldChunksEffectReader(s, contFn, f))),
+    onFailure: fail$1,
+    onDone: () => succeedNow(s)
+  });
+};
+
+/** @internal */
+const foldEffect = (s, contFn, f) => suspend(() => new SinkImpl(foldEffectReader(s, contFn, f)));
+
+/** @internal */
+const foldEffectReader = (s, contFn, f) => {
+  if (!contFn(s)) {
+    return succeedNow(s);
+  }
+  return readWith({
+    onInput: input => pipe(fromEffect$1(foldChunkSplitEffect(s, input, contFn, f)), flatMap$1(([nextS, leftovers]) => pipe(leftovers, match$1({
+      onNone: () => foldEffectReader(nextS, contFn, f),
+      onSome: leftover => pipe(write(leftover), as$1(nextS))
+    })))),
+    onFailure: fail$1,
+    onDone: () => succeedNow(s)
+  });
+};
+
+/** @internal */
+const foldChunkSplitEffect = (s, chunk, contFn, f) => foldChunkSplitEffectInternal(s, chunk, 0, chunk.length, contFn, f);
+
+/** @internal */
+const foldChunkSplitEffectInternal = (s, chunk, index, length, contFn, f) => {
+  if (index === length) {
+    return succeed$2([s, none()]);
+  }
+  return pipe(f(s, pipe(chunk, unsafeGet$1(index))), flatMap$2(s1 => contFn(s1) ? foldChunkSplitEffectInternal(s1, chunk, index + 1, length, contFn, f) : succeed$2([s1, some$1(pipe(chunk, drop$1(index + 1)))])));
+};
+
+/** @internal */
+const foldLeft = (s, f) => ignoreLeftover(fold(s, constTrue, f));
+
+/** @internal */
+const foldLeftChunks = (s, f) => foldChunks(s, constTrue, f);
+
+/** @internal */
+const foldLeftChunksEffect = (s, f) => ignoreLeftover(foldChunksEffect(s, constTrue, f));
+
+/** @internal */
+const foldLeftEffect = (s, f) => foldEffect(s, constTrue, f);
+
+/** @internal */
+const foldUntil = (s, max, f) => pipe(fold([s, 0], tuple => tuple[1] < max, ([output, count], input) => [f(output, input), count + 1]), map(tuple => tuple[0]));
+
+/** @internal */
+const foldUntilEffect = (s, max, f) => pipe(foldEffect([s, 0], tuple => tuple[1] < max, ([output, count], input) => pipe(f(output, input), map$1(s => [s, count + 1]))), map(tuple => tuple[0]));
+
+/** @internal */
+const foldWeighted = options => foldWeightedDecompose({
+  ...options,
+  decompose: of
+});
+
+/** @internal */
+const foldWeightedDecompose = options => suspend(() => new SinkImpl(foldWeightedDecomposeLoop(options.initial, 0, false, options.maxCost, options.cost, options.decompose, options.body)));
+
+/** @internal */
+const foldWeightedDecomposeLoop = (s, cost, dirty, max, costFn, decompose, f) => readWith({
+  onInput: input => {
+    const [nextS, nextCost, nextDirty, leftovers] = foldWeightedDecomposeFold(input, 0, s, cost, dirty, max, costFn, decompose, f);
+    if (isNonEmpty(leftovers)) {
+      return pipe(write(leftovers), zipRight$1(succeedNow(nextS)));
+    }
+    if (cost > max) {
+      return succeedNow(nextS);
+    }
+    return foldWeightedDecomposeLoop(nextS, nextCost, nextDirty, max, costFn, decompose, f);
+  },
+  onFailure: fail$1,
+  onDone: () => succeedNow(s)
+});
+
+/** @internal */
+const foldWeightedDecomposeFold = (input, index, s, cost, dirty, max, costFn, decompose, f) => {
+  if (index === input.length) {
+    return [s, cost, dirty, empty()];
+  }
+  const elem = pipe(input, unsafeGet$1(index));
+  const total = cost + costFn(s, elem);
+  if (total <= max) {
+    return foldWeightedDecomposeFold(input, index + 1, f(s, elem), total, true, max, costFn, decompose, f);
+  }
+  const decomposed = decompose(elem);
+  if (decomposed.length <= 1 && !dirty) {
+    // If `elem` cannot be decomposed, we need to cross the `max` threshold. To
+    // minimize "injury", we only allow this when we haven't added anything else
+    // to the aggregate (dirty = false).
+    return [f(s, elem), total, true, pipe(input, drop$1(index + 1))];
+  }
+  if (decomposed.length <= 1 && dirty) {
+    // If the state is dirty and `elem` cannot be decomposed, we stop folding
+    // and include `elem` in the leftovers.
+    return [s, cost, dirty, pipe(input, drop$1(index))];
+  }
+  // `elem` got decomposed, so we will recurse with the decomposed elements pushed
+  // into the chunk we're processing and see if we can aggregate further.
+  const next = pipe(decomposed, appendAll(pipe(input, drop$1(index + 1))));
+  return foldWeightedDecomposeFold(next, 0, s, cost, dirty, max, costFn, decompose, f);
+};
+
+/** @internal */
+const foldWeightedDecomposeEffect = options => suspend(() => new SinkImpl(foldWeightedDecomposeEffectLoop(options.initial, options.maxCost, options.cost, options.decompose, options.body, 0, false)));
+
+/** @internal */
+const foldWeightedEffect = options => foldWeightedDecomposeEffect({
+  ...options,
+  decompose: input => succeed$2(of(input))
+});
+
+/** @internal */
+const foldWeightedDecomposeEffectLoop = (s, max, costFn, decompose, f, cost, dirty) => readWith({
+  onInput: input => pipe(fromEffect$1(foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, input, dirty, cost, 0)), flatMap$1(([nextS, nextCost, nextDirty, leftovers]) => {
+    if (isNonEmpty(leftovers)) {
+      return pipe(write(leftovers), zipRight$1(succeedNow(nextS)));
+    }
+    if (cost > max) {
+      return succeedNow(nextS);
+    }
+    return foldWeightedDecomposeEffectLoop(nextS, max, costFn, decompose, f, nextCost, nextDirty);
+  })),
+  onFailure: fail$1,
+  onDone: () => succeedNow(s)
+});
+
+/** @internal */
+const foldWeightedDecomposeEffectFold = (s, max, costFn, decompose, f, input, dirty, cost, index) => {
+  if (index === input.length) {
+    return succeed$2([s, cost, dirty, empty()]);
+  }
+  const elem = pipe(input, unsafeGet$1(index));
+  return pipe(costFn(s, elem), map$1(newCost => cost + newCost), flatMap$2(total => {
+    if (total <= max) {
+      return pipe(f(s, elem), flatMap$2(s => foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, input, true, total, index + 1)));
+    }
+    return pipe(decompose(elem), flatMap$2(decomposed => {
+      if (decomposed.length <= 1 && !dirty) {
+        // If `elem` cannot be decomposed, we need to cross the `max` threshold. To
+        // minimize "injury", we only allow this when we haven't added anything else
+        // to the aggregate (dirty = false).
+        return pipe(f(s, elem), map$1(s => [s, total, true, pipe(input, drop$1(index + 1))]));
+      }
+      if (decomposed.length <= 1 && dirty) {
+        // If the state is dirty and `elem` cannot be decomposed, we stop folding
+        // and include `elem` in th leftovers.
+        return succeed$2([s, cost, dirty, pipe(input, drop$1(index))]);
+      }
+      // `elem` got decomposed, so we will recurse with the decomposed elements pushed
+      // into the chunk we're processing and see if we can aggregate further.
+      const next = pipe(decomposed, appendAll(pipe(input, drop$1(index + 1))));
+      return foldWeightedDecomposeEffectFold(s, max, costFn, decompose, f, next, dirty, cost, 0);
+    }));
+  }));
+};
+
+/** @internal */
+const flatMap = /*#__PURE__*/dual(2, (self, f) => foldSink(self, {
+  onFailure: fail,
+  onSuccess: f
+}));
+
+/** @internal */
+const forEach = f => {
+  const process = readWithCause({
+    onInput: input => pipe(fromEffect$1(forEach$1(input, v => f(v), {
+      discard: true
+    })), flatMap$1(() => process)),
+    onFailure: failCause$1,
+    onDone: () => unit
+  });
+  return new SinkImpl(process);
+};
+
+/** @internal */
+const forEachChunk = f => {
+  const process = readWithCause({
+    onInput: input => pipe(fromEffect$1(f(input)), flatMap$1(() => process)),
+    onFailure: failCause$1,
+    onDone: () => unit
+  });
+  return new SinkImpl(process);
+};
+
+/** @internal */
+const forEachWhile = f => {
+  const process = readWithCause({
+    onInput: input => forEachWhileReader(f, input, 0, input.length, process),
+    onFailure: failCause$1,
+    onDone: () => unit
+  });
+  return new SinkImpl(process);
+};
+
+/** @internal */
+const forEachWhileReader = (f, input, index, length, cont) => {
+  if (index === length) {
+    return cont;
+  }
+  return pipe(fromEffect$1(f(pipe(input, unsafeGet$1(index)))), flatMap$1(bool => bool ? forEachWhileReader(f, input, index + 1, length, cont) : write(pipe(input, drop$1(index)))), catchAll(error => pipe(write(pipe(input, drop$1(index))), zipRight$1(fail$1(error)))));
+};
+
+/** @internal */
+const forEachChunkWhile = f => {
+  const reader = readWith({
+    onInput: input => pipe(fromEffect$1(f(input)), flatMap$1(cont => cont ? reader : unit)),
+    onFailure: fail$1,
+    onDone: () => unit
+  });
+  return new SinkImpl(reader);
+};
+
+/** @internal */
+const fromChannel = channel => new SinkImpl(channel);
+
+/** @internal */
+const fromEffect = effect => new SinkImpl(fromEffect$1(effect));
+
+/** @internal */
+const fromHub = (hub, options) => fromQueue(hub, options);
+
+/** @internal */
+const fromPush = push => new SinkImpl(unwrapScoped$1(pipe(push, map$1(fromPushPull))));
+const fromPushPull = push => readWith({
+  onInput: input => foldChannel(fromEffect$1(push(some$1(input))), {
+    onFailure: ([either, leftovers]) => match(either, {
+      onLeft: error => pipe(write(leftovers), zipRight$1(fail$1(error))),
+      onRight: z => pipe(write(leftovers), zipRight$1(succeedNow(z)))
+    }),
+    onSuccess: () => fromPushPull(push)
+  }),
+  onFailure: fail$1,
+  onDone: () => foldChannel(fromEffect$1(push(none())), {
+    onFailure: ([either, leftovers]) => match(either, {
+      onLeft: error => pipe(write(leftovers), zipRight$1(fail$1(error))),
+      onRight: z => pipe(write(leftovers), zipRight$1(succeedNow(z)))
+    }),
+    onSuccess: () => fromEffect$1(dieMessage$1("BUG: Sink.fromPush - please report an issue at https://github.com/Effect-TS/stream/issues"))
+  })
+});
+
+/** @internal */
+const fromQueue = (queue, options) => options?.shutdown ? unwrapScoped(map$1(acquireRelease(succeed$2(queue), shutdown), fromQueue)) : forEachChunk(input => pipe(offerAll(queue, input)));
+
+/** @internal */
+const head = () => fold(none(), isNone, (option, input) => match$1(option, {
+  onNone: () => some$1(input),
+  onSome: () => option
+}));
+
+/** @internal */
+const ignoreLeftover = self => new SinkImpl(drain$1(toChannel(self)));
+
+/** @internal */
+const last = () => foldLeftChunks(none(), (s, input) => orElse$2(last$1(input), () => s));
+
+/** @internal */
+const leftover = chunk => new SinkImpl(suspend$1(() => write(chunk)));
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => {
+  return new SinkImpl(pipe(toChannel(self), map$2(f)));
+});
+
+/** @internal */
+const mapEffect = /*#__PURE__*/dual(2, (self, f) => new SinkImpl(pipe(toChannel(self), mapEffect$1(f))));
+
+/** @internal */
+const mapError = /*#__PURE__*/dual(2, (self, f) => new SinkImpl(pipe(toChannel(self), mapError$1(f))));
+
+/** @internal */
+const mapLeftover = /*#__PURE__*/dual(2, (self, f) => new SinkImpl(pipe(toChannel(self), mapOut(map$3(f)))));
+
+/** @internal */
+const never = /*#__PURE__*/fromEffect(never$1);
+
+/** @internal */
+const orElse = /*#__PURE__*/dual(2, (self, that) => new SinkImpl(pipe(toChannel(self), orElse$1(() => toChannel(that())))));
+
+/** @internal */
+const provideContext = /*#__PURE__*/dual(2, (self, context) => new SinkImpl(pipe(toChannel(self), provideContext$1(context))));
+
+/** @internal */
+const race = /*#__PURE__*/dual(2, (self, that) => pipe(self, raceBoth(that), map(merge)));
+
+/** @internal */
+const raceBoth = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => raceWith(self, {
+  other: that,
+  onSelfDone: selfDone => Done(map$1(selfDone, left)),
+  onOtherDone: thatDone => Done(map$1(thatDone, right)),
+  capacity: options?.capacity ?? 16
+}));
+
+/** @internal */
+const raceWith = /*#__PURE__*/dual(2, (self, options) => {
+  const scoped = gen(function* ($) {
+    const hub = yield* $(bounded(options?.capacity ?? 16));
+    const channel1 = yield* $(fromHubScoped(hub));
+    const channel2 = yield* $(fromHubScoped(hub));
+    const reader = toHub(hub);
+    const writer = pipe(channel1, pipeTo(toChannel(self)), mergeWith({
+      other: pipe(channel2, pipeTo(toChannel(options.other))),
+      onSelfDone: options.onSelfDone,
+      onOtherDone: options.onOtherDone
+    }));
+    const racedChannel = mergeWith(reader, {
+      other: writer,
+      onSelfDone: _ => Await(exit => suspend$2(() => exit)),
+      onOtherDone: done => Done(suspend$2(() => done))
+    });
+    return new SinkImpl(racedChannel);
+  });
+  return unwrapScoped(scoped);
+});
+
+/** @internal */
+const refineOrDie = /*#__PURE__*/dual(2, (self, pf) => pipe(self, refineOrDieWith(pf, identity)));
+
+/** @internal */
+const refineOrDieWith = /*#__PURE__*/dual(3, (self, pf, f) => {
+  const newChannel = pipe(self, toChannel, catchAll(error => match$1(pf(error), {
+    onNone: () => failCauseSync$1(() => die$1(f(error))),
+    onSome: fail$1
+  })));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const some = predicate => fold(false, bool => !bool, (acc, input) => acc || predicate(input));
+
+/** @internal */
+const splitWhere = /*#__PURE__*/dual(2, (self, f) => {
+  const newChannel = pipe(fromEffect$1(make(empty())), flatMap$1(ref => pipe(splitWhereSplitter(false, ref, f), pipeToOrFail(toChannel(self)), collectElements, flatMap$1(([leftovers, z]) => pipe(fromEffect$1(get(ref)), flatMap$1(leftover => pipe(write(pipe(leftover, appendAll(flatten(leftovers)))), zipRight$1(succeed$1(z)))))))));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const splitWhereSplitter = (written, leftovers, f) => readWithCause({
+  onInput: input => {
+    if (isEmpty(input)) {
+      return splitWhereSplitter(written, leftovers, f);
+    }
+    if (written) {
+      const index = indexWhere(input, f);
+      if (index === -1) {
+        return zipRight$1(write(input), splitWhereSplitter(true, leftovers, f));
+      }
+      const [left, right] = splitAt(input, index);
+      return zipRight$1(write(left), fromEffect$1(set$1(leftovers, right)));
+    }
+    const index = indexWhere(input, f, 1);
+    if (index === -1) {
+      return zipRight$1(write(input), splitWhereSplitter(true, leftovers, f));
+    }
+    const [left, right] = pipe(input, splitAt(Math.max(index, 1)));
+    return zipRight$1(write(left), fromEffect$1(set$1(leftovers, right)));
+  },
+  onFailure: failCause$1,
+  onDone: succeed$1
+});
+
+/** @internal */
+const indexWhere = (self, predicate, from = 0) => {
+  const iterator = self[Symbol.iterator]();
+  let index = 0;
+  let result = -1;
+  let next;
+  while (result < 0 && (next = iterator.next()) && !next.done) {
+    const a = next.value;
+    if (index >= from && predicate(a)) {
+      result = index;
+    }
+    index = index + 1;
+  }
+  return result;
+};
+
+/** @internal */
+const succeed = z => new SinkImpl(succeed$1(z));
+
+/** @internal */
+const sum = /*#__PURE__*/foldLeftChunks(0, (acc, chunk) => acc + reduce(chunk, 0, (s, a) => s + a));
+
+/** @internal */
+const summarized = /*#__PURE__*/dual(3, (self, summary, f) => {
+  const newChannel = pipe(fromEffect$1(summary), flatMap$1(start => pipe(self, toChannel, flatMap$1(done => pipe(fromEffect$1(summary), map$2(end => [done, f(start, end)]))))));
+  return new SinkImpl(newChannel);
+});
+
+/** @internal */
+const sync = evaluate => new SinkImpl(sync$1(evaluate));
+
+/** @internal */
+const take = n => pipe(foldChunks(empty(), chunk => chunk.length < n, (acc, chunk) => pipe(acc, appendAll(chunk))), flatMap(acc => {
+  const [taken, leftover] = pipe(acc, splitAt(n));
+  return new SinkImpl(pipe(write(leftover), zipRight$1(succeedNow(taken))));
+}));
+
+/** @internal */
+const toChannel = self => isEffect(self) ? toChannel(fromEffect(self)) : self.channel;
+
+/** @internal */
+const unwrap = effect => new SinkImpl(unwrap$1(pipe(effect, map$1(sink => toChannel(sink)))));
+
+/** @internal */
+const unwrapScoped = effect => {
+  return new SinkImpl(unwrapScoped$1(pipe(effect, map$1(sink => toChannel(sink)))));
+};
+
+/** @internal */
+const withDuration = self => pipe(self, summarized(currentTimeMillis, (start, end) => millis(end - start)));
+
+/** @internal */
+const zip = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (z, z2) => [z, z2], options));
+
+/** @internal */
+const zipLeft = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (z, _) => z, options));
+
+/** @internal */
+const zipRight = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options) => zipWith(self, that, (_, z2) => z2, options));
+
+/** @internal */
+const zipWith = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, f, options) => options?.concurrent ? raceWith(self, {
+  other: that,
+  onSelfDone: match$2({
+    onFailure: cause => Done(failCause$2(cause)),
+    onSuccess: leftZ => Await(match$2({
+      onFailure: failCause$2,
+      onSuccess: rightZ => succeed$2(f(leftZ, rightZ))
+    }))
+  }),
+  onOtherDone: match$2({
+    onFailure: cause => Done(failCause$2(cause)),
+    onSuccess: rightZ => Await(match$2({
+      onFailure: failCause$2,
+      onSuccess: leftZ => succeed$2(f(leftZ, rightZ))
+    }))
+  })
+}) : flatMap(self, z => map(that, z2 => f(z, z2))));
+
+// Circular with Channel
+
+/** @internal */
+const channelToSink = self => new SinkImpl(self);
+
+// Constants
+
+/** @internal */
+const count = /*#__PURE__*/foldLeftChunks(0, (acc, chunk) => acc + chunk.length);
+
+/** @internal */
+const mkString = /*#__PURE__*/suspend(() => {
+  const strings = [];
+  return pipe(foldLeftChunks(void 0, (_, elems) => map$3(elems, elem => {
+    strings.push(String(elem));
+  })), map(() => strings.join("")));
+});
+
+/** @internal */
+const timed = /*#__PURE__*/pipe( /*#__PURE__*/withDuration(drain), /*#__PURE__*/map(tuple => tuple[1]));
+
+export { SinkImpl, SinkTypeId, as, channelToSink, collectAll, collectAllFrom, collectAllN, collectAllToMap, collectAllToMapN, collectAllToSet, collectAllToSetN, collectAllUntil, collectAllUntilEffect, collectAllWhile, collectAllWhileEffect, collectAllWhileWith, collectLeftover, context, contextWith, contextWithEffect, contextWithSink, count, die, dieMessage, dieSync, dimap, dimapChunks, dimapChunksEffect, dimapEffect, drain, drop, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, ensuring, ensuringWith, every, fail, failCause, failCauseSync, failSync, filterInput, filterInputEffect, findEffect, flatMap, fold, foldChunks, foldChunksEffect, foldEffect, foldLeft, foldLeftChunks, foldLeftChunksEffect, foldLeftEffect, foldSink, foldUntil, foldUntilEffect, foldWeighted, foldWeightedDecompose, foldWeightedDecomposeEffect, foldWeightedEffect, forEach, forEachChunk, forEachChunkWhile, forEachWhile, fromChannel, fromEffect, fromHub, fromPush, fromQueue, head, ignoreLeftover, isSink, last, leftover, map, mapEffect, mapError, mapInput, mapInputChunks, mapInputChunksEffect, mapInputEffect, mapLeftover, mkString, never, orElse, provideContext, race, raceBoth, raceWith, refineOrDie, refineOrDieWith, some, splitWhere, succeed, sum, summarized, suspend, sync, take, timed, toChannel, unwrap, unwrapScoped, withDuration, zip, zipLeft, zipRight, zipWith };