🩹 fix: Make module and cjs build work.

Author: make-github-pseudonymous-again

src/asyncIterableChain.js

@@ -5,8 +5,36 @@
  * @param {AsyncIterable<AsyncIterable>} iterables - the input iterable of iterables.
  * @returns {AsyncIterable} The chain of the input iterables.
  */
-export default async function* asyncIterableChain(iterables) {
-	for await (const iterable of iterables) {
-		for await (const item of iterable) yield item;
+export default function asyncIterableChain(iterables) {
+	return new Chain(iterables);
+}
+
+export class Chain {
+	constructor(iterables) {
+		this.iterators = iterables[Symbol.asyncIterator]();
+		this.iterator = null;
+	}
+
+	async next() {
+		for (;;) {
+			if (this.iterator === null) {
+				// eslint-disable-next-line no-await-in-loop
+				const {done, value} = await this.iterators.next();
+				if (done) return {done: true};
+				this.iterator = value[Symbol.asyncIterator]();
+			}
+
+			// eslint-disable-next-line no-await-in-loop
+			const {done, value} = await this.iterator.next();
+			if (done) {
+				this.iterator = null;
+			} else {
+				return {done: false, value};
+			}
+		}
+	}
+
+	[Symbol.asyncIterator]() {
+		return this;
 	}
 }

src/asyncIterableMap.js

@@ -1,3 +1,5 @@
+import asyncIteratorMap from './asyncIteratorMap.js';
+
 /**
  * Utility function to apply a sync callable to each item of an async iterable.
  *
@@ -6,7 +8,6 @@
  * @param {AsyncIterable} iterable - The iterable to process.
  * @returns {AsyncIterable} The iterable of mapped values.
  */
-export default async function* asyncIterableMap(callable, iterable) {
-	// Should the callable also be async ?
-	for await (const item of iterable) yield callable(item);
+export default function asyncIterableMap(callable, iterable) {
+	return asyncIteratorMap(callable, iterable[Symbol.asyncIterator]());
 }

src/asyncIterableToArray.js

@@ -7,6 +7,13 @@
  */
 export default async function asyncIterableToArray(asyncIterable) {
 	const array = [];
-	for await (const item of asyncIterable) array.push(item);
+	const it = asyncIterable[Symbol.asyncIterator]();
+	for (;;) {
+		// eslint-disable-next-line no-await-in-loop
+		const {done, value} = await it.next();
+		if (done) break;
+		array.push(value);
+	}
+
 	return array;
 }

src/asyncIteratorMap.js

@@ -0,0 +1,17 @@
+/**
+ * Utility function to apply a sync callable to each item of an async iterator.
+ *
+ * @private
+ * @param {Function} callable - The callable to apply.
+ * @param {AsyncIterator} iterator - The iterator to process.
+ * @returns {AsyncIterator} The iterator of mapped values.
+ */
+export default async function* asyncIteratorMap(callable, iterator) {
+	// Should the callable also be async ?
+	for (;;) {
+		// eslint-disable-next-line no-await-in-loop
+		const {done, value} = await iterator.next();
+		if (done) break;
+		yield callable(value);
+	}
+}

src/exhaust.js

@@ -3,5 +3,10 @@
  * @param {Tape} tape - The tape to read from.
  */
 export default async function exhaust(tape) {
-	while ((await tape.read()) !== tape.eof); // eslint-disable-line no-await-in-loop
+	// While ((await tape.read()) !== tape.eof); // eslint-disable-line no-await-in-loop
+	for (;;) {
+		// eslint-disable-next-line no-await-in-loop
+		const token = await tape.read();
+		if (token === tape.eof) return;
+	}
 }

src/fromReadStream.js

@@ -1,16 +1,35 @@
 import fromAsyncIterable from './fromAsyncIterable.js';
 
+/**
+ * Converts a ReadStream iterator to an async iterable of tokens.
+ *
+ * @private
+ * @param {AsyncIterator} iterator - The ReadStream iterator to convert.
+ * @returns {AsyncIterable} The converted iterable.
+ */
+export async function* _fromReadStreamIterator(iterator) {
+	for (;;) {
+		// eslint-disable-next-line no-await-in-loop
+		const {done, value: chunk} = await iterator.next();
+		if (done) break;
+		const chunkIterator = chunk[Symbol.iterator]();
+		for (;;) {
+			const {done, value} = chunkIterator.next();
+			if (done) break;
+			yield value;
+		}
+	}
+}
+
 /**
  * Converts a ReadStream object to an async iterable of tokens.
  *
  * @private
  * @param {ReadStream} readStream - The ReadStream object to convert.
  * @returns {AsyncIterable} The converted iterable.
  */
-export async function* _fromReadStream(readStream) {
-	for await (const chunk of readStream) {
-		for (const piece of chunk) yield piece;
-	}
+export function _fromReadStream(readStream) {
+	return _fromReadStreamIterator(readStream[Symbol.asyncIterator]());
 }
 
 /**

src/split.js

@@ -1,3 +1,4 @@
+import assert from 'assert';
 import fromAsyncIterable from './fromAsyncIterable.js';
 import exhaust from './exhaust.js';
 
@@ -13,6 +14,38 @@ export default function split(tape, sep) {
 	return fromAsyncIterable(_split(tape, sep));
 }
 
+export class Group {
+	constructor(first, sep, tape) {
+		this.first = first;
+		this.sep = sep;
+		this.tape = tape;
+		this.state = 0;
+	}
+
+	async next() {
+		if (this.state === 0) {
+			this.state = 1;
+			return {done: false, value: this.first};
+		}
+
+		if (this.state === 1) {
+			const value = await this.tape.read();
+			if (value !== this.tape.eof && !this.sep.has(value))
+				return {done: false, value};
+			this.sep = null;
+			this.tape = null;
+			this.state = 2;
+			return {done: true};
+		}
+
+		return {done: true};
+	}
+
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+}
+
 /**
  * Same as {@link split}, but returns an iterable rather than a tape.
  *
@@ -21,32 +54,45 @@ export default function split(tape, sep) {
  * @param {Iterable} sep - An iterable of separators.
  * @returns {AsyncIterable} An iterable of tapes.
  */
-export async function* _split(tape, sep) {
-	const _sep = new Set(sep);
-
-	while (true) {
-		const token = await tape.read(); // eslint-disable-line no-await-in-loop
-
-		if (token === tape.eof) break;
-
-		if (_sep.has(token)) continue;
+export function _split(tape, sep) {
+	return new Split(tape, sep);
+}
 
-		const group = fromAsyncIterable(
-			(async function* () {
-				yield token;
+class Split {
+	constructor(tape, sep) {
+		this.tape = tape;
+		this.sep = new Set(sep);
+		this.group = null;
+		this.state = 0;
+		assert(!this.sep.has(this.tape.eof));
+	}
 
-				while (true) {
-					const token = await tape.read(); // eslint-disable-line no-await-in-loop
+	async next() {
+		if (this.state === 0) {
+			if (this.group !== null) await exhaust(this.group);
+			let token;
+			do {
+				// eslint-disable-next-line no-await-in-loop
+				token = await this.tape.read();
+			} while (this.sep.has(token));
 
-					if (_sep.has(token)) break;
+			if (token === this.tape.eof) {
+				this.tape = null;
+				this.sep = null;
+				this.group = null;
+				this.state = 1;
+				return {done: true};
+			}
 
-					yield token;
-				}
-			})(),
-		);
+			assert(!this.sep.has(token));
+			this.group = fromAsyncIterable(new Group(token, this.sep, this.tape));
+			return {done: false, value: this.group};
+		}
 
-		yield group;
+		return {done: true};
+	}
 
-		await exhaust(group); // eslint-disable-line no-await-in-loop
+	[Symbol.asyncIterator]() {
+		return this;
 	}
 }