@fncts/io 0.0.9 → 0.0.10

package/_cjs/Sink/api.cjs

@@ -3,53 +3,381 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.apFirst = apFirst;
+exports.apFirstC = apFirstC;
+exports.apSecond = apSecond;
+exports.apSecondC = apSecondC;
+exports.as = as;
 exports.collectAll = collectAll;
+exports.collectAllWhileWith = void 0;
+exports.collectLeftover = collectLeftover;
+exports.defer = exports.contramapIO = exports.contramapChunksIO = exports.contramapChunks = exports.contramap = void 0;
+exports.dimap = dimap;
+exports.dimapChunks = dimapChunks;
+exports.dimapChunksIO = dimapChunksIO;
+exports.dimapIO = dimapIO;
 exports.drain = void 0;
 exports.dropWhile = dropWhile;
-exports.foreach = foreach;
-exports.foreachWhile = void 0;
+exports.environment = environment;
+exports.environmentWith = environmentWith;
+exports.environmentWithIO = environmentWithIO;
+exports.environmentWithSink = environmentWithSink;
+exports.fail = fail;
+exports.failNow = exports.failCauseNow = exports.failCause = void 0;
+exports.filterInput = filterInput;
+exports.filterInputIO = filterInputIO;
+exports.findIO = findIO;
+exports.flatMap = void 0;
+exports.fromChannel = fromChannel;
+exports.fromHub = fromHub;
+exports.fromHubWithShutdown = fromHubWithShutdown;
+exports.fromIO = void 0;
+exports.fromPush = fromPush;
+exports.fromQueueWithShutdown = exports.fromQueue = void 0;
+exports.halt = halt;
+exports.haltNow = haltNow;
+exports.head = head;
+exports.ignoreLeftover = void 0;
+exports.last = last;
+exports.leftover = leftover;
+exports.log = log;
+exports.makeCollectAll = makeCollectAll;
+exports.makeCollectAllN = makeCollectAllN;
+exports.makeFoldLeft = exports.makeFoldIO = exports.makeFoldChunksIO = exports.makeFoldChunks = exports.makeFold = void 0;
+exports.makeFoldLeftChunks = makeFoldLeftChunks;
+exports.makeFoldLeftChunksIO = makeFoldLeftChunksIO;
+exports.makeFoldLeftIO = makeFoldLeftIO;
+exports.makeFoldUntil = void 0;
+exports.makeFoldUntilIO = makeFoldUntilIO;
+exports.makeFoldWeighted = makeFoldWeighted;
+exports.makeFoldWeightedDecomposeIO = exports.makeFoldWeightedDecompose = void 0;
+exports.makeFoldWeightedIO = makeFoldWeightedIO;
+exports.makeForeach = makeForeach;
+exports.makeForeachChunk = void 0;
+exports.makeForeachChunkWhile = makeForeachChunkWhile;
+exports.makeForeachWhile = void 0;
+exports.mapError_ = mapError_;
+exports.matchSink_ = exports.map_ = exports.mapIO_ = void 0;
+exports.orElse = orElse;
+exports.provideEnvironment = provideEnvironment;
+exports.race = race;
+exports.raceWith = exports.raceBoth = void 0;
+exports.service = service;
+exports.serviceWith = void 0;
+exports.serviceWithIO = serviceWithIO;
+exports.serviceWithSink = serviceWithSink;
+exports.splitWhere = splitWhere;
+exports.succeed = succeed;
+exports.succeedNow = succeedNow;
+exports.summarized = void 0;
+exports.timed = timed;
+exports.unwrapScoped = exports.unwrap = void 0;
+exports.zip = zip;
+exports.zipC = zipC;
+exports.zipWithC = exports.zipWith = void 0;
 
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api"));
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api/empty"));
 
-var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/core-api"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api"));
 
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/api"));
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Sink/definition"));
 
-var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Sink/definition"));
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/api"));
 
-var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/api/empty"));
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/core-api"));
 
-var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/api/set"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/api/get"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Ref/constructors"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/collection/immutable/Conc/mapIO"));
+
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/environment"));
+
+var tsplus_module_12 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+
+var tsplus_module_13 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/collection/immutable/Conc/filterIO"));
+
+var tsplus_module_14 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_15 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var tsplus_module_16 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Queue/api/operations"));
+
+var tsplus_module_17 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/acquireRelease"));
+
+var tsplus_module_18 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Cause/api"));
+
+var tsplus_module_19 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_20 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var tsplus_module_21 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc"));
+
+var tsplus_module_22 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Conc/constructors"));
+
+var tsplus_module_23 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/api"));
+
+var tsplus_module_24 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/constructors"));
+
+var tsplus_module_25 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/internal/MergeDecision"));
+
+var tsplus_module_26 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Channel/api/mergeWith"));
+
+var tsplus_module_27 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Hub/api"));
+
+var tsplus_module_28 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/Iterable/api"));
+
+var tsplus_module_29 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/Clock/api"));
+
+var tsplus_module_30 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Duration/api"));
+
+var tsplus_module_31 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/api"));
+
+var _AtomicReference = /*#__PURE__*/require("@fncts/base/internal/AtomicReference");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const foreachWhile = foreachWhile_1;
-exports.foreachWhile = foreachWhile;
+const fileName_1 = "(@fncts/io) src/Sink/api.ts";
+const collectAllWhileWith = collectAllWhileWith_1;
+exports.collectAllWhileWith = collectAllWhileWith;
+const contramap = contramap_1;
+exports.contramap = contramap;
+const contramapChunks = contramapChunks_1;
+exports.contramapChunks = contramapChunks;
+const contramapChunksIO = contramapChunksIO_1;
+exports.contramapChunksIO = contramapChunksIO;
+const contramapIO = contramapIO_1;
+exports.contramapIO = contramapIO;
+const defer = defer_1;
+exports.defer = defer;
+const failCause = failCause_1;
+exports.failCause = failCause;
+const failCauseNow = failCauseNow_1;
+exports.failCauseNow = failCauseNow;
+const failNow = failNow_1;
+exports.failNow = failNow;
+const flatMap = flatMap_1;
+exports.flatMap = flatMap;
+const fromQueue = fromQueue_1;
+exports.fromQueue = fromQueue;
+const fromQueueWithShutdown = fromQueueWithShutdown_1;
+exports.fromQueueWithShutdown = fromQueueWithShutdown;
+const fromIO = fromIO_1;
+exports.fromIO = fromIO;
+const ignoreLeftover = ignoreLeftover_1;
+exports.ignoreLeftover = ignoreLeftover;
+const makeForeachChunk = makeForeachChunk_1;
+exports.makeForeachChunk = makeForeachChunk;
+const makeForeachWhile = makeForeachWhile_1;
+exports.makeForeachWhile = makeForeachWhile;
+const makeFold = makeFold_1;
+exports.makeFold = makeFold;
+const makeFoldUntil = makeFoldUntil_1;
+exports.makeFoldUntil = makeFoldUntil;
+const makeFoldChunks = makeFoldChunks_1;
+exports.makeFoldChunks = makeFoldChunks;
+const makeFoldChunksIO = makeFoldChunksIO_1;
+exports.makeFoldChunksIO = makeFoldChunksIO;
+const makeFoldLeft = makeFoldLeft_1;
+exports.makeFoldLeft = makeFoldLeft;
+const makeFoldIO = makeFoldIO_1;
+exports.makeFoldIO = makeFoldIO;
+const makeFoldWeightedDecompose = makeFoldWeightedDecompose_1;
+exports.makeFoldWeightedDecompose = makeFoldWeightedDecompose;
+const makeFoldWeightedDecomposeIO = makeFoldWeightedDecomposeIO_1;
+exports.makeFoldWeightedDecomposeIO = makeFoldWeightedDecomposeIO;
+const map_ = map_1;
+exports.map_ = map_;
+const mapIO_ = mapIO_1;
+exports.mapIO_ = mapIO_;
+const matchSink_ = matchSink_1;
+exports.matchSink_ = matchSink_;
+const raceBoth = raceBoth_1;
+exports.raceBoth = raceBoth;
+const raceWith = raceWith_1;
+exports.raceWith = raceWith;
+const serviceWith = serviceWith_1;
+exports.serviceWith = serviceWith;
+const summarized = summarized_1;
+exports.summarized = summarized;
+const unwrap = unwrap_1;
+exports.unwrap = unwrap;
+const unwrapScoped = unwrapScoped_1;
+exports.unwrapScoped = unwrapScoped;
+const zipWith = zipWith_1;
+exports.zipWith = zipWith;
+const zipWithC = zipWithC_1;
+exports.zipWithC = zipWithC;
 
-function collectLoop(state) {
-  return tsplus_module_3.readWithCause(inp => collectLoop(tsplus_module_1.concat_(state, inp)), tsplus_module_2.failCauseNow, () => tsplus_module_2.endNow(state));
+/**
+ * @tsplus fluent fncts.io.Sink apFirst
+ */
+function apFirst(self, that) {
+  return zipWith_1(() => self, that, (z, _) => z);
 }
 /**
- * A sink that collects all of its inputs into a chunk.
- *
- * @tsplus static fncts.io.SinkOps collectAll
+ * @tsplus fluent fncts.io.Sink apFirstC
+ */
+
+
+function apFirstC(self, that) {
+  return zipWithC_1(() => self, that, (z, _) => z);
+}
+/**
+ * @tsplus fluent fncts.io.Sink apSecond
+ */
+
+
+function apSecond(self, that) {
+  return zipWith_1(() => self, that, (_, z1) => z1);
+}
+/**
+ * @tsplus fluent fncts.io.Sink apSecondC
+ */
+
+
+function apSecondC(self, that) {
+  return zipWithC_1(() => self, that, (_, z1) => z1);
+}
+/**
+ * @tsplus fluent fncts.io.Sink as
+ */
+
+
+function as(self, z) {
+  return map_1(self, () => z(), fileName_1 + ":49:18");
+}
+/**
+ * @tsplus fluent fncts.io.Sink collectAll
+ */
+
+
+function collectAll(self, __tsplusTrace) {
+  return collectAllWhileWith_1(self, () => tsplus_module_1.empty(), () => true, (s, z) => tsplus_module_2.append_(s, z), __tsplusTrace);
+}
+/**
+ * @tsplus fluent fncts.io.Sink collectAllWhileWith
+ */
+
+
+function collectAllWhileWith_1(self, z, p, f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_9.zip_(tsplus_module_8.make(() => tsplus_module_1.empty()), tsplus_module_8.make(() => false))), ([leftoversRef, upstreamDoneRef]) => {
+    const upstreamMarker = tsplus_module_4.readWith(inp => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), upstreamMarker), tsplus_module_4.failNow, x => tsplus_module_4.as_(tsplus_module_4.fromIO(() => tsplus_module_6.set_(upstreamDoneRef, true)), () => x));
+
+    function loop(currentResult) {
+      return tsplus_module_4.matchChannel_(tsplus_module_4.collectElements(self.channel), tsplus_module_4.failNow, ([leftovers, doneValue]) => {
+        if (p(doneValue)) {
+          return tsplus_module_5.apSecond_(tsplus_module_4.fromIO(() => tsplus_module_6.set_(leftoversRef, tsplus_module_2.flatten(leftovers))), tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_7.get(upstreamDoneRef)), upstreamDone => {
+            const accumulatedResult = f(currentResult, doneValue);
+            if (upstreamDone) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => accumulatedResult);else return loop(accumulatedResult);
+          }));
+        } else {
+          return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => currentResult);
+        }
+      });
+    }
+
+    return tsplus_module_4.pipeTo_(tsplus_module_4.pipeTo_(upstreamMarker, tsplus_module_4.bufferChunk(leftoversRef)), loop(z()));
+  }));
+}
+/**
+ * @tsplus getter fncts.io.Sink collectLeftover
+ */
+
+
+function collectLeftover(self, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.map_(tsplus_module_4.collectElements(self.channel), ([chunks, z]) => [z, tsplus_module_2.flatten(chunks)]));
+}
+/**
+ * @tsplus fluent fncts.io.Sink contramap
+ */
+
+
+function contramap_1(self, f) {
+  return contramapChunks_1(self, chunk => tsplus_module_2.map_(chunk, f));
+}
+/**
+ * @tsplus fluent fncts.io.Sink contramapChunks
+ */
+
+
+function contramapChunks_1(self, f) {
+  const loop = tsplus_module_4.readWith(chunk => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(f(chunk)), loop), tsplus_module_4.failNow, tsplus_module_5.succeedNow);
+  return new tsplus_module_3.Sink(tsplus_module_4.pipeTo_(loop, self.channel));
+}
+/**
+ * @tsplus fluent fncts.io.Sink contramapChunksIO
+ */
+
+
+function contramapChunksIO_1(self, f) {
+  const loop = tsplus_module_4.readWith(chunk => tsplus_module_5.apSecond_(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(chunk)), tsplus_module_4.writeNow), loop), tsplus_module_4.failNow, tsplus_module_5.succeedNow);
+  return new tsplus_module_3.Sink(tsplus_module_4.pipeToOrFail_(loop, self.channel));
+}
+/**
+ * @tsplus fluent fncts.io.Sink contramapIO
+ */
+
+
+function contramapIO_1(self, f) {
+  return contramapChunksIO_1(self, chunk => tsplus_module_10.mapIO_(chunk, f));
+}
+/**
+ * @tsplus fluent fncts.io.Sink dimap
+ */
+
+
+function dimap(self, f, g) {
+  return map_1(contramap_1(self, f), g, fileName_1 + ":171:31");
+}
+/**
+ * @tsplus fluent fncts.io.Sink dimapChunks
+ */
+
+
+function dimapChunks(self, f, g) {
+  return map_1(contramapChunks_1(self, f), g, fileName_1 + ":182:37");
+}
+/**
+ * @tsplus fluent fncts.io.Sink dimapChunksIO
+ */
+
+
+function dimapChunksIO(self, f, g) {
+  return mapIO_1(contramapChunksIO_1(self, f), g, fileName_1 + ":193:41");
+}
+/**
+ * @tsplus fluent fncts.io.Sink dimapIO
+ */
+
+
+function dimapIO(self, f, g) {
+  return mapIO_1(contramapIO_1(self, f), g, fileName_1 + ":204:35");
+}
+/**
+ * @tsplus static fncts.io.SinkOps defer
  */
 
 
-function collectAll() {
-  return new tsplus_module_4.Sink(collectLoop(tsplus_module_5.empty()));
+function defer_1(sink) {
+  return new tsplus_module_3.Sink(tsplus_module_4.defer(() => sink().channel));
 }
 
-const drainLoop = /*#__PURE__*/tsplus_module_3.readWithCause(() => drainLoop, tsplus_module_2.failCauseNow, () => tsplus_module_3.unit);
+const drainLoop = /*#__PURE__*/tsplus_module_4.readWithCause(() => drainLoop, tsplus_module_5.failCauseNow, () => tsplus_module_4.unit);
 /**
  * A sink that ignores all of its inputs.
  *
  * @tsplus static fncts.io.SinkOps drain
  */
 
-const drain = /*#__PURE__*/new tsplus_module_4.Sink(drainLoop);
+const drain = /*#__PURE__*/new tsplus_module_3.Sink(drainLoop);
 /**
  * @tsplus static fncts.io.SinkOps dropWhile
  */
@@ -57,46 +385,858 @@ const drain = /*#__PURE__*/new tsplus_module_4.Sink(drainLoop);
 exports.drain = drain;
 
 function dropWhile(predicate) {
-  const loop = tsplus_module_3.readWith(inp => {
-    const leftover = tsplus_module_1.dropWhile_(inp, predicate);
-    const more = tsplus_module_1.isEmpty(leftover);
+  const loop = tsplus_module_4.readWith(inp => {
+    const leftover = tsplus_module_2.dropWhile_(inp, predicate);
+    const more = tsplus_module_2.isEmpty(leftover);
 
     if (more) {
       return loop;
     } else {
-      return tsplus_module_2.apSecond_(tsplus_module_3.writeNow(leftover), tsplus_module_3.id());
+      return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftover), tsplus_module_4.id());
     }
-  }, tsplus_module_3.failNow, () => tsplus_module_3.unit);
-  return new tsplus_module_4.Sink(loop);
+  }, tsplus_module_4.failNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(loop);
 }
 /**
- * A sink that executes the provided effectful function for every element fed to it.
+ * @tsplus static fncts.io.SinkOps environment
+ */
+
+
+function environment(__tsplusTrace) {
+  return fromIO_1(() => tsplus_module_11.environment(__tsplusTrace));
+}
+/**
+ * @tsplus static fncts.io.SinkOps environmentWith
+ */
+
+
+function environmentWith(f, __tsplusTrace) {
+  return fromIO_1(() => tsplus_module_11.environmentWith(f, __tsplusTrace));
+}
+/**
+ * @tsplus static fncts.io.SinkOps environmentWithIO
+ */
+
+
+function environmentWithIO(f, __tsplusTrace) {
+  return fromIO_1(() => tsplus_module_11.environmentWithIO(f, __tsplusTrace));
+}
+/**
+ * @tsplus static fncts.io.SinkOps environmentWithSink
+ */
+
+
+function environmentWithSink(f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_11.environmentWith(tsplus_module_12.compose_(f, s => s.channel), __tsplusTrace)));
+}
+/**
+ * @tsplus static fncts.io.SinkOps fail
+ */
+
+
+function fail(e) {
+  return new tsplus_module_3.Sink(tsplus_module_4.fail(e));
+}
+/**
+ * @tsplus static fncts.io.SinkOps failCause
+ */
+
+
+function failCause_1(cause, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.failCause(cause));
+}
+/**
+ * @tsplus static fncts.io.SinkOps failCauseNow
+ */
+
+
+function failCauseNow_1(cause, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.failCauseNow(cause));
+}
+/**
+ * @tsplus static fncts.io.SinkOps failNow
+ */
+
+
+function failNow_1(e, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.failNow(e));
+}
+/**
+ * @tsplus static fncts.io.SinkOps filterInput
+ */
+
+
+function filterInput(self, p, __tsplusTrace) {
+  return contramapChunks_1(self, chunk => tsplus_module_2.filter_(chunk, p));
+}
+/**
+ * @tsplus static fncts.io.SinkOps filterInputIO
+ */
+
+
+function filterInputIO(self, p, __tsplusTrace) {
+  return contramapChunksIO_1(self, chunk => tsplus_module_13.filterIO(chunk, p));
+}
+/**
+ * @tsplus fluent fncts.io.Sink findIO
+ */
+
+
+function findIO(self, f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_9.zip_(tsplus_module_8.make(() => tsplus_module_1.empty()), tsplus_module_8.make(() => false))), ([leftoversRef, upstreamDoneRef]) => {
+    const upstreamMarker = tsplus_module_4.readWith(inp => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), upstreamMarker), tsplus_module_4.failNow, x => tsplus_module_4.as_(tsplus_module_4.fromIO(() => tsplus_module_6.set_(upstreamDoneRef, true)), () => x));
+    const loop = tsplus_module_4.matchChannel_(tsplus_module_4.collectElements(self.channel), tsplus_module_4.failNow, ([leftovers, doneValue]) => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(doneValue)), satisfied => tsplus_module_5.apSecond_(tsplus_module_4.fromIO(() => tsplus_module_6.set_(leftoversRef, tsplus_module_2.flatten(leftovers))), tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_7.get(upstreamDoneRef)), upstreamDone => {
+      if (satisfied) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => tsplus_module_14.just(doneValue));else if (upstreamDone) return tsplus_module_4.as_(tsplus_module_4.writeNow(tsplus_module_2.flatten(leftovers)), () => tsplus_module_14.nothing());else return loop;
+    }))));
+    return tsplus_module_4.pipeTo_(tsplus_module_4.pipeTo_(upstreamMarker, tsplus_module_4.bufferChunk(leftoversRef)), loop);
+  }));
+}
+/**
+ * @tsplus fluent fncts.io.Sink flatMap
+ */
+
+
+function flatMap_1(self, f, __tsplusTrace) {
+  return matchSink_1(self, failNow_1, f, __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromChannel
+ * @tsplus static fncts.io.SinkOps __call
+ */
+
+
+function fromChannel(channel) {
+  return new tsplus_module_3.Sink(channel);
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromPush
+ */
+
+
+function fromPush(push, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrapScoped(() => tsplus_module_9.map_(push, fromPushPull, __tsplusTrace)));
+}
+
+function fromPushPull(push) {
+  return tsplus_module_4.readWith(inp => tsplus_module_4.matchChannel_(tsplus_module_4.fromIO(() => push(tsplus_module_14.just(inp))), ([r, leftovers]) => tsplus_module_15.match_(r, e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_4.failNow(e)), z => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(z))), () => fromPushPull(push)), tsplus_module_4.failNow, () => tsplus_module_4.matchChannel_(tsplus_module_4.fromIO(() => push(tsplus_module_14.nothing())), ([r, leftovers]) => tsplus_module_15.match_(r, e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_4.failNow(e)), z => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(z))), () => tsplus_module_4.fromIO(() => tsplus_module_9.halt(() => new Error("empty sink"), fileName_1 + ":427:37"))));
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromQueue
+ */
+
+
+function fromQueue_1(queue) {
+  return unwrap_1(() => tsplus_module_9.map_(tsplus_module_9.succeed(queue, fileName_1 + ":436:32"), queue => makeForeachChunk_1(inp => tsplus_module_16.offerAll_(queue, inp), fileName_1 + ":436:72"), fileName_1 + ":436:43"));
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
+ */
+
+
+function fromQueueWithShutdown_1(queue) {
+  return unwrapScoped_1(() => tsplus_module_9.map_(tsplus_module_17.acquireRelease(() => tsplus_module_9.succeed(queue, fileName_1 + ":444:15"), queue => tsplus_module_16.shutdown(queue)), queue => fromQueue_1(() => queue), fileName_1 + ":446:11"));
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromHub
+ */
+
+
+function fromHub(hub) {
+  return fromQueue_1(hub);
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromHubWithShutdown
+ */
+
+
+function fromHubWithShutdown(hub) {
+  return fromQueueWithShutdown_1(hub);
+}
+/**
+ * @tsplus static fncts.io.SinkOps fromIO
+ */
+
+
+function fromIO_1(b) {
+  return new tsplus_module_3.Sink(tsplus_module_4.fromIO(b));
+}
+/**
+ * @tsplus static fncts.io.SinkOps halt
+ */
+
+
+function halt(defect, __tsplusTrace) {
+  return failCause_1(() => tsplus_module_18.halt(defect()), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.SinkOps haltNow
+ */
+
+
+function haltNow(defect, __tsplusTrace) {
+  return failCauseNow_1(tsplus_module_18.halt(defect), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.SinkOps head
+ */
+
+
+function head(__tsplusTrace) {
+  return makeFold_1(() => tsplus_module_14.nothing(), elem => tsplus_module_19.isNothing(elem), (s, inp) => tsplus_module_20.match_(s, () => tsplus_module_14.just(inp), () => s), __tsplusTrace);
+}
+/**
+ * @tsplus getter fncts.io.Sink ignoreLeftover
+ */
+
+
+function ignoreLeftover_1(self, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.drain(self.channel));
+}
+/**
+ * @tsplus static fncts.io.SinkOps last
+ */
+
+
+function last(__tsplusTrace) {
+  return makeFoldLeft_1(() => tsplus_module_14.nothing(), (_, inp) => tsplus_module_14.just(inp));
+}
+/**
+ * @tsplus static fncts.io.SinkOps leftover
+ */
+
+
+function leftover(c, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.write(c));
+}
+/**
+ * @tsplus static fncts.io.SinkOps log
+ */
+
+
+function log(message, __tsplusTrace) {
+  return fromIO_1(() => tsplus_module_9.log(message, __tsplusTrace));
+}
+/**
+ * A sink that collects all of its inputs into a chunk.
  *
- * @tsplus static fncts.io.SinkOps foreach
+ * @tsplus static fncts.io.SinkOps collectAll
  */
 
 
-function foreach(f) {
-  return foreachWhile_1(inp => tsplus_module_6.as_(f(inp), () => true));
+function makeCollectAll() {
+  return new tsplus_module_3.Sink(collectLoop(tsplus_module_1.empty()));
 }
 
-function foreachWhileLoop(f, chunk, idx, len, cont) {
-  if (idx === len) {
-    return cont;
-  }
+function collectLoop(state) {
+  return tsplus_module_4.readWithCause(inp => collectLoop(tsplus_module_2.concat_(state, inp)), tsplus_module_5.failCauseNow, () => tsplus_module_5.endNow(state));
+}
 
-  return tsplus_module_3.catchAll_(tsplus_module_2.flatMap_(tsplus_module_3.fromIO(() => f(tsplus_module_1.unsafeGet_(chunk, idx))), b => b ? foreachWhileLoop(f, chunk, idx + 1, len, cont) : tsplus_module_3.writeNow(tsplus_module_1.drop_(chunk, idx))), e => tsplus_module_2.apSecond_(tsplus_module_3.writeNow(tsplus_module_1.drop_(chunk, idx)), tsplus_module_3.failNow(e)));
+function makeCollectAllN(n) {
+  return flatMap_1(fromIO_1(() => tsplus_module_9.succeed(() => new tsplus_module_21.ConcBuilder(), fileName_1 + ":549:32")), builder => map_1(makeFoldUntil_1(() => builder, n, (builder, inp) => builder.append(inp), fileName_1 + ":550:19"), builder => builder.result(), fileName_1 + ":550:95"), fileName_1 + ":549:64");
 }
 /**
- * A sink that executes the provided effectful function for every element fed to it
- * until `f` evaluates to `false`.
+ * A sink that executes the provided effectful function for every element fed to it.
  *
- * @tsplus static fncts.io.SinkOps foreachWhile
+ * @tsplus static fncts.io.SinkOps foreach
+ */
+
+
+function makeForeach(f, __tsplusTrace) {
+  return makeForeachWhile_1(inp => tsplus_module_9.as_(f(inp), () => true), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.SinkOps foreachChunk
+ */
+
+
+function makeForeachChunk_1(f, __tsplusTrace) {
+  const process = tsplus_module_4.readWithCause(inp => tsplus_module_5.apSecond_(tsplus_module_4.fromIO(() => f(inp)), process), tsplus_module_5.failCauseNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(process);
+}
+/**
+ * A sink that executes the provided effectful function for every element fed to it
+ * until `f` evaluates to `false`.
+ *
+ * @tsplus static fncts.io.SinkOps foreachWhile
+ */
+
+
+function makeForeachWhile_1(f, __tsplusTrace) {
+  const process = tsplus_module_4.readWithCause(inp => foreachWhileLoop(f, inp, 0, inp.length, process), tsplus_module_5.failCauseNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(process);
+}
+
+function foreachWhileLoop(f, chunk, idx, len, cont) {
+  if (idx === len) {
+    return cont;
+  }
+
+  return tsplus_module_4.catchAll_(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(tsplus_module_2.unsafeGet_(chunk, idx))), b => b ? foreachWhileLoop(f, chunk, idx + 1, len, cont) : tsplus_module_4.writeNow(tsplus_module_2.drop_(chunk, idx))), e => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(tsplus_module_2.drop_(chunk, idx)), tsplus_module_4.failNow(e)));
+}
+/**
+ * @tsplus static fncts.io.SinkOps foreachChunkWhile
+ */
+
+
+function makeForeachChunkWhile(f, __tsplusTrace) {
+  const reader = tsplus_module_4.readWith(inp => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(inp)), cont => cont ? reader : tsplus_module_4.unit), tsplus_module_4.failNow, () => tsplus_module_4.unit);
+  return new tsplus_module_3.Sink(reader);
+}
+/**
+ * @tsplus static fncts.io.SinkOps fold
+ */
+
+
+function makeFold_1(z, contFn, f, __tsplusTrace) {
+  return defer_1(() => new tsplus_module_3.Sink(foldReader(z(), contFn, f)));
+}
+/**
+ * @tsplus tailRec
+ */
+
+
+function foldChunkSplit(contFn, f, s, chunk, idx, len) {
+  var contFn_1 = contFn,
+      f_1 = f,
+      s_1 = s,
+      chunk_1 = chunk,
+      idx_1 = idx,
+      len_1 = len;
+  var contFn_2 = contFn,
+      f_2 = f,
+      s_2 = s,
+      chunk_2 = chunk,
+      idx_2 = idx,
+      len_2 = len;
+
+  while (1) {
+    if (idx_1 === len_1) {
+      return [s_1, tsplus_module_1.empty()];
+    } else {
+      const s1 = f_1(s_1, tsplus_module_2.unsafeGet_(chunk_1, idx_1));
+
+      if (contFn_1(s1)) {
+        contFn_2 = contFn_1;
+        f_2 = f_1;
+        s_2 = s1;
+        chunk_2 = chunk_1;
+        idx_2 = idx_1 + 1;
+        len_2 = len_1;
+        contFn_1 = contFn_2;
+        f_1 = f_2;
+        s_1 = s_2;
+        chunk_1 = chunk_2;
+        idx_1 = idx_2;
+        len_1 = len_2;
+        continue;
+      } else {
+        return [s1, tsplus_module_2.drop_(chunk_1, idx_1 + 1)];
+      }
+    }
+  }
+}
+
+function foldReader(s, contFn, f) {
+  if (!contFn(s)) {
+    return tsplus_module_5.succeedNow(s);
+  } else {
+    return tsplus_module_4.readWith(inp => {
+      const [nextS, leftovers] = foldChunkSplit(contFn, f, s, inp, 0, inp.length);
+
+      if (tsplus_module_2.isNonEmpty(leftovers)) {
+        return tsplus_module_4.as_(tsplus_module_4.writeNow(leftovers), () => nextS);
+      } else {
+        return foldReader(nextS, contFn, f);
+      }
+    }, _ => tsplus_module_4.failNow(_), _ => tsplus_module_5.succeedNow(_));
+  }
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldUntil
+ */
+
+
+function makeFoldUntil_1(z, max, f, __tsplusTrace) {
+  return unwrap_1(() => tsplus_module_9.map_(tsplus_module_9.succeed(max, __tsplusTrace), max => map_1(makeFold_1(() => [z(), 0], ([_, n]) => n < max, ([o, count], i) => [f(o, i), count + 1], __tsplusTrace), ([s]) => s, __tsplusTrace), __tsplusTrace));
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldChunks
+ */
+
+
+function makeFoldChunks_1(z, contFn, f) {
+  return defer_1(() => new tsplus_module_3.Sink(foldChunksReader(z(), contFn, f)));
+}
+
+function foldChunksReader(s, contFn, f) {
+  if (!contFn(s)) {
+    return tsplus_module_5.succeedNow(s);
+  } else {
+    return tsplus_module_4.readWith(inp => {
+      const nextS = f(s, inp);
+      return foldChunksReader(nextS, contFn, f);
+    }, err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(_));
+  }
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldChunksIO
+ */
+
+
+function makeFoldChunksIO_1(z, contFn, f) {
+  return defer_1(() => new tsplus_module_3.Sink(foldChunksIOReader(z(), contFn, f)));
+}
+
+function foldChunksIOReader(s, contFn, f) {
+  if (!contFn(s)) {
+    return tsplus_module_5.succeedNow(s);
+  } else {
+    return tsplus_module_4.readWith(inp => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => f(s, inp)), s => foldChunksIOReader(s, contFn, f)), err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(_));
+  }
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldLeft
+ */
+
+
+function makeFoldLeft_1(z, f) {
+  return ignoreLeftover_1(makeFold_1(z, () => true, f, fileName_1 + ":772:19"), fileName_1 + ":772:37");
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldLeftChunks
+ */
+
+
+function makeFoldLeftChunks(z, f) {
+  return ignoreLeftover_1(makeFoldChunks_1(z, () => true, f), fileName_1 + ":782:43");
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldLeftChunksIO
+ */
+
+
+function makeFoldLeftChunksIO(z, f) {
+  return makeFoldChunksIO_1(z, () => true, f);
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldLeftIO
+ */
+
+
+function makeFoldLeftIO(z, f) {
+  return makeFoldIO_1(z, () => true, f);
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldIO
+ */
+
+
+function makeFoldIO_1(z, contFn, f) {
+  return defer_1(() => new tsplus_module_3.Sink(foldIOReader(z(), contFn, f)));
+}
+
+function foldChunkSplitIO(s, contFn, f, chunk, idx, len) {
+  if (idx === len) {
+    return tsplus_module_9.succeedNow([s, tsplus_module_14.nothing()], fileName_1 + ":822:25");
+  } else {
+    return tsplus_module_9.flatMap_(f(s, tsplus_module_2.unsafeGet_(chunk, idx)), s1 => {
+      if (contFn(s1)) {
+        return foldChunkSplitIO(s1, contFn, f, chunk, idx + 1, len);
+      } else {
+        return tsplus_module_9.succeedNow([s1, tsplus_module_14.just(tsplus_module_2.drop_(chunk, idx + 1))], fileName_1 + ":828:29");
+      }
+    }, fileName_1 + ":824:36");
+  }
+}
+
+function foldIOReader(s, contFn, f) {
+  if (!contFn(s)) {
+    return tsplus_module_5.succeedNow(s);
+  } else {
+    return tsplus_module_4.readWith(inp => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => foldChunkSplitIO(s, contFn, f, inp, 0, inp.length)), ([nextS, leftovers]) => tsplus_module_20.match_(leftovers, () => foldIOReader(nextS, contFn, f), l => tsplus_module_4.as_(tsplus_module_4.writeNow(l), () => nextS))), err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(_));
+  }
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldUntilIO
+ */
+
+
+function makeFoldUntilIO(z, max, f) {
+  return map_1(makeFoldIO_1(() => [z(), 0], ([_, n]) => n < max(), ([o, count], i) => tsplus_module_9.map_(f(o, i), s => [s, count + 1], fileName_1 + ":867:35")), ([s]) => s, fileName_1 + ":868:8");
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldWeightedDecompose
+ */
+
+
+function makeFoldWeightedDecompose_1(z, costFn, max, decompose, f) {
+  return defer_1(() => {
+    /**
+     * @tsplus tailRec
+     */
+    function fold(inp, s, max, dirty, cost, idx) {
+      if (idx === inp.length) {
+        return [s, cost, dirty, tsplus_module_1.empty()];
+      } else {
+        const elem = tsplus_module_2.unsafeGet_(inp, idx);
+        const total = cost + costFn(s, elem);
+
+        if (total <= max) {
+          return fold(inp, f(s, elem), max, true, total, idx + 1);
+        } else {
+          const decomposed = decompose(elem);
+
+          if (decomposed.length <= 1 && !dirty) {
+            return [f(s, elem), total, true, tsplus_module_2.drop_(inp, idx + 1)];
+          } else if (decomposed.length <= 1 && dirty) {
+            return [s, cost, dirty, tsplus_module_2.drop_(inp, idx)];
+          } else {
+            return fold(tsplus_module_2.concat_(decomposed, tsplus_module_2.drop_(inp, idx + 1)), s, max, dirty, cost, 0);
+          }
+        }
+      }
+    }
+
+    function go(s, cost, dirty, max) {
+      return tsplus_module_4.readWith(inp => {
+        const [nextS, nextCost, nextDirty, leftovers] = fold(inp, s, max, dirty, cost, 0);
+
+        if (tsplus_module_2.isNonEmpty(leftovers)) {
+          return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(nextS));
+        } else if (cost > max) {
+          return tsplus_module_5.succeedNow(nextS);
+        } else {
+          return go(nextS, nextCost, nextDirty, max);
+        }
+      }, err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(s));
+    }
+
+    return new tsplus_module_3.Sink(go(z(), 0, false, max()));
+  });
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldWeightedDecomposeIO
+ */
+
+
+function makeFoldWeightedDecomposeIO_1(z, costFn, max, decompose, f) {
+  return defer_1(() => {
+    function fold(inp, s, max, dirty, cost, idx) {
+      if (idx === inp.length) {
+        return tsplus_module_9.succeedNow([s, cost, dirty, tsplus_module_1.empty()], fileName_1 + ":961:29");
+      } else {
+        const elem = tsplus_module_2.unsafeGet_(inp, idx);
+        return tsplus_module_9.flatMap_(tsplus_module_9.map_(costFn(s, elem), _ => cost + _, fileName_1 + ":965:15"), total => {
+          if (total <= max) {
+            return tsplus_module_9.flatMap_(f(s, elem), s => fold(inp, s, max, true, total, idx + 1), fileName_1 + ":968:40");
+          } else {
+            return tsplus_module_9.flatMap_(decompose(elem), decomposed => {
+              if (decomposed.length <= 1 && !dirty) {
+                return tsplus_module_9.map_(f(s, elem), s => [s, total, true, tsplus_module_2.drop_(inp, idx + 1)], fileName_1 + ":972:40");
+              } else if (decomposed.length <= 1 && dirty) {
+                return tsplus_module_9.succeedNow([s, cost, dirty, tsplus_module_2.drop_(inp, idx)], fileName_1 + ":974:39");
+              } else {
+                return fold(tsplus_module_2.concat_(decomposed, tsplus_module_2.drop_(inp, idx + 1)), s, max, dirty, cost, 0);
+              }
+            }, fileName_1 + ":970:45");
+          }
+        }, fileName_1 + ":966:19");
+      }
+    }
+
+    function go(s, cost, dirty, max) {
+      return tsplus_module_4.readWith(inp => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => fold(inp, s, max, dirty, cost, 0)), ([nextS, nextCost, nextDirty, leftovers]) => {
+        if (tsplus_module_2.isNonEmpty(leftovers)) {
+          return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(leftovers), tsplus_module_5.succeedNow(nextS));
+        } else if (cost > max) {
+          return tsplus_module_5.succeedNow(nextS);
+        } else {
+          return go(nextS, nextCost, nextDirty, max);
+        }
+      }), err => tsplus_module_4.failNow(err), _ => tsplus_module_5.succeedNow(s));
+    }
+
+    return new tsplus_module_3.Sink(go(z(), 0, false, max()));
+  });
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldWeighted
+ */
+
+
+function makeFoldWeighted(z, costFn, max, f) {
+  return makeFoldWeightedDecompose_1(z, costFn, max, tsplus_module_22.single, f);
+}
+/**
+ * @tsplus static fncts.io.SinkOps foldWeightedIO
+ */
+
+
+function makeFoldWeightedIO(z, costFn, max, f) {
+  return makeFoldWeightedDecomposeIO_1(z, costFn, max, inp => tsplus_module_9.succeedNow(tsplus_module_22.single(inp), fileName_1 + ":1030:77"), f);
+}
+/**
+ * Transforms this sink's result.
+ *
+ * @tsplus fluent fncts.io.Sink map
+ */
+
+
+function map_1(self, f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.map_(self.channel, f));
+}
+/**
+ * Transforms the errors emitted by this sink using `f`.
+ *
+ * @tsplus fluent fncts.io.Sink mapError
+ */
+
+
+function mapError_(self, f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.mapError_(self.channel, f));
+}
+/**
+ * Effectfully transforms this sink's result.
+ *
+ * @tsplus fluent fncts.io.Sink mapIO
+ */
+
+
+function mapIO_1(self, f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.mapIO_(self.channel, f));
+}
+/**
+ * Runs this sink until it yields a result, then uses that result to create
+ * another sink from the provided function which will continue to run until it
+ * yields a result.
+ *
+ * This function essentially runs sinks in sequence.
+ *
+ * @tsplus fluent fncts.io.Sink matchSink
+ */
+
+
+function matchSink_1(self, onFailure, onSuccess, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.matchChannel_(tsplus_module_4.doneCollect(self.channel), e => onFailure(e).channel, ([leftovers, z]) => tsplus_module_4.defer(() => {
+    const leftoversRef = new _AtomicReference.AtomicReference(tsplus_module_2.filter_(leftovers, c => tsplus_module_2.isNonEmpty(c)));
+    const refReader = tsplus_module_5.flatMap_(tsplus_module_5.succeed(() => leftoversRef.getAndSet(tsplus_module_1.empty())), chunk => tsplus_module_4.writeChunk(chunk));
+    const passthrough = tsplus_module_4.id();
+    const continuationSink = tsplus_module_4.pipeTo_(tsplus_module_5.apSecond_(refReader, passthrough), onSuccess(z).channel);
+    return tsplus_module_5.flatMap_(tsplus_module_4.doneCollect(continuationSink), ([newLeftovers, z1]) => tsplus_module_5.apSecond_(tsplus_module_5.flatMap_(tsplus_module_5.succeed(() => leftoversRef.get), tsplus_module_4.writeChunk), tsplus_module_4.as_(tsplus_module_4.writeChunk(newLeftovers), () => z1)));
+  })));
+}
+/**
+ * @tsplus fluent fncts.io.Sink orElse
+ */
+
+
+function orElse(self, that, __tsplusTrace) {
+  return defer_1(() => new tsplus_module_3.Sink(tsplus_module_4.orElse_(self.channel, that().channel)));
+}
+/**
+ * @tsplus fluent fncts.io.Sink provideEnvironment
+ */
+
+
+function provideEnvironment(self, r, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.provideEnvironment_(self.channel, r));
+}
+/**
+ * @tsplus fluent fncts.io.Sink race
+ */
+
+
+function race(self, that) {
+  return map_1(raceBoth_1(self, that), result => tsplus_module_23.merge(result), fileName_1 + ":1136:33");
+}
+/**
+ * @tsplus fluent fncts.io.Sink raceBoth
+ */
+
+
+function raceBoth_1(self, that, capacity = () => 16) {
+  return raceWith_1(self, that, selfDone => tsplus_module_25.done(tsplus_module_9.map_(tsplus_module_9.fromExitNow(selfDone, fileName_1 + ":1149:52"), tsplus_module_24.left, fileName_1 + ":1149:66")), thatDone => tsplus_module_25.done(tsplus_module_9.map_(tsplus_module_9.fromExitNow(thatDone, fileName_1 + ":1150:52"), tsplus_module_24.right, fileName_1 + ":1150:66")), capacity, fileName_1 + ":1147:23");
+}
+/**
+ * @tsplus fluent fncts.io.Sink raceWith
+ */
+
+
+function raceWith_1(self, that, leftDone, rightDone, capacity = () => 16, __tsplusTrace) {
+  const scoped = tsplus_module_9.defer(() => {
+    const that0 = that();
+    const capacity0 = capacity();
+    return tsplus_module_9.flatMap_(tsplus_module_27.makeBounded(capacity()), hub => tsplus_module_9.flatMap_(tsplus_module_4.fromHubScoped(() => hub), c1 => tsplus_module_9.map_(tsplus_module_4.fromHubScoped(() => hub), c2 => {
+      const reader = tsplus_module_4.toHub(() => hub);
+      const writer = tsplus_module_26.mergeWith_(tsplus_module_4.pipeTo_(c1, self.channel), tsplus_module_4.pipeTo_(c2, that0.channel), leftDone, rightDone);
+      const channel = tsplus_module_26.mergeWith_(reader, writer, () => tsplus_module_25.wait(tsplus_module_9.fromExitNow), done => tsplus_module_25.done(tsplus_module_9.fromExitNow(done, __tsplusTrace)));
+      return new tsplus_module_3.Sink(channel);
+    }, __tsplusTrace), __tsplusTrace), __tsplusTrace);
+  }, __tsplusTrace);
+  return unwrapScoped_1(() => scoped);
+}
+/**
+ * @tsplus static fncts.io.SinkOps service
+ */
+
+
+function service(
+/** @tsplus auto */
+tag) {
+  const tag_1 = tag;
+  return serviceWith_1(tsplus_module_12.identity, tag_1);
+}
+/**
+ * @tsplus static fncts.io.SinkOps serviceWith
+ */
+
+
+function serviceWith_1(f,
+/** @tsplus auto */
+tag) {
+  return fromIO_1(() => tsplus_module_11.serviceWith(f, tag));
+}
+/**
+ * @tsplus static fncts.io.SinkOps serviceWithIO
+ */
+
+
+function serviceWithIO(f,
+/** @tsplus auto */
+tag) {
+  return fromIO_1(() => tsplus_module_11.serviceWithIO(f, tag, fileName_1 + ":1210:38"));
+}
+/**
+ * @tsplus static fncts.io.SinkOps serviceWithSink
+ */
+
+
+function serviceWithSink(f,
+/** @tsplus auto */
+tag) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_11.serviceWith(tsplus_module_12.compose_(f, s => s.channel), tag)));
+}
+/**
+ * @tsplus fluent fncts.io.Sink splitWhere
+ */
+
+
+function splitWhere(self, p) {
+  return new tsplus_module_3.Sink(tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_8.make(() => tsplus_module_1.empty())), ref => tsplus_module_5.flatMap_(tsplus_module_4.collectElements(tsplus_module_4.pipeToOrFail_(splitter(p, false, ref), self.channel)), ([leftovers, z]) => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => tsplus_module_7.get(ref)), leftover => tsplus_module_5.apSecond_(tsplus_module_4.writeNow(tsplus_module_2.concat_(leftover, tsplus_module_2.flatten(leftovers))), tsplus_module_5.succeedNow(z))))));
+}
+
+function splitter(p, written, leftovers) {
+  return tsplus_module_4.readWithCause(inp => {
+    if (tsplus_module_2.isEmpty(inp)) {
+      return splitter(p, written, leftovers);
+    } else if (written) {
+      const index = tsplus_module_28.findIndex(inp, p);
+
+      if (index === -1) {
+        return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), splitter(p, true, leftovers));
+      } else {
+        const [left, right] = tsplus_module_2.splitAt_(inp, index);
+        return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(left), tsplus_module_4.fromIO(() => tsplus_module_6.set_(leftovers, right)));
+      }
+    } else {
+      const index = tsplus_module_28.findIndex(inp, p);
+
+      if (index === -1) {
+        return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(inp), splitter(p, true, leftovers));
+      } else {
+        const [left, right] = tsplus_module_2.splitAt_(inp, Math.max(index, 1));
+        return tsplus_module_5.apSecond_(tsplus_module_4.writeNow(left), tsplus_module_4.fromIO(() => tsplus_module_6.set_(leftovers, right)));
+      }
+    }
+  }, tsplus_module_5.failCauseNow, tsplus_module_5.succeedNow);
+}
+/**
+ * @tsplus static fncts.io.SinkOps succeed
+ */
+
+
+function succeed(z, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.succeed(z));
+}
+/**
+ * @tsplus static fncts.io.SinkOps succeedNow
+ */
+
+
+function succeedNow(z, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_5.succeedNow(z));
+}
+/**
+ * @tsplus fluent fncts.io.Sink summarized
+ */
+
+
+function summarized_1(self, summary, f, __tsplusTrace) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_9.map_(tsplus_module_9.succeed(summary, __tsplusTrace), summary => tsplus_module_5.flatMap_(tsplus_module_4.fromIO(() => summary), start => tsplus_module_5.flatMap_(self.channel, done => tsplus_module_5.map_(tsplus_module_4.fromIO(() => summary), end => [done, f(start, end)]))), __tsplusTrace)));
+}
+/**
+ * @tsplus getter fncts.io.Sink timed
+ */
+
+
+function timed(self, __tsplusTrace) {
+  return summarized_1(self, () => tsplus_module_29.currentTime, (start, end) => tsplus_module_30.fromInterval(start, end), __tsplusTrace);
+}
+/**
+ * @tsplus static fncts.io.SinkOps unwrap
+ */
+
+
+function unwrap_1(io) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrap(() => tsplus_module_9.map_(io(), sink => sink.channel, fileName_1 + ":1332:42")));
+}
+/**
+ * Creates a sink produced from a scoped effect.
+ *
+ * @tsplus static fncts.io.SinkOps unwrapScoped
+ */
+
+
+function unwrapScoped_1(scoped) {
+  return new tsplus_module_3.Sink(tsplus_module_4.unwrapScoped(() => tsplus_module_9.map_(scoped(), sink => sink.channel, fileName_1 + ":1343:52")));
+}
+/**
+ * @tsplus fluent fncts.io.Sink zip
+ */
+
+
+function zip(self, that) {
+  return zipWith_1(() => self, that, tsplus_module_12.tuple);
+}
+/**
+ * @tsplus fluent fncts.io.Sink zipC
+ */
+
+
+function zipC(self, that) {
+  return zipWithC_1(() => self, that, tsplus_module_12.tuple);
+}
+/**
+ * Feeds inputs to this sink until it yields a result, then switches over to
+ * the provided sink until it yields a result, finally combining the two
+ * results with `f`.
+ *
+ * @tsplus fluent fncts.io.Sink zipWith
+ */
+
+
+function zipWith_1(self, that, f) {
+  return defer_1(() => flatMap_1(self(), z => map_1(that(), z1 => f(z, z1), fileName_1 + ":1378:53"), fileName_1 + ":1378:35"));
+}
+/**
+ * Runs both sinks in parallel on the input and combines the results using the
+ * provided function.
+ *
+ * @tsplus fluent fncts.io.Sink zipWithC
  */
 
 
-function foreachWhile_1(f) {
-  const process = tsplus_module_3.readWithCause(inp => foreachWhileLoop(f, inp, 0, inp.length, process), tsplus_module_2.failCauseNow, () => tsplus_module_3.unit);
-  return new tsplus_module_4.Sink(process);
+function zipWithC_1(self, that, f) {
+  return defer_1(() => raceWith_1(self(), () => that(), exit => tsplus_module_31.match_(exit, err => tsplus_module_25.done(tsplus_module_9.failCauseNow(err, fileName_1 + ":1397:54")), lz => tsplus_module_25.wait(exit => tsplus_module_31.match_(exit, cause => tsplus_module_9.failCauseNow(cause, fileName_1 + ":1401:43"), rz => tsplus_module_9.succeedNow(f(lz, rz), fileName_1 + ":1402:38")))), exit => tsplus_module_31.match_(exit, err => tsplus_module_25.done(tsplus_module_9.failCauseNow(err, fileName_1 + ":1408:54")), rz => tsplus_module_25.wait(exit => tsplus_module_31.match_(exit, cause => tsplus_module_9.failCauseNow(cause, fileName_1 + ":1412:43"), lz => tsplus_module_9.succeedNow(f(lz, rz), fileName_1 + ":1413:38"))))));
 }
 //# sourceMappingURL=api.cjs.map