reactor-core-ts 2.1.6 → 3.2.1

package/dist/internal/iterable-transform.js

@@ -0,0 +1,159 @@
+import { isAsyncIterable } from "./iterable.js";
+//#region src/internal/iterable-transform.ts
+/**
+* @packageDocumentation
+* Internal iterable transformation helpers.
+*/
+/** Maps an iterable, preserving synchronous iteration when possible. */
+function mapIterable(source, mapper) {
+	if (isAsyncIterable(source)) return (async function* () {
+		for await (const value of source) yield mapper(value);
+	})();
+	return (function* () {
+		for (const value of source) yield mapper(value);
+	})();
+}
+/** Filters an iterable, preserving synchronous iteration when possible. */
+function filterIterable(source, predicate) {
+	if (isAsyncIterable(source)) return (async function* () {
+		for await (const value of source) if (predicate(value)) yield value;
+	})();
+	return (function* () {
+		for (const value of source) if (predicate(value)) yield value;
+	})();
+}
+/** Takes values while a predicate returns true, preserving synchronous iteration when possible. */
+function takeWhileIterable(source, predicate) {
+	if (isAsyncIterable(source)) return (async function* () {
+		for await (const value of source) {
+			if (!predicate(value)) return;
+			yield value;
+		}
+	})();
+	return (function* () {
+		for (const value of source) {
+			if (!predicate(value)) return;
+			yield value;
+		}
+	})();
+}
+/** Takes values until a predicate returns true, preserving synchronous iteration when possible. */
+function takeUntilIterable(source, predicate) {
+	if (isAsyncIterable(source)) return (async function* () {
+		for await (const value of source) {
+			yield value;
+			if (predicate(value)) return;
+		}
+	})();
+	return (function* () {
+		for (const value of source) {
+			yield value;
+			if (predicate(value)) return;
+		}
+	})();
+}
+/** Skips a fixed number of values, preserving synchronous iteration when possible. */
+function skipIterable(source, count) {
+	if (isAsyncIterable(source)) return (async function* () {
+		let skipped = 0;
+		for await (const value of source) if (skipped < count) skipped += 1;
+		else yield value;
+	})();
+	return (function* () {
+		let skipped = 0;
+		for (const value of source) if (skipped < count) skipped += 1;
+		else yield value;
+	})();
+}
+/** Skips values while a predicate returns true, preserving synchronous iteration when possible. */
+function skipWhileIterable(source, predicate) {
+	if (isAsyncIterable(source)) return (async function* () {
+		let skipping = true;
+		for await (const value of source) {
+			if (skipping && predicate(value)) continue;
+			skipping = false;
+			yield value;
+		}
+	})();
+	return (function* () {
+		let skipping = true;
+		for (const value of source) {
+			if (skipping && predicate(value)) continue;
+			skipping = false;
+			yield value;
+		}
+	})();
+}
+/** Keeps the first value for every selected key, preserving synchronous iteration when possible. */
+function distinctIterable(source, keySelector) {
+	if (isAsyncIterable(source)) return (async function* () {
+		const seen = /* @__PURE__ */ new Set();
+		for await (const value of source) {
+			const key = keySelector(value);
+			if (!seen.has(key)) {
+				seen.add(key);
+				yield value;
+			}
+		}
+	})();
+	return (function* () {
+		const seen = /* @__PURE__ */ new Set();
+		for (const value of source) {
+			const key = keySelector(value);
+			if (!seen.has(key)) {
+				seen.add(key);
+				yield value;
+			}
+		}
+	})();
+}
+/** Keeps values whose selected key differs from the previous key. */
+function distinctUntilChangedIterable(source, keySelector) {
+	if (isAsyncIterable(source)) return (async function* () {
+		let hasPrevious = false;
+		let previous;
+		for await (const value of source) {
+			const key = keySelector(value);
+			if (!hasPrevious || !Object.is(previous, key)) {
+				hasPrevious = true;
+				previous = key;
+				yield value;
+			}
+		}
+	})();
+	return (function* () {
+		let hasPrevious = false;
+		let previous;
+		for (const value of source) {
+			const key = keySelector(value);
+			if (!hasPrevious || !Object.is(previous, key)) {
+				hasPrevious = true;
+				previous = key;
+				yield value;
+			}
+		}
+	})();
+}
+/** Emits a fallback value when the source is empty. */
+function defaultIfEmptyIterable(source, defaultValue) {
+	if (isAsyncIterable(source)) return (async function* () {
+		let empty = true;
+		for await (const value of source) {
+			empty = false;
+			yield value;
+		}
+		if (empty) yield defaultValue;
+	})();
+	return (function* () {
+		let empty = true;
+		for (const value of source) {
+			empty = false;
+			yield value;
+		}
+		if (empty) yield defaultValue;
+	})();
+}
+//#endregion
+export { defaultIfEmptyIterable, distinctIterable, distinctUntilChangedIterable, filterIterable, mapIterable, skipIterable, skipWhileIterable, takeUntilIterable, takeWhileIterable };
+
+//# sourceMappingURL=iterable-transform.js.map

package/dist/internal/iterable-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable-transform.js","names":[],"sources":["../../src/internal/iterable-transform.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Internal iterable transformation helpers.\n */\nimport {type AnyIterable, isAsyncIterable} from \"@/internal/iterable.js\";\n\n/** Maps an iterable, preserving synchronous iteration when possible. */\nexport function mapIterable<T, R>(source: AnyIterable<T>, mapper: (value: T) => R): AnyIterable<R> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            for await (const value of source) {\n                yield mapper(value);\n            }\n        })();\n    }\n    return (function* () {\n        for (const value of source) {\n            yield mapper(value);\n        }\n    })();\n}\n\n/** Filters an iterable, preserving synchronous iteration when possible. */\nexport function filterIterable<T>(source: AnyIterable<T>, predicate: (value: T) => boolean): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            for await (const value of source) {\n                if (predicate(value)) {\n                    yield value;\n                }\n            }\n        })();\n    }\n    return (function* () {\n        for (const value of source) {\n            if (predicate(value)) {\n                yield value;\n            }\n        }\n    })();\n}\n\n/** Takes values while a predicate returns true, preserving synchronous iteration when possible. */\nexport function takeWhileIterable<T>(source: AnyIterable<T>, predicate: (value: T) => boolean): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            for await (const value of source) {\n                if (!predicate(value)) {\n                    return;\n                }\n                yield value;\n            }\n        })();\n    }\n    return (function* () {\n        for (const value of source) {\n            if (!predicate(value)) {\n                return;\n            }\n            yield value;\n        }\n    })();\n}\n\n/** Takes values until a predicate returns true, preserving synchronous iteration when possible. */\nexport function takeUntilIterable<T>(source: AnyIterable<T>, predicate: (value: T) => boolean): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            for await (const value of source) {\n                yield value;\n                if (predicate(value)) {\n                    return;\n                }\n            }\n        })();\n    }\n    return (function* () {\n        for (const value of source) {\n            yield value;\n            if (predicate(value)) {\n                return;\n            }\n        }\n    })();\n}\n\n/** Skips a fixed number of values, preserving synchronous iteration when possible. */\nexport function skipIterable<T>(source: AnyIterable<T>, count: number): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            let skipped = 0;\n            for await (const value of source) {\n                if (skipped < count) {\n                    skipped += 1;\n                } else {\n                    yield value;\n                }\n            }\n        })();\n    }\n    return (function* () {\n        let skipped = 0;\n        for (const value of source) {\n            if (skipped < count) {\n                skipped += 1;\n            } else {\n                yield value;\n            }\n        }\n    })();\n}\n\n/** Skips values while a predicate returns true, preserving synchronous iteration when possible. */\nexport function skipWhileIterable<T>(source: AnyIterable<T>, predicate: (value: T) => boolean): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            let skipping = true;\n            for await (const value of source) {\n                if (skipping && predicate(value)) {\n                    continue;\n                }\n                skipping = false;\n                yield value;\n            }\n        })();\n    }\n    return (function* () {\n        let skipping = true;\n        for (const value of source) {\n            if (skipping && predicate(value)) {\n                continue;\n            }\n            skipping = false;\n            yield value;\n        }\n    })();\n}\n\n/** Keeps the first value for every selected key, preserving synchronous iteration when possible. */\nexport function distinctIterable<T, K>(source: AnyIterable<T>, keySelector: (value: T) => K): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            const seen = new Set<K>();\n            for await (const value of source) {\n                const key = keySelector(value);\n                if (!seen.has(key)) {\n                    seen.add(key);\n                    yield value;\n                }\n            }\n        })();\n    }\n    return (function* () {\n        const seen = new Set<K>();\n        for (const value of source) {\n            const key = keySelector(value);\n            if (!seen.has(key)) {\n                seen.add(key);\n                yield value;\n            }\n        }\n    })();\n}\n\n/** Keeps values whose selected key differs from the previous key. */\nexport function distinctUntilChangedIterable<T, K>(\n    source: AnyIterable<T>,\n    keySelector: (value: T) => K\n): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            let hasPrevious = false;\n            let previous: K | undefined;\n            for await (const value of source) {\n                const key = keySelector(value);\n                if (!hasPrevious || !Object.is(previous, key)) {\n                    hasPrevious = true;\n                    previous = key;\n                    yield value;\n                }\n            }\n        })();\n    }\n    return (function* () {\n        let hasPrevious = false;\n        let previous: K | undefined;\n        for (const value of source) {\n            const key = keySelector(value);\n            if (!hasPrevious || !Object.is(previous, key)) {\n                hasPrevious = true;\n                previous = key;\n                yield value;\n            }\n        }\n    })();\n}\n\n/** Emits a fallback value when the source is empty. */\nexport function defaultIfEmptyIterable<T>(source: AnyIterable<T>, defaultValue: T): AnyIterable<T> {\n    if (isAsyncIterable<T>(source)) {\n        return (async function* () {\n            let empty = true;\n            for await (const value of source) {\n                empty = false;\n                yield value;\n            }\n            if (empty) {\n                yield defaultValue;\n            }\n        })();\n    }\n    return (function* () {\n        let empty = true;\n        for (const value of source) {\n            empty = false;\n            yield value;\n        }\n        if (empty) {\n            yield defaultValue;\n        }\n    })();\n}\n"],"mappings":"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"}

package/dist/internal/iterable.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @packageDocumentation
+ * Internal async iteration and cancellation utilities.
+ */
+/** Source that can be consumed through either sync or async iteration. */
+export type AnyIterable<T> = Iterable<T> | AsyncIterable<T>;
+/** Shared empty iterable reused by stateless empty publishers. */
+export declare const EMPTY_ITERABLE: Iterable<never>;
+/** Returns true when `value` implements the async iterable protocol. */
+export declare function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T>;
+/** Returns true when `value` implements the synchronous iterable protocol. */
+export declare function isIterable<T>(value: unknown): value is Iterable<T>;
+/** Returns a reusable completed iterator result when no return value is needed. */
+export declare function doneResult<T>(): IteratorResult<T>;
+/** Returns a reusable resolved completed iterator result promise. */
+export declare function resolvedDoneResult<T>(): Promise<IteratorResult<T>>;
+/** Returns an async iterable that stays pending until the signal is aborted. */
+export declare function neverIterable(signal: AbortSignal): AsyncIterable<never>;
+/** Closes an async iterator and ignores cleanup failures. */
+export declare function closeAsyncIterator<T>(iterator: AsyncIterator<T>): Promise<void>;
+/** Converts a synchronous or asynchronous iterable into an async iterator. */
+export declare function toAsyncIterator<T>(source: AnyIterable<T>): AsyncIterator<T>;
+//# sourceMappingURL=iterable.d.ts.map

package/dist/internal/iterable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable.d.ts","sourceRoot":"","sources":["../../src/internal/iterable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,0EAA0E;AAC1E,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;AAkB5D,kEAAkE;AAClE,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,KAAK,CAAkB,CAAC;AAE9D,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAAC,CAAC,CAAC,CAE5E;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,CAAC,CAElE;AAED,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,CAAC,KAAK,cAAc,CAAC,CAAC,CAAC,CAEjD;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,CAAC,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAElE;AAED,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,CAAC,KAAK,CAAC,CAUvE;AAED,6DAA6D;AAC7D,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAMrF;AAED,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CA2B3E"}

package/dist/internal/iterable.js

@@ -0,0 +1,81 @@
+//#region src/internal/iterable.ts
+/** Shared completed iterator result reused by internal iterators. */
+var DONE_RESULT = Object.freeze({
+	done: true,
+	value: void 0
+});
+/** Shared resolved promise for completed iterator results. */
+var DONE_PROMISE = Promise.resolve(DONE_RESULT);
+/** Shared empty iterable reused by stateless empty publishers. */
+var EMPTY_ITERABLE = Object.freeze({
+	/** Returns the shared completed iterator result. */
+	next: doneResult,
+	/** Returns this stateless iterator. */
+	[Symbol.iterator]() {
+		return this;
+	}
+});
+/** Returns true when `value` implements the async iterable protocol. */
+function isAsyncIterable(value) {
+	return typeof value?.[Symbol.asyncIterator] === "function";
+}
+/** Returns true when `value` implements the synchronous iterable protocol. */
+function isIterable(value) {
+	return typeof value?.[Symbol.iterator] === "function";
+}
+/** Returns a reusable completed iterator result when no return value is needed. */
+function doneResult() {
+	return DONE_RESULT;
+}
+/** Returns a reusable resolved completed iterator result promise. */
+function resolvedDoneResult() {
+	return DONE_PROMISE;
+}
+/** Returns an async iterable that stays pending until the signal is aborted. */
+function neverIterable(signal) {
+	return (async function* () {
+		await new Promise((_resolve, reject) => {
+			if (signal.aborted) {
+				reject(signal.reason);
+				return;
+			}
+			signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+		});
+	})();
+}
+/** Closes an async iterator and ignores cleanup failures. */
+async function closeAsyncIterator(iterator) {
+	try {
+		await iterator.return?.();
+	} catch {}
+}
+/** Converts a synchronous or asynchronous iterable into an async iterator. */
+function toAsyncIterator(source) {
+	if (isAsyncIterable(source)) return source[Symbol.asyncIterator]();
+	const iterator = source[Symbol.iterator]();
+	return {
+		/** Returns the next synchronous iterator value as a promise. */
+		next() {
+			return Promise.resolve(iterator.next());
+		},
+		/** Delegates return to the synchronous iterator when available. */
+		return(value) {
+			const returnFn = iterator.return;
+			if (returnFn) return Promise.resolve(returnFn.call(iterator, value));
+			return value === void 0 ? resolvedDoneResult() : Promise.resolve({
+				done: true,
+				value
+			});
+		},
+		/** Delegates throw to the synchronous iterator when available. */
+		throw(error) {
+			const throwFn = iterator.throw;
+			if (throwFn) return Promise.resolve(throwFn.call(iterator, error));
+			return Promise.reject(error);
+		}
+	};
+}
+//#endregion
+export { EMPTY_ITERABLE, closeAsyncIterator, doneResult, isAsyncIterable, isIterable, neverIterable, resolvedDoneResult, toAsyncIterator };
+
+//# sourceMappingURL=iterable.js.map

package/dist/internal/iterable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable.js","names":[],"sources":["../../src/internal/iterable.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Internal async iteration and cancellation utilities.\n */\n/** Source that can be consumed through either sync or async iteration. */\nexport type AnyIterable<T> = Iterable<T> | AsyncIterable<T>;\n\n/** Shared completed iterator result reused by internal iterators. */\nconst DONE_RESULT: IteratorReturnResult<never> = Object.freeze({done: true, value: undefined as never});\n\n/** Shared resolved promise for completed iterator results. */\nconst DONE_PROMISE = Promise.resolve(DONE_RESULT);\n\n/** Shared empty iterator used by stateless empty publishers. */\nconst EMPTY_ITERATOR: Iterator<never> & Iterable<never> = Object.freeze({\n    /** Returns the shared completed iterator result. */\n    next: doneResult,\n    /** Returns this stateless iterator. */\n    [Symbol.iterator]() {\n        return this;\n    }\n});\n\n/** Shared empty iterable reused by stateless empty publishers. */\nexport const EMPTY_ITERABLE: Iterable<never> = EMPTY_ITERATOR;\n\n/** Returns true when `value` implements the async iterable protocol. */\nexport function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {\n    return typeof (value as { [Symbol.asyncIterator]?: unknown })?.[Symbol.asyncIterator] === \"function\";\n}\n\n/** Returns true when `value` implements the synchronous iterable protocol. */\nexport function isIterable<T>(value: unknown): value is Iterable<T> {\n    return typeof (value as { [Symbol.iterator]?: unknown })?.[Symbol.iterator] === \"function\";\n}\n\n/** Returns a reusable completed iterator result when no return value is needed. */\nexport function doneResult<T>(): IteratorResult<T> {\n    return DONE_RESULT as IteratorResult<T>;\n}\n\n/** Returns a reusable resolved completed iterator result promise. */\nexport function resolvedDoneResult<T>(): Promise<IteratorResult<T>> {\n    return DONE_PROMISE as Promise<IteratorResult<T>>;\n}\n\n/** Returns an async iterable that stays pending until the signal is aborted. */\nexport function neverIterable(signal: AbortSignal): AsyncIterable<never> {\n    return (async function* () {\n        await new Promise<void>((_resolve, reject) => {\n            if (signal.aborted) {\n                reject(signal.reason);\n                return;\n            }\n            signal.addEventListener(\"abort\", () => reject(signal.reason), {once: true});\n        });\n    })();\n}\n\n/** Closes an async iterator and ignores cleanup failures. */\nexport async function closeAsyncIterator<T>(iterator: AsyncIterator<T>): Promise<void> {\n    try {\n        await iterator.return?.();\n    } catch {\n        // best-effort cleanup\n    }\n}\n\n/** Converts a synchronous or asynchronous iterable into an async iterator. */\nexport function toAsyncIterator<T>(source: AnyIterable<T>): AsyncIterator<T> {\n    if (isAsyncIterable<T>(source)) {\n        return source[Symbol.asyncIterator]();\n    }\n    const iterator = source[Symbol.iterator]();\n    return {\n        /** Returns the next synchronous iterator value as a promise. */\n        next() {\n            return Promise.resolve(iterator.next());\n        },\n        /** Delegates return to the synchronous iterator when available. */\n        return(value?: unknown) {\n            const returnFn = iterator.return;\n            if (returnFn) {\n                return Promise.resolve(returnFn.call(iterator, value));\n            }\n            return value === undefined ? resolvedDoneResult<T>() : Promise.resolve({done: true, value: value as T});\n        },\n        /** Delegates throw to the synchronous iterator when available. */\n        throw(error?: unknown) {\n            const throwFn = iterator.throw;\n            if (throwFn) {\n                return Promise.resolve(throwFn.call(iterator, error));\n            }\n            return Promise.reject(error);\n        }\n    };\n}\n"],"mappings":";;AAQA,IAAM,cAA2C,OAAO,OAAO;CAAC,MAAM;CAAM,OAAO;AAAkB,CAAC;;AAGtG,IAAM,eAAe,QAAQ,QAAQ,WAAW;;AAahD,IAAa,iBAV6C,OAAO,OAAO;;CAEpE,MAAM;;CAEN,CAAC,OAAO,YAAY;EAChB,OAAO;CACX;AACJ,CAG+C;;AAG/C,SAAgB,gBAAmB,OAA2C;CAC1E,OAAO,OAAQ,QAAiD,OAAO,mBAAmB;AAC9F;;AAGA,SAAgB,WAAc,OAAsC;CAChE,OAAO,OAAQ,QAA4C,OAAO,cAAc;AACpF;;AAGA,SAAgB,aAAmC;CAC/C,OAAO;AACX;;AAGA,SAAgB,qBAAoD;CAChE,OAAO;AACX;;AAGA,SAAgB,cAAc,QAA2C;CACrE,QAAQ,mBAAmB;EACvB,MAAM,IAAI,SAAe,UAAU,WAAW;GAC1C,IAAI,OAAO,SAAS;IAChB,OAAO,OAAO,MAAM;IACpB;GACJ;GACA,OAAO,iBAAiB,eAAe,OAAO,OAAO,MAAM,GAAG,EAAC,MAAM,KAAI,CAAC;EAC9E,CAAC;CACL,EAAA,CAAG;AACP;;AAGA,eAAsB,mBAAsB,UAA2C;CACnF,IAAI;EACA,MAAM,SAAS,SAAS;CAC5B,QAAQ,CAER;AACJ;;AAGA,SAAgB,gBAAmB,QAA0C;CACzE,IAAI,gBAAmB,MAAM,GACzB,OAAO,OAAO,OAAO,cAAc,CAAC;CAExC,MAAM,WAAW,OAAO,OAAO,SAAS,CAAC;CACzC,OAAO;;EAEH,OAAO;GACH,OAAO,QAAQ,QAAQ,SAAS,KAAK,CAAC;EAC1C;;EAEA,OAAO,OAAiB;GACpB,MAAM,WAAW,SAAS;GAC1B,IAAI,UACA,OAAO,QAAQ,QAAQ,SAAS,KAAK,UAAU,KAAK,CAAC;GAEzD,OAAO,UAAU,SAAY,mBAAsB,IAAI,QAAQ,QAAQ;IAAC,MAAM;IAAa;GAAU,CAAC;EAC1G;;EAEA,MAAM,OAAiB;GACnB,MAAM,UAAU,SAAS;GACzB,IAAI,SACA,OAAO,QAAQ,QAAQ,QAAQ,KAAK,UAAU,KAAK,CAAC;GAExD,OAAO,QAAQ,OAAO,KAAK;EAC/B;CACJ;AACJ"}

package/dist/internal/microtask.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @packageDocumentation
+ * Internal browser task scheduling utilities.
+ */
+/** Schedules a task in the browser microtask queue with a small fallback. */
+export declare function scheduleMicrotask(task: () => void): void;
+//# sourceMappingURL=microtask.d.ts.map

package/dist/internal/microtask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microtask.d.ts","sourceRoot":"","sources":["../../src/internal/microtask.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAMxD"}

package/dist/internal/microtask.js

@@ -0,0 +1,19 @@
+//#region src/internal/microtask.ts
+/**
+* @packageDocumentation
+* Internal browser task scheduling utilities.
+*/
+/** Promise reused when a browser does not expose `queueMicrotask`. */
+var resolvedMicrotask = Promise.resolve();
+/** Schedules a task in the browser microtask queue with a small fallback. */
+function scheduleMicrotask(task) {
+	if (typeof queueMicrotask === "function") {
+		queueMicrotask(task);
+		return;
+	}
+	resolvedMicrotask.then(task);
+}
+//#endregion
+export { scheduleMicrotask };
+
+//# sourceMappingURL=microtask.js.map

package/dist/internal/microtask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"microtask.js","names":[],"sources":["../../src/internal/microtask.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Internal browser task scheduling utilities.\n */\n\n/** Promise reused when a browser does not expose `queueMicrotask`. */\nconst resolvedMicrotask = Promise.resolve();\n\n/** Schedules a task in the browser microtask queue with a small fallback. */\nexport function scheduleMicrotask(task: () => void): void {\n    if (typeof queueMicrotask === \"function\") {\n        queueMicrotask(task);\n        return;\n    }\n    void resolvedMicrotask.then(task);\n}\n"],"mappings":";;;;;;AAMA,IAAM,oBAAoB,QAAQ,QAAQ;;AAG1C,SAAgB,kBAAkB,MAAwB;CACtD,IAAI,OAAO,mBAAmB,YAAY;EACtC,eAAe,IAAI;EACnB;CACJ;CACA,AAAK,kBAAkB,KAAK,IAAI;AACpC"}

package/dist/publisher/browser-sources.d.ts

@@ -0,0 +1,15 @@
+import type { SourceFactory } from "./types.js";
+/** Options used when creating a Flux from a browser WebSocket. */
+export interface WebSocketFluxOptions {
+    /** Protocol or protocols passed to the browser WebSocket constructor when a URL is provided. */
+    readonly protocols?: string | string[];
+    /** Binary data format assigned to the socket before listening for messages. */
+    readonly binaryType?: BinaryType;
+    /** Closes the socket when the Flux subscription is cancelled. Defaults to true for URL-created sockets. */
+    readonly closeOnCancel?: boolean;
+}
+/** Creates a lazy source factory from browser events. */
+export declare function eventSource<TEvent extends Event>(target: EventTarget, type: string, options?: boolean | AddEventListenerOptions): SourceFactory<TEvent>;
+/** Creates a lazy source factory from browser WebSocket message events. */
+export declare function webSocketSource<T>(input: WebSocket | string | URL, options?: string | string[] | WebSocketFluxOptions): SourceFactory<MessageEvent<T>>;
+//# sourceMappingURL=browser-sources.d.ts.map

package/dist/publisher/browser-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-sources.d.ts","sourceRoot":"","sources":["../../src/publisher/browser-sources.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,sBAAsB,CAAC;AAExD,kEAAkE;AAClE,MAAM,WAAW,oBAAoB;IACjC,gGAAgG;IAChG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,2GAA2G;IAC3G,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,MAAM,SAAS,KAAK,EAC5C,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC5C,aAAa,CAAC,MAAM,CAAC,CAkBvB;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,CAAC,EAC7B,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,GAAG,EAC/B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,oBAAoB,GACnD,aAAa,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CA0ChC"}

package/dist/publisher/browser-sources.js

@@ -0,0 +1,92 @@
+import { throwIfNullish } from "../errors/helpers.js";
+import { AsyncQueue } from "../internal/async-queue.js";
+//#region src/publisher/browser-sources.ts
+/**
+* @packageDocumentation
+* Browser source adapters used by Flux static factories.
+*/
+/** Creates a lazy source factory from browser events. */
+function eventSource(target, type, options) {
+	throwIfNullish(target, "target");
+	throwIfNullish(type, "type");
+	return (signal) => {
+		const queue = new AsyncQueue(signal);
+		if (signal.aborted) return queue;
+		const listener = (event) => {
+			queue.push(event);
+		};
+		const cleanup = () => {
+			target.removeEventListener(type, listener, options);
+		};
+		target.addEventListener(type, listener, options);
+		signal.addEventListener("abort", cleanup, { once: true });
+		return queue;
+	};
+}
+/** Creates a lazy source factory from browser WebSocket message events. */
+function webSocketSource(input, options) {
+	throwIfNullish(input, "input");
+	return (signal) => {
+		const queue = new AsyncQueue(signal);
+		if (signal.aborted) return queue;
+		const { closeOnCancel, socket } = webSocketFrom(input, options);
+		let cleaned = false;
+		const onMessage = (event) => {
+			queue.push(event);
+		};
+		const onError = (event) => {
+			cleanup(false);
+			queue.error(event);
+		};
+		const onClose = () => {
+			cleanup(false);
+			queue.complete();
+		};
+		const onAbort = () => {
+			cleanup(true);
+		};
+		function cleanup(cancelled) {
+			if (cleaned) return;
+			cleaned = true;
+			socket.removeEventListener("message", onMessage);
+			socket.removeEventListener("error", onError);
+			socket.removeEventListener("close", onClose);
+			signal.removeEventListener("abort", onAbort);
+			if (cancelled) closeWebSocket(socket, closeOnCancel);
+		}
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("error", onError);
+		socket.addEventListener("close", onClose);
+		signal.addEventListener("abort", onAbort, { once: true });
+		return queue;
+	};
+}
+/** Normalizes browser WebSocket options while keeping the common protocols-only shorthand. */
+function webSocketOptions(options) {
+	return typeof options === "string" || Array.isArray(options) ? { protocols: options } : options ?? {};
+}
+/** Creates or reuses a browser WebSocket and returns its cancellation ownership policy. */
+function webSocketFrom(input, options) {
+	const normalized = webSocketOptions(options);
+	const ownsSocket = typeof input === "string" || input instanceof URL;
+	const socket = ownsSocket ? openWebSocket(input, normalized.protocols) : input;
+	if (normalized.binaryType !== void 0) socket.binaryType = normalized.binaryType;
+	return {
+		closeOnCancel: normalized.closeOnCancel ?? ownsSocket,
+		socket
+	};
+}
+/** Opens a browser WebSocket or fails clearly when the runtime does not provide one. */
+function openWebSocket(url, protocols) {
+	const WebSocketConstructor = globalThis.WebSocket;
+	if (typeof WebSocketConstructor !== "function") throw new TypeError("WebSocket is not available in this runtime");
+	return protocols === void 0 ? new WebSocketConstructor(url) : new WebSocketConstructor(url, protocols);
+}
+/** Closes a WebSocket when this Flux owns the socket or the caller requested close-on-cancel. */
+function closeWebSocket(socket, closeOnCancel) {
+	if (closeOnCancel && socket.readyState < 2) socket.close();
+}
+//#endregion
+export { eventSource, webSocketSource };
+
+//# sourceMappingURL=browser-sources.js.map

package/dist/publisher/browser-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-sources.js","names":[],"sources":["../../src/publisher/browser-sources.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Browser source adapters used by Flux static factories.\n */\nimport {throwIfNullish} from \"@/errors/helpers.js\";\nimport {AsyncQueue} from \"@/internal/async-queue.js\";\nimport type {SourceFactory} from \"@/publisher/types.js\";\n\n/** Options used when creating a Flux from a browser WebSocket. */\nexport interface WebSocketFluxOptions {\n    /** Protocol or protocols passed to the browser WebSocket constructor when a URL is provided. */\n    readonly protocols?: string | string[];\n    /** Binary data format assigned to the socket before listening for messages. */\n    readonly binaryType?: BinaryType;\n    /** Closes the socket when the Flux subscription is cancelled. Defaults to true for URL-created sockets. */\n    readonly closeOnCancel?: boolean;\n}\n\n/** Creates a lazy source factory from browser events. */\nexport function eventSource<TEvent extends Event>(\n    target: EventTarget,\n    type: string,\n    options?: boolean | AddEventListenerOptions\n): SourceFactory<TEvent> {\n    throwIfNullish(target, \"target\");\n    throwIfNullish(type, \"type\");\n    return signal => {\n        const queue = new AsyncQueue<TEvent>(signal);\n        if (signal.aborted) {\n            return queue;\n        }\n        const listener = (event: Event) => {\n            queue.push(event as TEvent);\n        };\n        const cleanup = () => {\n            target.removeEventListener(type, listener, options);\n        };\n        target.addEventListener(type, listener, options);\n        signal.addEventListener(\"abort\", cleanup, {once: true});\n        return queue;\n    };\n}\n\n/** Creates a lazy source factory from browser WebSocket message events. */\nexport function webSocketSource<T>(\n    input: WebSocket | string | URL,\n    options?: string | string[] | WebSocketFluxOptions\n): SourceFactory<MessageEvent<T>> {\n    throwIfNullish(input, \"input\");\n    return signal => {\n        const queue = new AsyncQueue<MessageEvent<T>>(signal);\n        if (signal.aborted) {\n            return queue;\n        }\n        const {closeOnCancel, socket} = webSocketFrom(input, options);\n        let cleaned = false;\n        const onMessage = (event: MessageEvent) => {\n            queue.push(event as MessageEvent<T>);\n        };\n        const onError = (event: Event) => {\n            cleanup(false);\n            queue.error(event);\n        };\n        const onClose = () => {\n            cleanup(false);\n            queue.complete();\n        };\n        const onAbort = () => {\n            cleanup(true);\n        };\n        function cleanup(cancelled: boolean): void {\n            if (cleaned) {\n                return;\n            }\n            cleaned = true;\n            socket.removeEventListener(\"message\", onMessage);\n            socket.removeEventListener(\"error\", onError);\n            socket.removeEventListener(\"close\", onClose);\n            signal.removeEventListener(\"abort\", onAbort);\n            if (cancelled) {\n                closeWebSocket(socket, closeOnCancel);\n            }\n        }\n        socket.addEventListener(\"message\", onMessage);\n        socket.addEventListener(\"error\", onError);\n        socket.addEventListener(\"close\", onClose);\n        signal.addEventListener(\"abort\", onAbort, {once: true});\n        return queue;\n    };\n}\n\n/** Normalizes browser WebSocket options while keeping the common protocols-only shorthand. */\nfunction webSocketOptions(options?: string | string[] | WebSocketFluxOptions): WebSocketFluxOptions {\n    return typeof options === \"string\" || Array.isArray(options) ? {protocols: options} : options ?? {};\n}\n\n/** Creates or reuses a browser WebSocket and returns its cancellation ownership policy. */\nfunction webSocketFrom(\n    input: WebSocket | string | URL,\n    options?: string | string[] | WebSocketFluxOptions\n): { readonly closeOnCancel: boolean; readonly socket: WebSocket } {\n    const normalized = webSocketOptions(options);\n    const ownsSocket = typeof input === \"string\" || input instanceof URL;\n    const socket = ownsSocket ? openWebSocket(input, normalized.protocols) : input;\n    if (normalized.binaryType !== undefined) {\n        socket.binaryType = normalized.binaryType;\n    }\n    return {\n        closeOnCancel: normalized.closeOnCancel ?? ownsSocket,\n        socket\n    };\n}\n\n/** Opens a browser WebSocket or fails clearly when the runtime does not provide one. */\nfunction openWebSocket(url: string | URL, protocols?: string | string[]): WebSocket {\n    const WebSocketConstructor = globalThis.WebSocket;\n    if (typeof WebSocketConstructor !== \"function\") {\n        throw new TypeError(\"WebSocket is not available in this runtime\");\n    }\n    return protocols === undefined ? new WebSocketConstructor(url) : new WebSocketConstructor(url, protocols);\n}\n\n/** Closes a WebSocket when this Flux owns the socket or the caller requested close-on-cancel. */\nfunction closeWebSocket(socket: WebSocket, closeOnCancel: boolean): void {\n    if (closeOnCancel && socket.readyState < 2) {\n        socket.close();\n    }\n}\n"],"mappings":";;;;;;;;AAmBA,SAAgB,YACZ,QACA,MACA,SACqB;CACrB,eAAe,QAAQ,QAAQ;CAC/B,eAAe,MAAM,MAAM;CAC3B,QAAO,WAAU;EACb,MAAM,QAAQ,IAAI,WAAmB,MAAM;EAC3C,IAAI,OAAO,SACP,OAAO;EAEX,MAAM,YAAY,UAAiB;GAC/B,MAAM,KAAK,KAAe;EAC9B;EACA,MAAM,gBAAgB;GAClB,OAAO,oBAAoB,MAAM,UAAU,OAAO;EACtD;EACA,OAAO,iBAAiB,MAAM,UAAU,OAAO;EAC/C,OAAO,iBAAiB,SAAS,SAAS,EAAC,MAAM,KAAI,CAAC;EACtD,OAAO;CACX;AACJ;;AAGA,SAAgB,gBACZ,OACA,SAC8B;CAC9B,eAAe,OAAO,OAAO;CAC7B,QAAO,WAAU;EACb,MAAM,QAAQ,IAAI,WAA4B,MAAM;EACpD,IAAI,OAAO,SACP,OAAO;EAEX,MAAM,EAAC,eAAe,WAAU,cAAc,OAAO,OAAO;EAC5D,IAAI,UAAU;EACd,MAAM,aAAa,UAAwB;GACvC,MAAM,KAAK,KAAwB;EACvC;EACA,MAAM,WAAW,UAAiB;GAC9B,QAAQ,KAAK;GACb,MAAM,MAAM,KAAK;EACrB;EACA,MAAM,gBAAgB;GAClB,QAAQ,KAAK;GACb,MAAM,SAAS;EACnB;EACA,MAAM,gBAAgB;GAClB,QAAQ,IAAI;EAChB;EACA,SAAS,QAAQ,WAA0B;GACvC,IAAI,SACA;GAEJ,UAAU;GACV,OAAO,oBAAoB,WAAW,SAAS;GAC/C,OAAO,oBAAoB,SAAS,OAAO;GAC3C,OAAO,oBAAoB,SAAS,OAAO;GAC3C,OAAO,oBAAoB,SAAS,OAAO;GAC3C,IAAI,WACA,eAAe,QAAQ,aAAa;EAE5C;EACA,OAAO,iBAAiB,WAAW,SAAS;EAC5C,OAAO,iBAAiB,SAAS,OAAO;EACxC,OAAO,iBAAiB,SAAS,OAAO;EACxC,OAAO,iBAAiB,SAAS,SAAS,EAAC,MAAM,KAAI,CAAC;EACtD,OAAO;CACX;AACJ;;AAGA,SAAS,iBAAiB,SAA0E;CAChG,OAAO,OAAO,YAAY,YAAY,MAAM,QAAQ,OAAO,IAAI,EAAC,WAAW,QAAO,IAAI,WAAW,CAAC;AACtG;;AAGA,SAAS,cACL,OACA,SAC+D;CAC/D,MAAM,aAAa,iBAAiB,OAAO;CAC3C,MAAM,aAAa,OAAO,UAAU,YAAY,iBAAiB;CACjE,MAAM,SAAS,aAAa,cAAc,OAAO,WAAW,SAAS,IAAI;CACzE,IAAI,WAAW,eAAe,QAC1B,OAAO,aAAa,WAAW;CAEnC,OAAO;EACH,eAAe,WAAW,iBAAiB;EAC3C;CACJ;AACJ;;AAGA,SAAS,cAAc,KAAmB,WAA0C;CAChF,MAAM,uBAAuB,WAAW;CACxC,IAAI,OAAO,yBAAyB,YAChC,MAAM,IAAI,UAAU,4CAA4C;CAEpE,OAAO,cAAc,SAAY,IAAI,qBAAqB,GAAG,IAAI,IAAI,qBAAqB,KAAK,SAAS;AAC5G;;AAGA,SAAS,eAAe,QAAmB,eAA8B;CACrE,IAAI,iBAAiB,OAAO,aAAa,GACrC,OAAO,MAAM;AAErB"}

package/dist/publisher/flux-entrypoint.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @packageDocumentation
+ * Focused Flux public entrypoint.
+ */
+import "./operators/register.js";
+export { Flux } from "./flux.js";
+//# sourceMappingURL=flux-entrypoint.d.ts.map

package/dist/publisher/flux-entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flux-entrypoint.d.ts","sourceRoot":"","sources":["../../src/publisher/flux-entrypoint.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,mCAAmC,CAAC;AAE3C,OAAO,EAAC,IAAI,EAAC,MAAM,qBAAqB,CAAC"}

package/dist/publisher/flux-entrypoint.js

@@ -0,0 +1,11 @@
+import { Flux } from "./flux.js";
+import "./operators/register.js";
+//#region src/publisher/flux-entrypoint.ts
+/**
+* @packageDocumentation
+* Focused Flux public entrypoint.
+*/
+//#endregion
+export { Flux };
+
+//# sourceMappingURL=flux-entrypoint.js.map

package/dist/publisher/flux-entrypoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flux-entrypoint.js","names":[],"sources":["../../src/publisher/flux-entrypoint.ts"],"sourcesContent":["/**\n * @packageDocumentation\n * Focused Flux public entrypoint.\n */\nimport \"@/publisher/operators/register.js\";\n\nexport {Flux} from \"@/publisher/flux.js\";\n"],"mappings":""}

package/dist/publisher/flux.d.ts

@@ -0,0 +1,121 @@
+import type { Disposable } from "../core/types.js";
+import { Context } from "../context/context.js";
+import type { ContextView } from "../context/context-view.js";
+import { type AnyIterable } from "../internal/iterable.js";
+import { type WebSocketFluxOptions } from "./browser-sources.js";
+import type { Publisher } from "./publisher.js";
+import type { FluxSinkCallback, PublisherInput, SourceFactory } from "./types.js";
+import type { DurationInput, Scheduler } from "../schedulers/types.js";
+import type { Subscriber } from "../subscription/subscriber.js";
+/** Multi-value Reactive Streams publisher with Reactor-style operators. */
+export declare class Flux<T> implements Publisher<T>, AsyncIterable<T> {
+    /** Lazy source factory invoked for each subscription or async iteration. */
+    private readonly sourceFactory;
+    /** Creates a Flux from a lazy source factory. */
+    constructor(sourceFactory: SourceFactory<T>);
+    /** Creates a Flux that emits the provided values and then completes. */
+    static just<T>(...values: readonly T[]): Flux<T>;
+    /** Creates a Flux from an array-like readonly value list. */
+    static fromArray<T>(values: readonly T[]): Flux<T>;
+    /** Creates a Flux from a stream-like iterable or a lazy stream supplier. */
+    static fromStream<T>(stream: Iterable<T> | (() => Iterable<T>)): Flux<T>;
+    /** Creates a Flux from a JavaScript iterable. */
+    static fromIterable<T>(values: Iterable<T>): Flux<T>;
+    /** Creates a Flux from browser `Window` events and removes the listener on cancellation. */
+    static fromEvent<K extends keyof WindowEventMap>(target: Window, type: K, options?: boolean | AddEventListenerOptions): Flux<WindowEventMap[K]>;
+    /** Creates a Flux from browser `Document` events and removes the listener on cancellation. */
+    static fromEvent<K extends keyof DocumentEventMap>(target: Document, type: K, options?: boolean | AddEventListenerOptions): Flux<DocumentEventMap[K]>;
+    /** Creates a Flux from browser `HTMLElement` events and removes the listener on cancellation. */
+    static fromEvent<K extends keyof HTMLElementEventMap>(target: HTMLElement, type: K, options?: boolean | AddEventListenerOptions): Flux<HTMLElementEventMap[K]>;
+    /** Creates a Flux from any browser `EventTarget` and removes the listener on cancellation. */
+    static fromEvent<TEvent extends Event = Event>(target: EventTarget, type: string, options?: boolean | AddEventListenerOptions): Flux<TEvent>;
+    /** Creates a Flux from browser WebSocket message events. */
+    static fromWebSocket<T = unknown>(url: string | URL, options?: string | string[] | WebSocketFluxOptions): Flux<MessageEvent<T>>;
+    /** Creates a Flux from browser WebSocket message events. */
+    static fromWebSocket<T = unknown>(socket: WebSocket, options?: WebSocketFluxOptions): Flux<MessageEvent<T>>;
+    /** Adapts a publisher, iterable, async iterable or promise-like value to Flux. */
+    static from<T>(input: PublisherInput<T>): Flux<T>;
+    /** Creates a Flux that completes without emitting values. */
+    static empty<T = never>(): Flux<T>;
+    /** Creates a Flux that never emits or completes until cancelled. */
+    static never<T = never>(): Flux<T>;
+    /** Creates a Flux that terminates with the provided error. */
+    static error<T = never>(error: unknown | (() => unknown)): Flux<T>;
+    /** Defers source creation until subscription time. */
+    static defer<T>(supplier: () => PublisherInput<T>): Flux<T>;
+    /** Defers source creation and exposes the subscriber context. */
+    static deferContextual<T>(supplier: (context: ContextView) => PublisherInput<T>): Flux<T>;
+    /** Creates a Flux by bridging callback-style producers through a sink. */
+    static create<T>(callback: FluxSinkCallback<T>): Flux<T>;
+    /** Creates a Flux by bridging a single-threaded push-style producer through a sink. */
+    static push<T>(callback: FluxSinkCallback<T>): Flux<T>;
+    /** Creates a Flux by repeatedly invoking a synchronous generator callback. */
+    static generate<T>(generator: (sink: {
+        next(value: T): void;
+        complete(): void;
+        error(error: unknown): void;
+    }) => void): Flux<T>;
+    /** Creates a finite integer range. */
+    static range(start: number, count: number): Flux<number>;
+    /** Creates an interval Flux that emits incrementing numbers. */
+    static interval(period: DurationInput, scheduler?: Scheduler): Flux<number>;
+    /** Merges several publishers concurrently. */
+    static merge<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges several publishers concurrently and delays failures until every source terminates. */
+    static mergeDelayError<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges sources sequentially while subscribing to one source at a time. */
+    static mergeSequential<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges sources sequentially and delays failures until every source has been consumed. */
+    static mergeSequentialDelayError<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges finite sources and emits their values sorted by a comparator. */
+    static mergeComparing<T>(comparatorOrSource?: ((left: T, right: T) => number) | PublisherInput<T>, ...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges finite sources, delays failures and emits their values sorted by a comparator. */
+    static mergeComparingDelayError<T>(comparatorOrSource?: ((left: T, right: T) => number) | PublisherInput<T>, ...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges finite sources and emits their values in comparator order. */
+    static mergeOrdered<T>(comparatorOrSource?: ((left: T, right: T) => number) | PublisherInput<T>, ...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges finite sources with priority ordering. */
+    static mergePriority<T>(comparatorOrSource?: ((left: T, right: T) => number) | PublisherInput<T>, ...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Merges finite sources with priority ordering and delayed failures. */
+    static mergePriorityDelayError<T>(comparatorOrSource?: ((left: T, right: T) => number) | PublisherInput<T>, ...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Concatenates several publishers sequentially. */
+    static concat<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Concatenates several publishers sequentially and delays failures until every source has been consumed. */
+    static concatDelayError<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Relays the first source that emits any signal. */
+    static first<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Relays the first source that emits any signal. */
+    static firstWithSignal<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Relays the first source that produces a value, ignoring empty completions. */
+    static firstWithValue<T>(...sources: readonly PublisherInput<T>[]): Flux<T>;
+    /** Zips publishers by combining one value from each source. */
+    static zip<T extends readonly unknown[], R = T>(sources: {
+        [K in keyof T]: PublisherInput<T[K]>;
+    }, combinator?: (values: T) => R): Flux<R>;
+    /** Combines the latest value from each source after all sources emitted once. */
+    static combineLatest<T extends readonly unknown[], R = T>(sources: {
+        [K in keyof T]: PublisherInput<T[K]>;
+    }, combinator?: (values: T) => R): Flux<R>;
+    /** Switches to the most recent publisher emitted by an outer publisher. */
+    static switchOnNext<T>(sources: PublisherInput<PublisherInput<T>>): Flux<T>;
+    /** Uses a resource for the duration of a derived publisher and cleans it up afterwards. */
+    static using<T, D>(resourceSupplier: () => D, sourceFactory: (resource: D) => PublisherInput<T>, resourceCleanup?: (resource: D) => void): Flux<T>;
+    /** Uses an asynchronously supplied resource and runs asynchronous cleanup publishers. */
+    static usingWhen<T, D>(resourceSupplier: PublisherInput<D>, sourceFactory: (resource: D) => PublisherInput<T>, asyncComplete?: (resource: D) => PublisherInput<unknown>, asyncError?: (resource: D, error: unknown) => PublisherInput<unknown>, asyncCancel?: (resource: D) => PublisherInput<unknown>): Flux<T>;
+    /** Subscribes a full Reactive Streams subscriber. */
+    subscribe(subscriber: Subscriber<T>): void;
+    /** Subscribes callbacks and requests unbounded demand. */
+    subscribe(onNext?: (value: T) => void, onError?: (error: unknown) => void, onComplete?: () => void): Disposable;
+    /** Subscribes a normalized Reactive Streams subscriber to this Flux. */
+    protected subscribeActual(subscriber: Subscriber<T>): void;
+    /** Returns the lazy iterable backing this Flux for internal operator composition. */
+    iterate(signal: AbortSignal, context?: Context): AnyIterable<T>;
+    /** Returns an async iterator over this Flux. */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /** Returns this Flux as an async iterable. */
+    toIterable(): AsyncIterable<T>;
+    /** Collects all values into an array. */
+    toArray(): Promise<T[]>;
+    /** Resolves to the last emitted value, or undefined for an empty source. */
+    toPromise(): Promise<T | undefined>;
+}
+//# sourceMappingURL=flux.d.ts.map