@lodestar/reqresp 1.41.0-dev.ef310100c0 → 1.41.0-dev.f2caa915ab

package/src/utils/snappyUncompress.ts

@@ -2,96 +2,94 @@ import {uncompress} from "snappyjs";
 import {Uint8ArrayList} from "uint8arraylist";
 import {ChunkType, IDENTIFIER, UNCOMPRESSED_CHUNK_SIZE, crc} from "./snappyCommon.js";
 
-export class SnappyFramesUncompress {
-  private buffer = new Uint8ArrayList();
-
-  private state: UncompressState = {
-    foundIdentifier: false,
-  };
-
-  /**
-   * Accepts chunk of data containing some part of snappy frames stream
-   * @param chunk
-   * @return Buffer if there is one or more whole frames, null if it's partial
-   */
-  uncompress(chunk: Uint8ArrayList): Uint8ArrayList | null {
-    this.buffer.append(chunk);
-    const result = new Uint8ArrayList();
-    while (this.buffer.length > 0) {
-      if (this.buffer.length < 4) break;
+export function parseSnappyFrameHeader(header: Uint8Array): {type: ChunkType; frameSize: number} {
+  if (header.length !== 4) {
+    throw new Error("malformed input: incomplete frame header");
+  }
 
-      const type = getChunkType(this.buffer.get(0));
+  const type = getChunkType(header[0]);
+  const frameSize = header[1] + (header[2] << 8) + (header[3] << 16);
+  return {type, frameSize};
+}
 
-      if (!this.state.foundIdentifier && type !== ChunkType.IDENTIFIER) {
-        throw "malformed input: must begin with an identifier";
+export function decodeSnappyFrameData(type: ChunkType, frame: Uint8Array): Uint8Array | null {
+  switch (type) {
+    case ChunkType.IDENTIFIER: {
+      if (!Buffer.prototype.equals.call(frame, IDENTIFIER)) {
+        throw new Error("malformed input: bad identifier");
+      }
+      return null;
+    }
+    case ChunkType.PADDING:
+    case ChunkType.SKIPPABLE:
+      return null;
+    case ChunkType.COMPRESSED: {
+      if (frame.length < 4) {
+        throw new Error("malformed input: too short");
       }
 
-      const frameSize = getFrameSize(this.buffer, 1);
+      const checksum = frame.subarray(0, 4);
+      const data = frame.subarray(4);
+      const uncompressed = uncompress(data, UNCOMPRESSED_CHUNK_SIZE);
+      if (crc(uncompressed).compare(checksum) !== 0) {
+        throw new Error("malformed input: bad checksum");
+      }
+      return uncompressed;
+    }
+    case ChunkType.UNCOMPRESSED: {
+      if (frame.length < 4) {
+        throw new Error("malformed input: too short");
+      }
 
-      if (this.buffer.length - 4 < frameSize) {
-        break;
+      const checksum = frame.subarray(0, 4);
+      const uncompressed = frame.subarray(4);
+      if (uncompressed.length > UNCOMPRESSED_CHUNK_SIZE) {
+        throw new Error("malformed input: too large");
+      }
+      if (crc(uncompressed).compare(checksum) !== 0) {
+        throw new Error("malformed input: bad checksum");
       }
+      return uncompressed;
+    }
+  }
+}
 
-      const frame = this.buffer.subarray(4, 4 + frameSize);
-      this.buffer.consume(4 + frameSize);
+export function decodeSnappyFrames(data: Uint8Array): Uint8ArrayList {
+  const out = new Uint8ArrayList();
+  let foundIdentifier = false;
+  let offset = 0;
 
-      switch (type) {
-        case ChunkType.IDENTIFIER: {
-          if (!Buffer.prototype.equals.call(frame, IDENTIFIER)) {
-            throw "malformed input: bad identifier";
-          }
-          this.state.foundIdentifier = true;
-          continue;
-        }
-        case ChunkType.PADDING:
-        case ChunkType.SKIPPABLE:
-          continue;
-        case ChunkType.COMPRESSED: {
-          const checksum = frame.subarray(0, 4);
-          const data = frame.subarray(4);
+  while (offset < data.length) {
+    const remaining = data.length - offset;
+    if (remaining < 4) {
+      throw new Error("malformed input: incomplete frame header");
+    }
 
-          const uncompressed = uncompress(data, UNCOMPRESSED_CHUNK_SIZE);
-          if (crc(uncompressed).compare(checksum) !== 0) {
-            throw "malformed input: bad checksum";
-          }
-          result.append(uncompressed);
-          break;
-        }
-        case ChunkType.UNCOMPRESSED: {
-          const checksum = frame.subarray(0, 4);
-          const uncompressed = frame.subarray(4);
+    const {type, frameSize} = parseSnappyFrameHeader(data.subarray(offset, offset + 4));
+    if (!foundIdentifier && type !== ChunkType.IDENTIFIER) {
+      throw new Error("malformed input: must begin with an identifier");
+    }
 
-          if (uncompressed.length > UNCOMPRESSED_CHUNK_SIZE) {
-            throw "malformed input: too large";
-          }
-          if (crc(uncompressed).compare(checksum) !== 0) {
-            throw "malformed input: bad checksum";
-          }
-          result.append(uncompressed);
-          break;
-        }
-      }
+    offset += 4;
+
+    if (data.length - offset < frameSize) {
+      throw new Error("malformed input: incomplete frame");
     }
-    if (result.length === 0) {
-      return null;
+
+    const frame = data.subarray(offset, offset + frameSize);
+    offset += frameSize;
+
+    if (type === ChunkType.IDENTIFIER) {
+      foundIdentifier = true;
     }
-    return result;
-  }
 
-  reset(): void {
-    this.buffer = new Uint8ArrayList();
-    this.state = {
-      foundIdentifier: false,
-    };
+    const uncompressed = decodeSnappyFrameData(type, frame);
+    if (uncompressed !== null) {
+      out.append(uncompressed);
+    }
   }
-}
-
-type UncompressState = {
-  foundIdentifier: boolean;
-};
 
-function getFrameSize(buffer: Uint8ArrayList, offset: number): number {
-  return buffer.get(offset) + (buffer.get(offset + 1) << 8) + (buffer.get(offset + 2) << 16);
+  return out;
 }
 
 function getChunkType(value: number): ChunkType {

package/src/utils/stream.ts

@@ -0,0 +1,34 @@
+import type {Stream} from "@libp2p/interface";
+import {ByteStream} from "@libp2p/utils";
+import {Uint8ArrayList} from "uint8arraylist";
+import {ErrorAborted} from "@lodestar/utils";
+
+export async function sendChunks(
+  stream: Stream,
+  source: Iterable<Uint8Array | Uint8ArrayList> | AsyncIterable<Uint8Array | Uint8ArrayList>,
+  signal?: AbortSignal
+): Promise<void> {
+  for await (const chunk of source) {
+    if (signal?.aborted) {
+      throw new ErrorAborted("sendChunks");
+    }
+
+    if (!stream.send(chunk)) {
+      await stream.onDrain({signal});
+    }
+  }
+}
+
+export function drainByteStream(bytes: ByteStream<Stream>): Uint8Array | undefined {
+  const readBuffer = (
+    bytes as unknown as {
+      readBuffer?: {byteLength: number; subarray: () => Uint8Array; consume: (bytes: number) => void};
+    }
+  ).readBuffer;
+  if (readBuffer && readBuffer.byteLength > 0) {
+    const drained = readBuffer.subarray();
+    readBuffer.consume(readBuffer.byteLength);
+    return drained;
+  }
+  return undefined;
+}

package/lib/utils/abortableSource.d.ts

@@ -1,12 +0,0 @@
-/**
- * Wraps an AsyncIterable and rejects early if any signal aborts.
- * Throws the error returned by `getError()` of each signal options.
- *
- * Simplified fork of `"abortable-iterator"`.
- * Read function's source for reasoning of the fork.
- */
-export declare function abortableSource<T>(sourceArg: AsyncIterable<T>, signals: {
-    signal: AbortSignal;
-    getError: () => Error;
-}[]): AsyncIterable<T>;
-//# sourceMappingURL=abortableSource.d.ts.map

package/lib/utils/abortableSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abortableSource.d.ts","sourceRoot":"","sources":["../../src/utils/abortableSource.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE;IACP,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,KAAK,CAAC;CACvB,EAAE,GACF,aAAa,CAAC,CAAC,CAAC,CAkElB"}

package/lib/utils/abortableSource.js

@@ -1,69 +0,0 @@
-/**
- * Wraps an AsyncIterable and rejects early if any signal aborts.
- * Throws the error returned by `getError()` of each signal options.
- *
- * Simplified fork of `"abortable-iterator"`.
- * Read function's source for reasoning of the fork.
- */
-export function abortableSource(sourceArg, signals) {
-    const source = sourceArg;
-    async function* abortable() {
-        // Handler that will hold a reference to the `abort()` promise,
-        // necessary for the signal abort listeners to reject the iterable promise
-        let nextAbortHandler = null;
-        // For each signal register an abortHandler(), and prepare clean-up with `onDoneCbs`
-        const onDoneCbs = [];
-        for (const { signal, getError } of signals) {
-            const abortHandler = () => {
-                if (nextAbortHandler)
-                    nextAbortHandler(getError());
-            };
-            signal.addEventListener("abort", abortHandler);
-            onDoneCbs.push(() => {
-                signal.removeEventListener("abort", abortHandler);
-            });
-        }
-        try {
-            while (true) {
-                // Abort early if any signal is aborted
-                for (const { signal, getError } of signals) {
-                    if (signal.aborted) {
-                        throw getError();
-                    }
-                }
-                // Race the iterator and the abort signals
-                const result = await Promise.race([
-                    new Promise((_, reject) => {
-                        nextAbortHandler = (error) => reject(error);
-                    }),
-                    source.next(),
-                ]);
-                // source.next() resolved first
-                nextAbortHandler = null;
-                if (result.done) {
-                    return;
-                }
-                yield result.value;
-            }
-        }
-        catch (err) {
-            // End the iterator if it is a generator
-            if (typeof source.return === "function") {
-                // This source.return() function may never resolve depending on the source AsyncGenerator implementation.
-                // This is the main reason to fork "abortable-iterator", which caused our node to get stuck during Sync.
-                // We choose to call .return() but not await it. In general, source.return should never throw. If it does,
-                // it a problem of the source implementor, and thus logged as an unhandled rejection. If that happens,
-                // the source implementor should fix the upstream code.
-                void source.return(null);
-            }
-            throw err;
-        }
-        finally {
-            for (const cb of onDoneCbs) {
-                cb();
-            }
-        }
-    }
-    return abortable();
-}
-//# sourceMappingURL=abortableSource.js.map

package/lib/utils/abortableSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abortableSource.js","sourceRoot":"","sources":["../../src/utils/abortableSource.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,SAA2B,EAC3B,OAGG;IAEH,MAAM,MAAM,GAAG,SAA8B,CAAC;IAE9C,KAAK,SAAS,CAAC,CAAC,SAAS;QACvB,+DAA+D;QAC/D,0EAA0E;QAC1E,IAAI,gBAAgB,GAAoC,IAAI,CAAC;QAE7D,oFAAoF;QACpF,MAAM,SAAS,GAAmB,EAAE,CAAC;QACrC,KAAK,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,IAAI,OAAO,EAAE,CAAC;YACzC,MAAM,YAAY,GAAG,GAAS,EAAE;gBAC9B,IAAI,gBAAgB;oBAAE,gBAAgB,CAAC,QAAQ,EAAE,CAAC,CAAC;YACrD,CAAC,CAAC;YACF,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YAC/C,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE;gBAClB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;YACpD,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC;YACH,OAAO,IAAI,EAAE,CAAC;gBACZ,uCAAuC;gBACvC,KAAK,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,IAAI,OAAO,EAAE,CAAC;oBACzC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;wBACnB,MAAM,QAAQ,EAAE,CAAC;oBACnB,CAAC;gBACH,CAAC;gBAED,0CAA0C;gBAC1C,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC;oBAChC,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;wBAC/B,gBAAgB,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC9C,CAAC,CAAC;oBACF,MAAM,CAAC,IAAI,EAAE;iBACd,CAAC,CAAC;gBAEH,+BAA+B;gBAC/B,gBAAgB,GAAG,IAAI,CAAC;gBAExB,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;oBAChB,OAAO;gBACT,CAAC;gBAED,MAAM,MAAM,CAAC,KAAK,CAAC;YACrB,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,wCAAwC;YACxC,IAAI,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;gBACxC,yGAAyG;gBACzG,wGAAwG;gBACxG,0GAA0G;gBAC1G,sGAAsG;gBACtG,uDAAuD;gBACvD,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;YAED,MAAM,GAAG,CAAC;QACZ,CAAC;gBAAS,CAAC;YACT,KAAK,MAAM,EAAE,IAAI,SAAS,EAAE,CAAC;gBAC3B,EAAE,EAAE,CAAC;YACP,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,SAAS,EAAE,CAAC;AACrB,CAAC"}

package/lib/utils/bufferedSource.d.ts

@@ -1,16 +0,0 @@
-import { Uint8ArrayList } from "uint8arraylist";
-/**
- * Wraps a buffer chunk stream source with another async iterable
- * so it can be reused in multiple for..of statements.
- *
- * Uses a BufferList internally to make sure all chunks are consumed
- * when switching consumers
- */
-export declare class BufferedSource {
-    isDone: boolean;
-    private buffer;
-    private source;
-    constructor(source: AsyncGenerator<Uint8ArrayList | Uint8Array>);
-    [Symbol.asyncIterator](): AsyncIterator<Uint8ArrayList>;
-}
-//# sourceMappingURL=bufferedSource.d.ts.map

package/lib/utils/bufferedSource.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bufferedSource.d.ts","sourceRoot":"","sources":["../../src/utils/bufferedSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAE9C;;;;;;GAMG;AACH,qBAAa,cAAc;IACzB,MAAM,UAAS;IACf,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAA8C;gBAEhD,MAAM,EAAE,cAAc,CAAC,cAAc,GAAG,UAAU,CAAC;IAK/D,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,cAAc,CAAC;CA0BxD"}

package/lib/utils/bufferedSource.js

@@ -1,40 +0,0 @@
-import { Uint8ArrayList } from "uint8arraylist";
-/**
- * Wraps a buffer chunk stream source with another async iterable
- * so it can be reused in multiple for..of statements.
- *
- * Uses a BufferList internally to make sure all chunks are consumed
- * when switching consumers
- */
-export class BufferedSource {
-    isDone = false;
-    buffer;
-    source;
-    constructor(source) {
-        this.buffer = new Uint8ArrayList();
-        this.source = source;
-    }
-    [Symbol.asyncIterator]() {
-        const that = this;
-        let firstNext = true;
-        return {
-            async next() {
-                // Prevent fetching a new chunk if there are pending bytes
-                // not processed by a previous consumer of this BufferedSource
-                if (firstNext && that.buffer.length > 0) {
-                    firstNext = false;
-                    return { done: false, value: that.buffer };
-                }
-                const { done, value: chunk } = await that.source.next();
-                if (done === true) {
-                    that.isDone = true;
-                    return { done: true, value: undefined };
-                }
-                // Concat new chunk and return a reference to its BufferList instance
-                that.buffer.append(chunk);
-                return { done: false, value: that.buffer };
-            },
-        };
-    }
-}
-//# sourceMappingURL=bufferedSource.js.map

package/lib/utils/bufferedSource.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bufferedSource.js","sourceRoot":"","sources":["../../src/utils/bufferedSource.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IACzB,MAAM,GAAG,KAAK,CAAC;IACP,MAAM,CAAiB;IACvB,MAAM,CAA8C;IAE5D,YAAY,MAAmD;QAC7D,IAAI,CAAC,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,CAAC,MAAM,CAAC,aAAa,CAAC;QACpB,MAAM,IAAI,GAAG,IAAI,CAAC;QAElB,IAAI,SAAS,GAAG,IAAI,CAAC;QAErB,OAAO;YACL,KAAK,CAAC,IAAI;gBACR,0DAA0D;gBAC1D,8DAA8D;gBAC9D,IAAI,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACxC,SAAS,GAAG,KAAK,CAAC;oBAClB,OAAO,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC;gBAC3C,CAAC;gBAED,MAAM,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACtD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;oBACnB,OAAO,EAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAC,CAAC;gBACxC,CAAC;gBAED,qEAAqE;gBACrE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1B,OAAO,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC;YAC3C,CAAC;SACF,CAAC;IACJ,CAAC;CACF"}

package/lib/utils/onChunk.d.ts

@@ -1,6 +0,0 @@
-/**
- * Calls `callback` with each `chunk` received from the `source` AsyncIterable
- * Useful for logging, or cancelling timeouts
- */
-export declare function onChunk<T>(callback: (chunk: T) => void): (source: AsyncIterable<T>) => AsyncIterable<T>;
-//# sourceMappingURL=onChunk.d.ts.map

package/lib/utils/onChunk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"onChunk.d.ts","sourceRoot":"","sources":["../../src/utils/onChunk.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,CAOvG"}

package/lib/utils/onChunk.js

@@ -1,13 +0,0 @@
-/**
- * Calls `callback` with each `chunk` received from the `source` AsyncIterable
- * Useful for logging, or cancelling timeouts
- */
-export function onChunk(callback) {
-    return async function* onChunkTransform(source) {
-        for await (const chunk of source) {
-            callback(chunk);
-            yield chunk;
-        }
-    };
-}
-//# sourceMappingURL=onChunk.js.map

package/lib/utils/onChunk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"onChunk.js","sourceRoot":"","sources":["../../src/utils/onChunk.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,OAAO,CAAI,QAA4B;IACrD,OAAO,KAAK,SAAS,CAAC,CAAC,gBAAgB,CAAC,MAAM;QAC5C,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YACjC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAChB,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/lib/utils/snappy.d.ts

@@ -1,3 +0,0 @@
-export { compressSync as compress } from "snappy";
-export { uncompress } from "snappyjs";
-//# sourceMappingURL=snappy.d.ts.map

package/lib/utils/snappy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"snappy.d.ts","sourceRoot":"","sources":["../../src/utils/snappy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,IAAI,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAChD,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC"}

package/lib/utils/snappy.js

@@ -1,3 +0,0 @@
-export { compressSync as compress } from "snappy";
-export { uncompress } from "snappyjs";
-//# sourceMappingURL=snappy.js.map

package/lib/utils/snappy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"snappy.js","sourceRoot":"","sources":["../../src/utils/snappy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,IAAI,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAChD,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC"}

package/src/utils/abortableSource.ts

@@ -1,80 +0,0 @@
-/**
- * Wraps an AsyncIterable and rejects early if any signal aborts.
- * Throws the error returned by `getError()` of each signal options.
- *
- * Simplified fork of `"abortable-iterator"`.
- * Read function's source for reasoning of the fork.
- */
-export function abortableSource<T>(
-  sourceArg: AsyncIterable<T>,
-  signals: {
-    signal: AbortSignal;
-    getError: () => Error;
-  }[]
-): AsyncIterable<T> {
-  const source = sourceArg as AsyncGenerator<T>;
-
-  async function* abortable(): AsyncIterable<T> {
-    // Handler that will hold a reference to the `abort()` promise,
-    // necessary for the signal abort listeners to reject the iterable promise
-    let nextAbortHandler: ((error: Error) => void) | null = null;
-
-    // For each signal register an abortHandler(), and prepare clean-up with `onDoneCbs`
-    const onDoneCbs: (() => void)[] = [];
-    for (const {signal, getError} of signals) {
-      const abortHandler = (): void => {
-        if (nextAbortHandler) nextAbortHandler(getError());
-      };
-      signal.addEventListener("abort", abortHandler);
-      onDoneCbs.push(() => {
-        signal.removeEventListener("abort", abortHandler);
-      });
-    }
-
-    try {
-      while (true) {
-        // Abort early if any signal is aborted
-        for (const {signal, getError} of signals) {
-          if (signal.aborted) {
-            throw getError();
-          }
-        }
-
-        // Race the iterator and the abort signals
-        const result = await Promise.race([
-          new Promise<never>((_, reject) => {
-            nextAbortHandler = (error) => reject(error);
-          }),
-          source.next(),
-        ]);
-
-        // source.next() resolved first
-        nextAbortHandler = null;
-
-        if (result.done) {
-          return;
-        }
-
-        yield result.value;
-      }
-    } catch (err) {
-      // End the iterator if it is a generator
-      if (typeof source.return === "function") {
-        // This source.return() function may never resolve depending on the source AsyncGenerator implementation.
-        // This is the main reason to fork "abortable-iterator", which caused our node to get stuck during Sync.
-        // We choose to call .return() but not await it. In general, source.return should never throw. If it does,
-        // it a problem of the source implementor, and thus logged as an unhandled rejection. If that happens,
-        // the source implementor should fix the upstream code.
-        void source.return(null);
-      }
-
-      throw err;
-    } finally {
-      for (const cb of onDoneCbs) {
-        cb();
-      }
-    }
-  }
-
-  return abortable();
-}

package/src/utils/bufferedSource.ts

@@ -1,46 +0,0 @@
-import {Uint8ArrayList} from "uint8arraylist";
-
-/**
- * Wraps a buffer chunk stream source with another async iterable
- * so it can be reused in multiple for..of statements.
- *
- * Uses a BufferList internally to make sure all chunks are consumed
- * when switching consumers
- */
-export class BufferedSource {
-  isDone = false;
-  private buffer: Uint8ArrayList;
-  private source: AsyncGenerator<Uint8ArrayList | Uint8Array>;
-
-  constructor(source: AsyncGenerator<Uint8ArrayList | Uint8Array>) {
-    this.buffer = new Uint8ArrayList();
-    this.source = source;
-  }
-
-  [Symbol.asyncIterator](): AsyncIterator<Uint8ArrayList> {
-    const that = this;
-
-    let firstNext = true;
-
-    return {
-      async next() {
-        // Prevent fetching a new chunk if there are pending bytes
-        // not processed by a previous consumer of this BufferedSource
-        if (firstNext && that.buffer.length > 0) {
-          firstNext = false;
-          return {done: false, value: that.buffer};
-        }
-
-        const {done, value: chunk} = await that.source.next();
-        if (done === true) {
-          that.isDone = true;
-          return {done: true, value: undefined};
-        }
-
-        // Concat new chunk and return a reference to its BufferList instance
-        that.buffer.append(chunk);
-        return {done: false, value: that.buffer};
-      },
-    };
-  }
-}

package/src/utils/onChunk.ts

@@ -1,12 +0,0 @@
-/**
- * Calls `callback` with each `chunk` received from the `source` AsyncIterable
- * Useful for logging, or cancelling timeouts
- */
-export function onChunk<T>(callback: (chunk: T) => void): (source: AsyncIterable<T>) => AsyncIterable<T> {
-  return async function* onChunkTransform(source) {
-    for await (const chunk of source) {
-      callback(chunk);
-      yield chunk;
-    }
-  };
-}

package/src/utils/snappy.ts

@@ -1,2 +0,0 @@
-export {compressSync as compress} from "snappy";
-export {uncompress} from "snappyjs";