async-lube 2.0.0 → 2.1.0

package/src/stream.js

@@ -28,11 +28,6 @@ export function buffer(source, ms) {
 	let failure
 	let finished = false
 	const due = create_due(ms)
-	function finish() {
-		finished = true
-		due.clear()
-		if (reader) release(reader)
-	}
 	return {
 		[Symbol.asyncIterator]() {
 			return reader || finished ? buffer(source, ms) : this
@@ -43,7 +38,9 @@ export function buffer(source, ms) {
 				failure = void 0
 				throw error
 			}
-			if (finished) return { done: true, value: void 0 }
+			if (finished) {
+				return { done: true, value: void 0 }
+			}
 			try {
 				reader ??= /** @type {AsyncIterator<T>} */(to_reader(source))/**/
 				for (;;) {
@@ -52,7 +49,9 @@ export function buffer(source, ms) {
 					const step = await Promise.race(
 						racing ? [ next, racing ] : [ next ]
 					)
-					if (finished) return { done: true, value: void 0 }
+					if (finished) {
+						return { done: true, value: void 0 }
+					}
 					if (step == "due" || racing && due.fired) {
 						const full = batch
 						batch = []
@@ -66,12 +65,18 @@ export function buffer(source, ms) {
 						return full.length ? { done: false, value: full } : { done: true, value: void 0 }
 					}
 					batch.push(step.value)
-					if (!due.promise) due.start()
+					if (!due.promise) {
+						due.start()
+					}
 				}
 			} catch (error) {
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				finish()
-				if (!batch.length) throw error
+				if (!batch.length) {
+					throw error
+				}
 				const full = batch
 				batch = []
 				failure = { error }
@@ -80,10 +85,20 @@ export function buffer(source, ms) {
 		},
 		async return() {
 			failure = void 0
-			if (!finished) finish()
+			if (!finished) {
+				finish()
+			}
 			return { done: true, value: void 0 }
 		}
 	}
+	/** @returns {void} */
+	function finish() {
+		finished = true
+		due.clear()
+		if (reader) {
+			release(reader)
+		}
+	}
 }
 /**
  * @param {unknown} value
@@ -91,10 +106,15 @@ export function buffer(source, ms) {
  */
 function cancel_result(value) {
 	const result = /** @type {{ cancel?: unknown } | null | undefined} */(value)/**/
-	if (typeof result?.cancel != "function") return
+	if (typeof result?.cancel != "function") {
+		return
+	}
 	try {
 		const cancelled = /** @type {{ cancel: () => unknown }} */(result)/**/.cancel()
-		if (typeof /** @type {Partial<PromiseLike<unknown>>} */(cancelled)/**/?.then == "function") /** @type {PromiseLike<unknown>} */(cancelled)/**/.then(noop, noop)
+		if (typeof /** @type {Partial<PromiseLike<unknown>>} */(cancelled)/**/?.then == "function") {
+			const pending = /** @type {PromiseLike<unknown>} */(cancelled)/**/
+			pending.then(noop, noop)
+		}
 	} catch {}
 }
 /**
@@ -103,7 +123,9 @@ function cancel_result(value) {
  * @returns {void}
  */
 function check_limit(limit, kind) {
-	if (limit == null || limit === Infinity || Number.isInteger(limit) && /** @type {number} */(limit)/**/ >= 1) return
+	if (limit == null || limit === Infinity || Number.isInteger(limit) && /** @type {number} */(limit)/**/ >= 1) {
+		return
+	}
 	throw TypeError(
 		`The limit of ${kind}() must be a positive integer or Infinity`
 	)
@@ -114,7 +136,9 @@ function check_limit(limit, kind) {
  * @returns {void}
  */
 function check_ms(ms, kind) {
-	if (typeof ms == "number" && ms >= 0) return
+	if (typeof ms == "number" && ms >= 0) {
+		return
+	}
 	throw TypeError(
 		`${kind}() needs a non-negative number of milliseconds`
 	)
@@ -136,8 +160,9 @@ function create_channel(options = {}) {
 		"initial" in options ? { value: options.initial } : void 0
 	)
 	const { signal } = options
-	if (signal?.aborted) source.close()
-	else if (signal) {
+	if (signal?.aborted) {
+		source.close()
+	} else if (signal) {
 		on_abort(signal, () => source.close())
 	}
 	return {
@@ -150,9 +175,11 @@ function create_channel(options = {}) {
 		send: value => source.write(value)
 	}
 }
-export const channel = /** @type {import("../public.js").ChannelFunction} */(create_channel)/**/
+/** @type {import("../public.js").ChannelFunction} */
+export const channel = create_channel
 /**
  * @param {number} ms
+ * @returns {{ clear(): void; fired: boolean; promise: Promise<"due"> | undefined; start(): void; }}
  */
 function create_due(ms) {
 	const delay = clamp_delay(ms)
@@ -160,12 +187,6 @@ function create_due(ms) {
 	let resolve
 	/** @type {ReturnType<typeof setTimeout> | undefined} */
 	let timer
-	function fire() {
-		const settle = /** @type {(value: "due") => void} */(resolve)/**/
-		due.clear()
-		due.fired = true
-		settle("due")
-	}
 	const due = {
 		clear() {
 			clearTimeout(timer)
@@ -188,6 +209,13 @@ function create_due(ms) {
 		}
 	}
 	return due
+	/** @returns {void} */
+	function fire() {
+		const settle = /** @type {(value: "due") => void} */(resolve)/**/
+		due.clear()
+		due.fired = true
+		settle("due")
+	}
 }
 /**
  * @param {number=} limit
@@ -203,20 +231,6 @@ function create_source(
 	let ended = false
 	/** @type {{ value: unknown } | undefined} */
 	let failure
-	/**
-	 * @param {{ value: unknown }=} error
-	 * @returns {void}
-	 */
-	function finish(error) {
-		if (ended) return
-		ended = true
-		failure = error
-		for (const loop of loops) {
-			loop.ended = true
-			loop.error = error
-			loop.wake?.()
-		}
-	}
 	return {
 		close: () => finish(void 0),
 		get ended() {
@@ -234,16 +248,6 @@ function create_source(
 			}
 			let finished = false
 			let started = false
-			/** @returns {IteratorResult<unknown>} */
-			function stop() {
-				if (!finished) {
-					finished = true
-					const left = loops.delete(loop)
-					loop.wake?.()
-					if (left && !loops.size) on_last?.()
-				}
-				return { done: true, value: void 0 }
-			}
 			return {
 				[Symbol.asyncIterator]() {
 					return this
@@ -255,12 +259,23 @@ function create_source(
 						loop.error = failure
 						if (!ended) {
 							loops.add(loop)
-							if (current) loop.buffer.push(current.value)
-							if (loops.size == 1) on_first?.()
+							if (current) {
+								loop.buffer.push(current.value)
+							}
+							if (loops.size == 1) {
+								try {
+									on_first?.()
+								} catch (error) {
+									stop()
+									throw error
+								}
+							}
 						}
 					}
 					for (;;) {
-						if (finished) return { done: true, value: void 0 }
+						if (finished) {
+							return { done: true, value: void 0 }
+						}
 						if (loop.head < loop.buffer.length) {
 							const value = loop.buffer[loop.head]
 							loop.buffer[loop.head++] = void 0
@@ -278,7 +293,9 @@ function create_source(
 							stop()
 							throw value
 						}
-						if (loop.ended) return stop()
+						if (loop.ended) {
+							return stop()
+						}
 						await new Promise(
 							resolve => {
 								loop.wake = () => resolve(void 0)
@@ -291,10 +308,26 @@ function create_source(
 					return stop()
 				}
 			}
+			/** @returns {IteratorResult<unknown>} */
+			function stop() {
+				if (!finished) {
+					finished = true
+					const left = loops.delete(loop)
+					loop.wake?.()
+					if (left && !loops.size) {
+						on_last?.()
+					}
+				}
+				return { done: true, value: void 0 }
+			}
 		},
 		write(value) {
-			if (ended) return
-			if (current) current.value = value
+			if (ended) {
+				return
+			}
+			if (current) {
+				current.value = value
+			}
 			for (const loop of loops) {
 				loop.buffer.push(value)
 				if (loop.buffer.length - loop.head > limit) {
@@ -308,6 +341,22 @@ function create_source(
 			}
 		}
 	}
+	/**
+	 * @param {{ value: unknown }=} error
+	 * @returns {void}
+	 */
+	function finish(error) {
+		if (ended) {
+			return
+		}
+		ended = true
+		failure = error
+		for (const loop of loops) {
+			loop.ended = true
+			loop.error = error
+			loop.wake?.()
+		}
+	}
 }
 /**
  * Yields the last value of every quiet window of the milliseconds, like the `debounce` of a request.
@@ -329,11 +378,6 @@ export function debounce(source, ms) {
 	let held
 	let finished = false
 	const due = create_due(ms)
-	function finish() {
-		finished = true
-		due.clear()
-		if (reader) release(reader)
-	}
 	return {
 		[Symbol.asyncIterator]() {
 			return reader || finished ? debounce(source, ms) : this
@@ -344,7 +388,9 @@ export function debounce(source, ms) {
 				failure = void 0
 				throw error
 			}
-			if (finished) return { done: true, value: void 0 }
+			if (finished) {
+				return { done: true, value: void 0 }
+			}
 			try {
 				reader ??= /** @type {AsyncIterator<T>} */(to_reader(source))/**/
 				for (;;) {
@@ -353,7 +399,9 @@ export function debounce(source, ms) {
 					const step = await Promise.race(
 						racing ? [ next, racing ] : [ next ]
 					)
-					if (finished) return { done: true, value: void 0 }
+					if (finished) {
+						return { done: true, value: void 0 }
+					}
 					if (step == "due" || racing && due.fired) {
 						const { value } = /** @type {{ value: T }} */(held)/**/
 						held = void 0
@@ -370,10 +418,14 @@ export function debounce(source, ms) {
 					due.start()
 				}
 			} catch (error) {
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				finish()
 				const last = held
-				if (!last) throw error
+				if (!last) {
+					throw error
+				}
 				held = void 0
 				failure = { error }
 				return { done: false, value: last.value }
@@ -381,10 +433,20 @@ export function debounce(source, ms) {
 		},
 		async return() {
 			failure = void 0
-			if (!finished) finish()
+			if (!finished) {
+				finish()
+			}
 			return { done: true, value: void 0 }
 		}
 	}
+	/** @returns {void} */
+	function finish() {
+		finished = true
+		due.clear()
+		if (reader) {
+			release(reader)
+		}
+	}
 }
 /**
  * Counts every period of the milliseconds, 1, 2, 3, for polling and jobs. A loop that takes longer than a period gets
@@ -397,9 +459,11 @@ export function debounce(source, ms) {
  * @returns {AsyncIterable<number>}
  */
 export function every(ms, options = {}) {
-	if (!(typeof ms == "number" && ms > 0)) throw TypeError(
-		"every() needs a positive number of milliseconds"
-	)
+	if (!(typeof ms == "number" && ms > 0)) {
+		throw TypeError(
+			"every() needs a positive number of milliseconds"
+		)
+	}
 	check_options(
 		options,
 		[ "immediate", "signal" ],
@@ -413,21 +477,14 @@ export function every(ms, options = {}) {
 			let finished = false
 			const controller = new AbortController()
 			const unlink = link_signal(controller, signal)
-			/** @returns {IteratorResult<number>} */
-			function finish() {
-				if (!finished) {
-					finished = true
-					controller.abort()
-					unlink()
-				}
-				return { done: true, value: void 0 }
-			}
 			return {
 				[Symbol.asyncIterator]() {
 					return this
 				},
 				async next() {
-					if (finished || controller.signal.aborted) return finish()
+					if (finished || controller.signal.aborted) {
+						return finish()
+					}
 					if (due > Date.now()) {
 						try {
 							await sleep_until(due, controller.signal)
@@ -435,7 +492,9 @@ export function every(ms, options = {}) {
 							return finish()
 						}
 					}
-					if (finished) return finish()
+					if (finished) {
+						return finish()
+					}
 					const now = Date.now()
 					due = (now - due >= ms ? now : due) + ms
 					return { done: false, value: ++count }
@@ -444,6 +503,15 @@ export function every(ms, options = {}) {
 					return finish()
 				}
 			}
+			/** @returns {IteratorResult<number>} */
+			function finish() {
+				if (!finished) {
+					finished = true
+					controller.abort()
+					unlink()
+				}
+				return { done: true, value: void 0 }
+			}
 		}
 	}
 }
@@ -463,50 +531,14 @@ function switch_latest(source, start) {
 	let inner
 	let outer_done = false
 	let finished = false
-	/**
-	 * @returns {void}
-	 */
-	function close_inner() {
-		if (!inner) return
-		inner.controller.abort(
-			new CancelError("Superseded by a newer value")
-		)
-		inner.next?.catch(noop)
-		release(inner.reader)
-		cancel_result(inner.made)
-		inner = void 0
-	}
-	function finish() {
-		finished = true
-		close_inner()
-		if (outer) release(outer)
-	}
-	/**
-	 * @param {T} value
-	 * @returns {void}
-	 */
-	function open_inner(value) {
-		next_outer = /** @type {AsyncIterator<T>} */(outer)/**/.next()
-		next_outer.catch(noop)
-		const controller = new AbortController()
-		const made = start(value, controller.signal)
-		const iterable = typeof /** @type {Partial<AsyncIterable<unknown>>} */(made)/**/?.[Symbol.asyncIterator] == "function"
-		const reader = /** @type {AsyncIterator<R>} */(iterable ? to_reader(made) : once_reader(made))/**/
-		inner = {
-			controller,
-			made: iterable || typeof /** @type {Partial<PromiseLike<unknown>>} */(made)/**/?.then == "function"
-				? made
-				: void 0,
-			next: void 0,
-			reader
-		}
-	}
 	return {
 		[Symbol.asyncIterator]() {
 			return outer || finished ? switch_latest(source, start) : this
 		},
 		async next() {
-			if (finished) return { done: true, value: void 0 }
+			if (finished) {
+				return { done: true, value: void 0 }
+			}
 			try {
 				outer ??= /** @type {AsyncIterator<T>} */(to_reader(source))/**/
 				for (;;) {
@@ -517,7 +549,9 @@ function switch_latest(source, start) {
 						}
 						next_outer ??= outer.next()
 						const step = await next_outer
-						if (finished) return { done: true, value: void 0 }
+						if (finished) {
+							return { done: true, value: void 0 }
+						}
 						next_outer = void 0
 						if (step.done) {
 							finish()
@@ -543,7 +577,9 @@ function switch_latest(source, start) {
 						)
 					}
 					const won = await Promise.race(racing)
-					if (finished) return { done: true, value: void 0 }
+					if (finished) {
+						return { done: true, value: void 0 }
+					}
 					if (won.from_outer) {
 						const step = /** @type {IteratorResult<T>} */(won.step)/**/
 						next_outer = void 0
@@ -564,18 +600,64 @@ function switch_latest(source, start) {
 					return step
 				}
 			} catch (error) {
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				finish()
 				throw error
 			}
 		},
 		async return() {
-			if (!finished) finish()
+			if (!finished) {
+				finish()
+			}
 			return { done: true, value: void 0 }
 		}
 	}
+	/** @returns {void} */
+	function close_inner() {
+		if (!inner) {
+			return
+		}
+		inner.controller.abort(
+			new CancelError("Superseded by a newer value")
+		)
+		inner.next?.catch(noop)
+		release(inner.reader)
+		cancel_result(inner.made)
+		inner = void 0
+	}
+	/** @returns {void} */
+	function finish() {
+		finished = true
+		close_inner()
+		if (outer) {
+			release(outer)
+		}
+	}
+	/**
+	 * @param {T} value
+	 * @returns {void}
+	 */
+	function open_inner(value) {
+		next_outer = /** @type {AsyncIterator<T>} */(outer)/**/.next()
+		next_outer.catch(noop)
+		const controller = new AbortController()
+		const made = start(value, controller.signal)
+		const iterable = typeof /** @type {Partial<AsyncIterable<unknown>>} */(made)/**/?.[Symbol.asyncIterator] == "function"
+		const reader = /** @type {AsyncIterator<R>} */(iterable ? to_reader(made) : once_reader(made))/**/
+		inner = {
+			controller,
+			made: iterable || typeof /** @type {Partial<PromiseLike<unknown>>} */(made)/**/?.then == "function"
+				? made
+				: void 0,
+			next: void 0,
+			reader
+		}
+	}
 }
-export const latest = /** @type {import("../public.js").LatestFunction} */(switch_latest)/**/
+/** @type {import("../public.js").LatestFunction} */
+export const latest = switch_latest
 /**
  * @template T
  * @param {...AsyncIterable<T>} sources
@@ -593,51 +675,28 @@ function merge_streams(...sources) {
 	/** @type {(() => void) | undefined} */
 	let wake
 	let finished = false
-	function finish() {
-		finished = true
-		if (readers) for (const reader of readers) release(reader)
-		wake?.()
-	}
-	/**
-	 * @param {AsyncIterator<T>} reader
-	 * @returns {void}
-	 */
-	function read(reader) {
-		reader.next()
-			.then(
-				step => {
-					if (finished) return
-					ready.push(
-						{ error: void 0, reader, step }
-					)
-					wake?.()
-				},
-				error => {
-					if (finished) return
-					ready.push(
-						{
-							error: { value: error },
-							reader,
-							step: void 0
-						}
-					)
-					wake?.()
-				}
-			)
-	}
 	return {
 		[Symbol.asyncIterator]() {
 			return readers || finished ? merge_streams(...sources) : this
 		},
 		async next() {
-			if (finished) return { done: true, value: void 0 }
+			if (finished) {
+				return { done: true, value: void 0 }
+			}
 			try {
 				if (!readers) {
-					readers = sources.map(
-						source => /** @type {AsyncIterator<T>} */(to_reader(source))/**/
-					)
-					active = readers.length
-					for (const reader of readers) read(reader)
+					/** @type {AsyncIterator<T>[]} */
+					const opened = []
+					readers = opened
+					for (const source of sources) {
+						opened.push(
+							/** @type {AsyncIterator<T>} */(to_reader(source))/**/
+						)
+					}
+					active = opened.length
+					for (const reader of opened) {
+						read(reader)
+					}
 				}
 				if (last) {
 					read(last)
@@ -650,7 +709,9 @@ function merge_streams(...sources) {
 							ready = []
 							head = 0
 						}
-						if (error) throw error.value
+						if (error) {
+							throw error.value
+						}
 						if (/** @type {IteratorResult<T>} */(step)/**/.done) {
 							active--
 							continue
@@ -658,28 +719,77 @@ function merge_streams(...sources) {
 						last = reader
 						return /** @type {IteratorResult<T>} */(step)/**/
 					}
-					if (!active) break
+					if (!active) {
+						break
+					}
 					await new Promise(
 						resolve => {
 							wake = () => resolve(void 0)
 						}
 					)
 					wake = void 0
-					if (finished) return { done: true, value: void 0 }
+					if (finished) {
+						return { done: true, value: void 0 }
+					}
 				}
 				finish()
 				return { done: true, value: void 0 }
 			} catch (error) {
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				finish()
 				throw error
 			}
 		},
 		async return() {
-			if (!finished) finish()
+			if (!finished) {
+				finish()
+			}
 			return { done: true, value: void 0 }
 		}
 	}
+	/** @returns {void} */
+	function finish() {
+		finished = true
+		if (readers) {
+			for (const reader of readers) {
+				release(reader)
+			}
+		}
+		wake?.()
+	}
+	/**
+	 * @param {AsyncIterator<T>} reader
+	 * @returns {void}
+	 */
+	function read(reader) {
+		reader.next()
+			.then(
+				step => {
+					if (finished) {
+						return
+					}
+					ready.push(
+						{ error: void 0, reader, step }
+					)
+					wake?.()
+				},
+				error => {
+					if (finished) {
+						return
+					}
+					ready.push(
+						{
+							error: { value: error },
+							reader,
+							step: void 0
+						}
+					)
+					wake?.()
+				}
+			)
+	}
 }
 export const merge = /** @type {import("../public.js").MergeFunction} */(merge_streams)/**/
 /**
@@ -692,8 +802,12 @@ function once_reader(value) {
 	let inner
 	return {
 		async next() {
-			if (done) return { done: true, value: void 0 }
-			if (inner) return inner.reader.next()
+			if (done) {
+				return { done: true, value: void 0 }
+			}
+			if (inner) {
+				return inner.reader.next()
+			}
 			const settled = await value
 			const iterable = typeof /** @type {Partial<AsyncIterable<unknown>>} */(settled)/**/?.[Symbol.asyncIterator] == "function"
 			if (done) {
@@ -730,7 +844,9 @@ function once_reader(value) {
 function release(reader) {
 	try {
 		const returned = /** @type {Promise<unknown> | undefined} */(reader.return?.())/**/
-		if (returned && typeof returned.then == "function") returned.then(noop, noop)
+		if (returned && typeof returned.then == "function") {
+			returned.then(noop, noop)
+		}
 	} catch {}
 }
 /**
@@ -746,7 +862,9 @@ export function share(source, options = {}) {
 	let shared = share_source(source, options.limit)
 	return {
 		[Symbol.asyncIterator]() {
-			if (shared.source.ended) shared = share_source(source, options.limit)
+			if (shared.source.ended) {
+				shared = share_source(source, options.limit)
+			}
 			return /** @type {AsyncGenerator<T, void, undefined>} */(shared.read())/**/
 		}
 	}
@@ -754,11 +872,17 @@ export function share(source, options = {}) {
 /**
  * @param {AsyncIterable<unknown>} source
  * @param {number | undefined} limit
+ * @returns {{ read: () => AsyncIterableIterator<unknown>; source: StreamSource; }}
  */
 function share_source(source, limit) {
 	const shared = create_source(limit)
 	/** @type {AsyncIterator<unknown> | undefined} */
 	let reader
+	return {
+		read: () => shared.read(start, stop),
+		source: shared
+	}
+	/** @returns {void} */
 	function start() {
 		const current = to_reader(source)
 		reader = current
@@ -766,7 +890,9 @@ function share_source(source, limit) {
 			try {
 				for (;;) {
 					const step = await current.next()
-					if (reader != current) return
+					if (reader != current) {
+						return
+					}
 					if (step.done) {
 						shared.close()
 						return
@@ -774,18 +900,19 @@ function share_source(source, limit) {
 					shared.write(step.value)
 				}
 			} catch (error) {
-				if (reader == current) shared.fail(error)
+				if (reader == current) {
+					shared.fail(error)
+				}
 			}
 		})()
 	}
+	/** @returns {void} */
 	function stop() {
 		const current = reader
 		reader = void 0
-		if (current) release(current)
-	}
-	return {
-		read: () => shared.read(start, stop),
-		source: shared
+		if (current) {
+			release(current)
+		}
 	}
 }
 /**
@@ -809,11 +936,6 @@ export function throttle(source, ms) {
 	let held
 	let finished = false
 	const window = create_due(ms)
-	function finish() {
-		finished = true
-		window.clear()
-		if (reader) release(reader)
-	}
 	return {
 		[Symbol.asyncIterator]() {
 			return reader || finished ? throttle(source, ms) : this
@@ -824,7 +946,9 @@ export function throttle(source, ms) {
 				failure = void 0
 				throw error
 			}
-			if (finished) return { done: true, value: void 0 }
+			if (finished) {
+				return { done: true, value: void 0 }
+			}
 			try {
 				reader ??= /** @type {AsyncIterator<T>} */(to_reader(source))/**/
 				for (;;) {
@@ -833,7 +957,9 @@ export function throttle(source, ms) {
 					const step = await Promise.race(
 						racing ? [ next, racing ] : [ next ]
 					)
-					if (finished) return { done: true, value: void 0 }
+					if (finished) {
+						return { done: true, value: void 0 }
+					}
 					if (step == "due" || racing && window.fired) {
 						if (held) {
 							const { value } = held
@@ -858,10 +984,14 @@ export function throttle(source, ms) {
 					return step
 				}
 			} catch (error) {
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				finish()
 				const last = held
-				if (!last) throw error
+				if (!last) {
+					throw error
+				}
 				held = void 0
 				failure = { error }
 				return { done: false, value: last.value }
@@ -869,10 +999,20 @@ export function throttle(source, ms) {
 		},
 		async return() {
 			failure = void 0
-			if (!finished) finish()
+			if (!finished) {
+				finish()
+			}
 			return { done: true, value: void 0 }
 		}
 	}
+	/** @returns {void} */
+	function finish() {
+		finished = true
+		window.clear()
+		if (reader) {
+			release(reader)
+		}
+	}
 }
 /**
  * @param {unknown} source
@@ -880,9 +1020,11 @@ export function throttle(source, ms) {
  */
 function to_reader(source) {
 	const iterable = /** @type {Partial<AsyncIterable<unknown>>} */(source)/**/
-	if (typeof iterable?.[Symbol.asyncIterator] != "function") throw TypeError(
-		"A stream must be an async iterable"
-	)
+	if (typeof iterable?.[Symbol.asyncIterator] != "function") {
+		throw TypeError(
+			"A stream must be an async iterable"
+		)
+	}
 	return /** @type {AsyncIterable<unknown>} */(source)/**/[Symbol.asyncIterator]()
 }
 /**
@@ -900,17 +1042,14 @@ export function until(source, stop) {
 	/** @type {Promise<"stop"> | undefined} */
 	let ended
 	let finished = false
-	function finish() {
-		finished = true
-		if (reader) release(reader)
-		if (ender) release(ender)
-	}
 	return {
 		[Symbol.asyncIterator]() {
 			return reader || finished ? until(source, stop) : this
 		},
 		async next() {
-			if (finished) return { done: true, value: void 0 }
+			if (finished) {
+				return { done: true, value: void 0 }
+			}
 			try {
 				if (!reader) {
 					reader = /** @type {AsyncIterator<T>} */(to_reader(source))/**/
@@ -924,21 +1063,37 @@ export function until(source, stop) {
 						/** @type {Promise<"stop">} */(ended)/**/
 					]
 				)
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				if (step == "stop" || step.done) {
 					finish()
 					return { done: true, value: void 0 }
 				}
 				return step
 			} catch (error) {
-				if (finished) return { done: true, value: void 0 }
+				if (finished) {
+					return { done: true, value: void 0 }
+				}
 				finish()
 				throw error
 			}
 		},
 		async return() {
-			if (!finished) finish()
+			if (!finished) {
+				finish()
+			}
 			return { done: true, value: void 0 }
 		}
 	}
+	/** @returns {void} */
+	function finish() {
+		finished = true
+		if (reader) {
+			release(reader)
+		}
+		if (ender) {
+			release(ender)
+		}
+	}
 }