reactor-core-ts 2.1.6 → 3.2.1

package/dist/publisher/flux.js

@@ -0,0 +1,697 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/defineProperty.js";
+import { Context } from "../context/context.js";
+import { EMPTY_ITERABLE, closeAsyncIterator, isAsyncIterable, isIterable, neverIterable, toAsyncIterator } from "../internal/iterable.js";
+import { mapIterable } from "../internal/iterable-transform.js";
+import { BooleanDisposable } from "../core/boolean-disposable.js";
+import { CompositeError } from "../errors/classes.js";
+import { asError, throwIfNullish } from "../errors/helpers.js";
+import { firstValueFrom, raceWithAbort } from "../internal/abort.js";
+import { AsyncQueue } from "../internal/async-queue.js";
+import { collectIterable, lastIterableValue } from "../internal/iterable-terminal.js";
+import { eventSource, webSocketSource } from "./browser-sources.js";
+import { Schedulers } from "../schedulers/schedulers.js";
+import { addCancelCallback, isSubscriber, runCancelCallbacks, scheduleDelay } from "./helpers.js";
+import { IterableSubscription } from "../subscription/iterable-subscription.js";
+//#region src/publisher/flux.ts
+/**
+* @packageDocumentation
+* Flux, Mono and operator implementation modules.
+*/
+var _Symbol$asyncIterator = Symbol.asyncIterator;
+/** Multi-value Reactive Streams publisher with Reactor-style operators. */
+var Flux = class Flux {
+	/** Creates a Flux from a lazy source factory. */
+	constructor(sourceFactory) {
+		_defineProperty(
+			this,
+			/** Lazy source factory invoked for each subscription or async iteration. */
+			"sourceFactory",
+			void 0
+		);
+		this.sourceFactory = sourceFactory;
+	}
+	/** Creates a Flux that emits the provided values and then completes. */
+	static just(...values) {
+		if (values.length === 0) return Flux.empty();
+		for (const value of values) throwIfNullish(value, "value");
+		return Flux.fromIterable(values);
+	}
+	/** Creates a Flux from an array-like readonly value list. */
+	static fromArray(values) {
+		throwIfNullish(values, "values");
+		if (values.length === 0) return Flux.empty();
+		return Flux.fromIterable(values);
+	}
+	/** Creates a Flux from a stream-like iterable or a lazy stream supplier. */
+	static fromStream(stream) {
+		throwIfNullish(stream, "stream");
+		return typeof stream === "function" ? Flux.defer(() => Flux.fromIterable(stream())) : Flux.fromIterable(stream);
+	}
+	/** Creates a Flux from a JavaScript iterable. */
+	static fromIterable(values) {
+		throwIfNullish(values, "values");
+		if (Array.isArray(values) && values.length === 0) return Flux.empty();
+		return new Flux(() => values);
+	}
+	/** Creates a Flux from browser events and removes the listener on cancellation. */
+	static fromEvent(target, type, options) {
+		return new Flux(eventSource(target, type, options));
+	}
+	/** Creates a Flux from browser WebSocket message events and cleans listeners on cancellation. */
+	static fromWebSocket(input, options) {
+		return new Flux(webSocketSource(input, options));
+	}
+	/** Adapts a publisher, iterable, async iterable or promise-like value to Flux. */
+	static from(input) {
+		throwIfNullish(input, "input");
+		if (input instanceof Flux) return input;
+		if (isAsyncIterable(input)) return new Flux(() => input);
+		if (isIterable(input)) return Flux.fromIterable(input);
+		if (typeof input.subscribe === "function") return fromPublisher(input);
+		if (typeof input.then === "function") return new Flux(async function* (signal) {
+			const value = await raceWithAbort(Promise.resolve(input), signal);
+			if (value !== void 0 && value !== null) yield value;
+		});
+		throw new TypeError("Unsupported publisher input");
+	}
+	/** Creates a Flux that completes without emitting values. */
+	static empty() {
+		return EMPTY_FLUX;
+	}
+	/** Creates a Flux that never emits or completes until cancelled. */
+	static never() {
+		return NEVER_FLUX;
+	}
+	/** Creates a Flux that terminates with the provided error. */
+	static error(error) {
+		return new Flux(async function* () {
+			throw typeof error === "function" ? error() : error;
+		});
+	}
+	/** Defers source creation until subscription time. */
+	static defer(supplier) {
+		return new Flux((signal, context) => Flux.from(supplier()).iterate(signal, context));
+	}
+	/** Defers source creation and exposes the subscriber context. */
+	static deferContextual(supplier) {
+		return new Flux((signal, context) => Flux.from(supplier(context.readOnly())).iterate(signal, context));
+	}
+	/** Creates a Flux by bridging callback-style producers through a sink. */
+	static create(callback) {
+		throwIfNullish(callback, "callback");
+		return new Flux((signal, context) => {
+			const queue = new AsyncQueue(signal);
+			let cancelled = false;
+			let cancelCallbacks;
+			const sink = {
+				/** Emits one value into the created Flux. */
+				next(value) {
+					throwIfNullish(value, "value");
+					queue.push(value);
+				},
+				/** Terminates the created Flux with an error. */
+				error(error) {
+					queue.error(error);
+				},
+				/** Completes the created Flux. */
+				complete() {
+					queue.complete();
+				},
+				/** Registers a callback invoked when the subscription is cancelled. */
+				onCancel(cancelCallback) {
+					cancelCallbacks = addCancelCallback(cancelCallbacks, cancelCallback);
+					return sink;
+				},
+				/** Returns true after cancellation has been observed. */
+				isCancelled() {
+					return cancelled || signal.aborted;
+				}
+			};
+			signal.addEventListener("abort", () => {
+				cancelled = true;
+				runCancelCallbacks(cancelCallbacks);
+				cancelCallbacks = void 0;
+				queue.complete();
+			}, { once: true });
+			try {
+				callback(sink);
+			} catch (error) {
+				queue.error(error);
+			}
+			return queue;
+		});
+	}
+	/** Creates a Flux by bridging a single-threaded push-style producer through a sink. */
+	static push(callback) {
+		return Flux.create(callback);
+	}
+	/** Creates a Flux by repeatedly invoking a synchronous generator callback. */
+	static generate(generator) {
+		throwIfNullish(generator, "generator");
+		return new Flux(async function* (signal) {
+			let done = false;
+			let hasValue = false;
+			let value;
+			const sink = {
+				/** Emits one generated value for this turn. */
+				next(nextValue) {
+					if (hasValue) throw new Error("Synchronous generator can emit at most one value per turn");
+					hasValue = true;
+					value = nextValue;
+				},
+				/** Completes the generated sequence. */
+				complete() {
+					done = true;
+				},
+				/** Fails the generated sequence. */
+				error(error) {
+					throw error;
+				}
+			};
+			while (!done && !signal.aborted) {
+				hasValue = false;
+				value = void 0;
+				generator(sink);
+				if (hasValue) yield value;
+				else if (!done) throw new Error("Synchronous generator must emit, complete or fail");
+			}
+		});
+	}
+	/** Creates a finite integer range. */
+	static range(start, count) {
+		if (!Number.isInteger(start) || !Number.isInteger(count) || count < 0) throw new RangeError("Flux.range expects an integer start and a non-negative integer count");
+		if (count === 0) return Flux.empty();
+		return new Flux(function* () {
+			for (let i = 0; i < count; i += 1) yield start + i;
+		});
+	}
+	/** Creates an interval Flux that emits incrementing numbers. */
+	static interval(period, scheduler = Schedulers.timeout()) {
+		return new Flux(async function* (signal) {
+			let index = 0;
+			while (!signal.aborted) {
+				await scheduleDelay(scheduler, period, signal);
+				if (!signal.aborted) {
+					yield index;
+					index += 1;
+				}
+			}
+		});
+	}
+	/** Merges several publishers concurrently. */
+	static merge(...sources) {
+		if (sources.length === 0) return Flux.empty();
+		if (sources.length === 1) return Flux.from(sources[0]);
+		return mergeSources(toFluxArray(sources));
+	}
+	/** Merges several publishers concurrently and delays failures until every source terminates. */
+	static mergeDelayError(...sources) {
+		if (sources.length === 0) return Flux.empty();
+		if (sources.length === 1) return Flux.from(sources[0]);
+		return mergeSourcesDelayError(toFluxArray(sources));
+	}
+	/** Merges sources sequentially while subscribing to one source at a time. */
+	static mergeSequential(...sources) {
+		return Flux.concat(...sources);
+	}
+	/** Merges sources sequentially and delays failures until every source has been consumed. */
+	static mergeSequentialDelayError(...sources) {
+		return concatDelayErrorSources(sources);
+	}
+	/** Merges finite sources and emits their values sorted by a comparator. */
+	static mergeComparing(comparatorOrSource, ...sources) {
+		const { comparator, inputs } = orderedMergeInputs(comparatorOrSource, sources);
+		return sortMergedSources(inputs, comparator);
+	}
+	/** Merges finite sources, delays failures and emits their values sorted by a comparator. */
+	static mergeComparingDelayError(comparatorOrSource, ...sources) {
+		const { comparator, inputs } = orderedMergeInputs(comparatorOrSource, sources);
+		return sortMergedSourcesDelayError(inputs, comparator);
+	}
+	/** Merges finite sources and emits their values in comparator order. */
+	static mergeOrdered(comparatorOrSource, ...sources) {
+		return Flux.mergeComparing(comparatorOrSource, ...sources);
+	}
+	/** Merges finite sources with priority ordering. */
+	static mergePriority(comparatorOrSource, ...sources) {
+		return Flux.mergeComparing(comparatorOrSource, ...sources);
+	}
+	/** Merges finite sources with priority ordering and delayed failures. */
+	static mergePriorityDelayError(comparatorOrSource, ...sources) {
+		return Flux.mergeComparingDelayError(comparatorOrSource, ...sources);
+	}
+	/** Concatenates several publishers sequentially. */
+	static concat(...sources) {
+		if (sources.length === 0) return Flux.empty();
+		if (sources.length === 1) return Flux.from(sources[0]);
+		return new Flux(async function* (signal, context) {
+			for (const source of sources) for await (const value of Flux.from(source).iterate(signal, context)) {
+				if (signal.aborted) return;
+				yield value;
+			}
+		});
+	}
+	/** Concatenates several publishers sequentially and delays failures until every source has been consumed. */
+	static concatDelayError(...sources) {
+		if (sources.length === 0) return Flux.empty();
+		if (sources.length === 1) return Flux.from(sources[0]);
+		return concatDelayErrorSources(sources);
+	}
+	/** Relays the first source that emits any signal. */
+	static first(...sources) {
+		return Flux.firstWithSignal(...sources);
+	}
+	/** Relays the first source that emits any signal. */
+	static firstWithSignal(...sources) {
+		if (sources.length === 0) return Flux.empty();
+		if (sources.length === 1) return Flux.from(sources[0]);
+		return new Flux((signal, context) => {
+			const queue = new AsyncQueue(signal);
+			let settled = false;
+			for (const source of sources) (async () => {
+				try {
+					const iterator = toAsyncIterator(Flux.from(source).iterate(signal, context));
+					try {
+						const first = await raceWithAbort(iterator.next(), signal);
+						if (settled) {
+							await iterator.return?.();
+							return;
+						}
+						settled = true;
+						if (first.done) {
+							queue.complete();
+							return;
+						}
+						queue.push(first.value);
+						for (;;) {
+							const next = await raceWithAbort(iterator.next(), signal);
+							if (next.done) {
+								queue.complete();
+								return;
+							}
+							queue.push(next.value);
+						}
+					} finally {
+						await iterator.return?.();
+					}
+				} catch (error) {
+					if (!settled) {
+						settled = true;
+						queue.error(error);
+					}
+				}
+			})();
+			return queue;
+		});
+	}
+	/** Relays the first source that produces a value, ignoring empty completions. */
+	static firstWithValue(...sources) {
+		if (sources.length === 0) return Flux.empty();
+		return new Flux((signal, context) => {
+			const queue = new AsyncQueue(signal);
+			let remaining = sources.length;
+			let settled = false;
+			const errors = [];
+			for (const source of sources) (async () => {
+				try {
+					const value = await firstValueFrom(Flux.from(source), signal);
+					if (settled) return;
+					if (value !== void 0) {
+						settled = true;
+						queue.push(value);
+						queue.complete();
+						return;
+					}
+				} catch (error) {
+					errors.push(error);
+				}
+				remaining -= 1;
+				if (remaining === 0 && !settled) errors.length > 0 ? queue.error(new CompositeError(errors)) : queue.complete();
+			})();
+			return queue;
+		});
+	}
+	/** Zips publishers by combining one value from each source. */
+	static zip(sources, combinator) {
+		const sourceCount = sources.length;
+		if (sourceCount === 0) return Flux.empty();
+		if (sourceCount === 1) return singleTupleSource(sources[0], combinator);
+		return new Flux(async function* (signal, context) {
+			const iterators = new Array(sourceCount);
+			const nexts = new Array(sourceCount);
+			for (let index = 0; index < sourceCount; index += 1) iterators[index] = toAsyncIterator(Flux.from(sources[index]).iterate(signal, context));
+			try {
+				while (!signal.aborted) {
+					for (let index = 0; index < sourceCount; index += 1) nexts[index] = raceWithAbort(iterators[index].next(), signal);
+					const results = await Promise.all(nexts);
+					const values = new Array(sourceCount);
+					for (let index = 0; index < sourceCount; index += 1) {
+						const result = results[index];
+						if (result.done) return;
+						values[index] = result.value;
+					}
+					const tuple = values;
+					yield combinator ? combinator(tuple) : tuple;
+				}
+			} finally {
+				for (const iterator of iterators) await closeAsyncIterator(iterator);
+			}
+		});
+	}
+	/** Combines the latest value from each source after all sources emitted once. */
+	static combineLatest(sources, combinator) {
+		if (sources.length === 0) return Flux.empty();
+		if (sources.length === 1) return singleTupleSource(sources[0], combinator);
+		return new Flux((signal, context) => {
+			const queue = new AsyncQueue(signal);
+			const sourceCount = sources.length;
+			const latest = new Array(sourceCount);
+			const hasValue = new Array(sourceCount);
+			let readyCount = 0;
+			let completed = 0;
+			let failed = false;
+			for (let index = 0; index < sourceCount; index += 1) {
+				const source = sources[index];
+				(async () => {
+					try {
+						for await (const value of Flux.from(source).iterate(signal, context)) {
+							latest[index] = value;
+							if (hasValue[index] !== true) {
+								hasValue[index] = true;
+								readyCount += 1;
+							}
+							if (readyCount === sourceCount) {
+								const values = latest.slice();
+								queue.push(combinator ? combinator(values) : values);
+							}
+						}
+						completed += 1;
+						if (completed === sourceCount && !failed) queue.complete();
+					} catch (error) {
+						failed = true;
+						queue.error(error);
+					}
+				})();
+			}
+			return queue;
+		});
+	}
+	/** Switches to the most recent publisher emitted by an outer publisher. */
+	static switchOnNext(sources) {
+		return new Flux((signal, context) => {
+			const queue = new AsyncQueue(signal);
+			let active = 0;
+			let outerDone = false;
+			let failed = false;
+			const completeIfDone = () => {
+				if (outerDone && active === 0 && !failed) queue.complete();
+			};
+			(async () => {
+				const iterator = toAsyncIterator(Flux.from(sources).iterate(signal, context));
+				try {
+					let version = 0;
+					while (!signal.aborted) {
+						const next = await raceWithAbort(iterator.next(), signal);
+						if (next.done) break;
+						version += 1;
+						const current = version;
+						active += 1;
+						(async () => {
+							try {
+								for await (const value of Flux.from(next.value).iterate(signal, context)) if (current === version) queue.push(value);
+							} catch (error) {
+								failed = true;
+								queue.error(error);
+							} finally {
+								active -= 1;
+								completeIfDone();
+							}
+						})();
+					}
+					outerDone = true;
+					completeIfDone();
+				} catch (error) {
+					failed = true;
+					queue.error(error);
+				} finally {
+					iterator.return?.();
+				}
+			})();
+			return queue;
+		});
+	}
+	/** Uses a resource for the duration of a derived publisher and cleans it up afterwards. */
+	static using(resourceSupplier, sourceFactory, resourceCleanup = closeResource) {
+		return new Flux(async function* (signal, context) {
+			const resource = resourceSupplier();
+			try {
+				for await (const value of Flux.from(sourceFactory(resource)).iterate(signal, context)) yield value;
+			} finally {
+				resourceCleanup(resource);
+			}
+		});
+	}
+	/** Uses an asynchronously supplied resource and runs asynchronous cleanup publishers. */
+	static usingWhen(resourceSupplier, sourceFactory, asyncComplete, asyncError, asyncCancel) {
+		return new Flux(async function* (signal, context) {
+			const resource = await firstValueFrom(Flux.from(resourceSupplier), signal);
+			if (resource === void 0) return;
+			let failed;
+			try {
+				for await (const value of Flux.from(sourceFactory(resource)).iterate(signal, context)) yield value;
+			} catch (error) {
+				failed = error;
+				if (asyncError) await drainPublisher(asyncError(resource, error), new AbortController().signal, context);
+				throw error;
+			} finally {
+				if (signal.aborted && asyncCancel) await drainPublisher(asyncCancel(resource), new AbortController().signal, context);
+				else if (failed === void 0 && asyncComplete) await drainPublisher(asyncComplete(resource), new AbortController().signal, context);
+			}
+		});
+	}
+	/** Subscribes either a full subscriber or callback handlers. */
+	subscribe(subscriberOrNext, onError = throwUnhandledSubscriberError, onComplete = noopSubscriberCallback) {
+		if (isSubscriber(subscriberOrNext)) {
+			this.subscribeActual(subscriberOrNext);
+			return;
+		}
+		let subscription;
+		const disposable = new BooleanDisposable(() => subscription?.cancel());
+		const subscriber = {
+			/** Stores the subscription and requests unbounded demand. */
+			onSubscribe(nextSubscription) {
+				subscription = nextSubscription;
+				nextSubscription.request(Number.POSITIVE_INFINITY);
+			},
+			onNext: subscriberOrNext ?? noopSubscriberCallback,
+			onError,
+			onComplete
+		};
+		this.subscribeActual(subscriber);
+		return disposable;
+	}
+	/** Subscribes a normalized Reactive Streams subscriber to this Flux. */
+	subscribeActual(subscriber) {
+		const context = subscriber.currentContext?.() ?? Context.empty();
+		const subscription = new IterableSubscription(this, subscriber, context);
+		subscription.start();
+		subscriber.onSubscribe(subscription);
+		subscription.deliverStartFailure();
+	}
+	/** Returns the lazy iterable backing this Flux for internal operator composition. */
+	iterate(signal, context = Context.empty()) {
+		return this.sourceFactory(signal, context);
+	}
+	/** Returns an async iterator over this Flux. */
+	[_Symbol$asyncIterator]() {
+		const controller = new AbortController();
+		const iterator = toAsyncIterator(this.iterate(controller.signal, Context.empty()));
+		return {
+			next: () => iterator.next(),
+			return: async (value) => {
+				controller.abort();
+				if (iterator.return) await iterator.return(value);
+				return {
+					done: true,
+					value
+				};
+			},
+			throw: async (error) => {
+				controller.abort();
+				if (iterator.throw) return iterator.throw(error);
+				throw error;
+			}
+		};
+	}
+	/** Returns this Flux as an async iterable. */
+	toIterable() {
+		return this;
+	}
+	/** Collects all values into an array. */
+	async toArray() {
+		return collectIterable(this.iterate(new AbortController().signal, Context.empty()));
+	}
+	/** Resolves to the last emitted value, or undefined for an empty source. */
+	async toPromise() {
+		return lastIterableValue(this.iterate(new AbortController().signal, Context.empty()));
+	}
+};
+/** Shared stateless empty Flux instance. */
+var EMPTY_FLUX = new Flux(() => EMPTY_ITERABLE);
+/** Shared stateless never Flux instance. */
+var NEVER_FLUX = new Flux((signal) => neverIterable(signal));
+/** Default cleanup for resources that expose a close method. */
+function closeResource(resource) {
+	resource.close?.();
+}
+/** Shared no-op subscriber callback. */
+function noopSubscriberCallback() {}
+/** Throws unhandled subscriber errors like the default callback contract. */
+function throwUnhandledSubscriberError(error) {
+	throw asError(error);
+}
+/** Adapts a Reactive Streams publisher to the Flux async-iteration model. */
+function fromPublisher(publisher) {
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		let subscription;
+		publisher.subscribe({
+			/** Captures upstream subscription and requests unbounded demand. */
+			onSubscribe(nextSubscription) {
+				subscription = nextSubscription;
+				nextSubscription.request(Number.POSITIVE_INFINITY);
+			},
+			/** Pushes upstream values into the bridge queue. */
+			onNext(value) {
+				queue.push(value);
+			},
+			/** Fails the bridge queue with the upstream error. */
+			onError(error) {
+				queue.error(error);
+			},
+			/** Completes the bridge queue when upstream completes. */
+			onComplete() {
+				queue.complete();
+			}
+		});
+		signal.addEventListener("abort", () => subscription?.cancel(), { once: true });
+		return queue;
+	});
+}
+/** Adapts publisher inputs to Flux instances without callback allocation. */
+function toFluxArray(sources) {
+	const fluxes = new Array(sources.length);
+	for (let index = 0; index < sources.length; index += 1) fluxes[index] = Flux.from(sources[index]);
+	return fluxes;
+}
+/** Emits one-element tuple values without multi-source coordination overhead. */
+function singleTupleSource(source, combinator) {
+	return new Flux((signal, context) => mapIterable(Flux.from(source).iterate(signal, context), (value) => {
+		const tuple = [value];
+		return combinator ? combinator(tuple) : tuple;
+	}));
+}
+/** Merges sources concurrently without bounded-concurrency bookkeeping. */
+function mergeSources(sources) {
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		const tasks = new Array(sources.length);
+		let failed = false;
+		(async () => {
+			try {
+				for (let index = 0; index < sources.length; index += 1) tasks[index] = drainMergedSource(sources[index], signal, context, queue, () => {
+					failed = true;
+				});
+				await Promise.all(tasks);
+				if (!failed) queue.complete();
+			} catch (error) {
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+}
+/** Merges sources concurrently and collects failures until all active sources terminate. */
+function mergeSourcesDelayError(sources) {
+	return new Flux((signal, context) => {
+		const queue = new AsyncQueue(signal);
+		const tasks = new Array(sources.length);
+		const errors = [];
+		(async () => {
+			try {
+				for (let index = 0; index < sources.length; index += 1) tasks[index] = drainMergedSourceDelayError(sources[index], signal, context, queue, errors);
+				await Promise.all(tasks);
+				errors.length > 0 ? queue.error(new CompositeError(errors)) : queue.complete();
+			} catch (error) {
+				queue.error(error);
+			}
+		})();
+		return queue;
+	});
+}
+/** Drains one merged source and reports its first failure through the output queue. */
+async function drainMergedSource(source, signal, context, queue, markFailed) {
+	try {
+		for await (const value of source.iterate(signal, context)) queue.push(value);
+	} catch (error) {
+		markFailed();
+		queue.error(error);
+	}
+}
+/** Drains one merged source while recording failures for delayed-error merging. */
+async function drainMergedSourceDelayError(source, signal, context, queue, errors) {
+	try {
+		for await (const value of source.iterate(signal, context)) queue.push(value);
+	} catch (error) {
+		errors.push(error);
+	}
+}
+/** Concatenates sources while collecting failures until all sources have run. */
+function concatDelayErrorSources(sources) {
+	return new Flux(async function* (signal, context) {
+		const errors = [];
+		for (const source of sources) try {
+			for await (const value of Flux.from(source).iterate(signal, context)) yield value;
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new CompositeError(errors);
+	});
+}
+/** Normalizes ordered merge arguments into a comparator and source list. */
+function orderedMergeInputs(comparatorOrSource, sources) {
+	if (typeof comparatorOrSource === "function") return {
+		comparator: comparatorOrSource,
+		inputs: sources
+	};
+	return {
+		comparator: void 0,
+		inputs: comparatorOrSource === void 0 ? sources : [comparatorOrSource, ...sources]
+	};
+}
+/** Collects finite merged values and emits them sorted by the optional comparator. */
+function sortMergedSources(sources, comparator) {
+	return new Flux(async function* (signal, context) {
+		const values = [];
+		for await (const value of Flux.merge(...sources).iterate(signal, context)) values.push(value);
+		values.sort(comparator);
+		yield* values;
+	});
+}
+/** Collects finite merged values with delayed errors and emits them sorted by the optional comparator. */
+function sortMergedSourcesDelayError(sources, comparator) {
+	return new Flux(async function* (signal, context) {
+		const values = [];
+		for await (const value of Flux.mergeDelayError(...sources).iterate(signal, context)) values.push(value);
+		values.sort(comparator);
+		yield* values;
+	});
+}
+/** Consumes a cleanup publisher and ignores all emitted values. */
+async function drainPublisher(source, signal, context) {
+	for await (const _ of Flux.from(source).iterate(signal, context));
+}
+//#endregion
+export { Flux };
+
+//# sourceMappingURL=flux.js.map