@nlozgachev/pipelined 0.65.0 → 0.66.0

package/dist/{Core-BHN87zoB.mjs → Core-D7_9dZpV.mjs}

@@ -284,6 +284,189 @@ const Equality = {
 	}
 };
 //#endregion
+//#region src/Core/EventBus.ts
+const makeEventBus = (options) => ({
+	options,
+	_listeners: /* @__PURE__ */ new Set(),
+	_listenerArray: null,
+	_queue: [],
+	_isEmitting: false
+});
+const emitEventBus = (target, message) => {
+	const targets = Array.isArray(target) ? target : [target];
+	const msg = message;
+	for (const bus of targets) {
+		bus._queue.push(msg);
+		if (!bus._isEmitting) {
+			bus._isEmitting = true;
+			try {
+				while (bus._queue.length > 0) {
+					const nextMsg = bus._queue.shift();
+					if (bus._listenerArray === null) bus._listenerArray = Array.from(bus._listeners);
+					const listeners = bus._listenerArray;
+					for (const listener of listeners) try {
+						listener(nextMsg);
+					} catch (err) {
+						if (bus.options?.onError) bus.options.onError(err);
+						else throw err;
+					}
+				}
+			} finally {
+				bus._isEmitting = false;
+			}
+		}
+	}
+};
+const forwardEventBus = (options) => {
+	const targets = Array.isArray(options.to) ? options.to : [options.to];
+	const filterSet = options.only ? new Set(options.only) : null;
+	const handler = (msg) => {
+		if (filterSet !== null && !filterSet.has(msg.kind)) return;
+		for (const target of targets) emitEventBus(target, msg);
+	};
+	options.from._listeners.add(handler);
+	options.from._listenerArray = null;
+	return () => {
+		options.from._listeners.delete(handler);
+		options.from._listenerArray = null;
+	};
+};
+const listenEventBus = (bus, events, options) => {
+	const eventList = Array.isArray(events) ? events : [events];
+	const isOrdered = options?.ordered ?? false;
+	const isStrict = options?.strict ?? false;
+	const isOnce = options?.once ?? false;
+	const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+	const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+	const createMatcher = (onMatch) => {
+		let sequenceIndex = 0;
+		return (msg) => {
+			if (resetKinds !== null && resetKinds.has(msg.kind)) {
+				sequenceIndex = 0;
+				return;
+			}
+			if (!isOrdered) {
+				if (eventList.includes(msg.kind)) onMatch(msg);
+				return;
+			}
+			let expectedKind = eventList[sequenceIndex];
+			if (expectedKind !== msg.kind && optionalKinds !== null) {
+				let lookaheadIndex = sequenceIndex;
+				while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) lookaheadIndex++;
+				if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+					sequenceIndex = lookaheadIndex;
+					expectedKind = eventList[sequenceIndex];
+				}
+			}
+			if (msg.kind === expectedKind) {
+				sequenceIndex++;
+				if (sequenceIndex === eventList.length) {
+					sequenceIndex = 0;
+					onMatch(msg);
+				}
+			} else if (isStrict) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+			else if (eventList.includes(msg.kind)) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+		};
+	};
+	return {
+		reduce: (reducer, initialState) => {
+			let currentState = initialState;
+			const listenerFn = createMatcher((msg) => {
+				currentState = reducer(msg, currentState);
+				if (isOnce) {
+					bus._listeners.delete(listenerFn);
+					bus._listenerArray = null;
+				}
+			});
+			const unsubscribe = () => {
+				bus._listeners.delete(listenerFn);
+				bus._listenerArray = null;
+			};
+			bus._listeners.add(listenerFn);
+			bus._listenerArray = null;
+			return {
+				unsubscribe,
+				getState: () => currentState
+			};
+		},
+		tap: (effect) => {
+			const listenerFn = createMatcher((msg) => {
+				effect(msg);
+				if (isOnce) {
+					bus._listeners.delete(listenerFn);
+					bus._listenerArray = null;
+				}
+			});
+			const unsubscribe = () => {
+				bus._listeners.delete(listenerFn);
+				bus._listenerArray = null;
+			};
+			bus._listeners.add(listenerFn);
+			bus._listenerArray = null;
+			return unsubscribe;
+		}
+	};
+};
+const EventBus = {
+	/**
+	* Constructs a new `EventBus` instance.
+	*
+	* @example
+	* ```ts
+	* const bus = EventBus.make<AppMessages>({ name: "app" });
+	* ```
+	*/
+	make: makeEventBus,
+	/**
+	* Emits a message payload to one or more target event buses.
+	*
+	* Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
+	*
+	* @example
+	* ```ts
+	* EventBus.emit(busA, {
+	*   kind: "userLoggedIn",
+	*   value: { userId: "user-1" },
+	* });
+	*
+	* EventBus.emit([busA, busB], {
+	*   kind: "userLoggedIn",
+	*   value: { userId: "user-1" },
+	* });
+	* ```
+	*/
+	emit: emitEventBus,
+	/**
+	* Forwards messages from one event bus to another (or multiple).
+	*
+	* @example
+	* ```ts
+	* const stop = EventBus.forward({
+	*   from: authBus,
+	*   to: analyticsBus,
+	*   only: ["userLoggedIn"],
+	* });
+	* ```
+	*/
+	forward: forwardEventBus,
+	/**
+	* Initiates listener registration on an event bus for specific event kind(s) or sequence.
+	*
+	* @example
+	* ```ts
+	* const sub = EventBus.listen(
+	*   appBus,
+	*   ["userLoggedIn", "checkoutStarted"],
+	*   { ordered: true }
+	* ).reduce(
+	*   (msg, state) => ({ count: state.count + 1 }),
+	*   { count: 0 }
+	* );
+	* ```
+	*/
+	listen: listenEventBus
+};
+//#endregion
 //#region src/Core/Lazy.ts
 const fromFn = (f) => {
 	let done = false;
@@ -763,6 +946,24 @@ const Maybe = {
 		Result: (data) => Result.is.ok(data) ? makeSome$1(data.value) : makeNone$1()
 	},
 	/**
+	* Wraps a synchronous operation that may throw, returning a `Maybe<A>`.
+	* Returns `Some(value)` if successful, or `None` if an exception is thrown.
+	*
+	* @example
+	* ```ts
+	* const safeParse = (s: string) => Maybe.tryCatch(() => JSON.parse(s));
+	* safeParse('{"a": 1}'); // Some({ a: 1 })
+	* safeParse('invalid');   // None
+	* ```
+	*/
+	tryCatch: (f) => {
+		try {
+			return makeSome$1(f());
+		} catch {
+			return makeNone$1();
+		}
+	},
+	/**
 	* Transforms the value inside a Maybe if it exists.
 	*
 	* @example
@@ -849,16 +1050,32 @@ const Maybe = {
 		return data;
 	},
 	/**
-	* Filters a Maybe based on a predicate.
+	* Executes a side effect when the Maybe is None, without changing the Maybe.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Maybe.make.none(),
+	*   Maybe.tapNone(() => console.log("Value missing")),
+	* );
+	* ```
+	*/
+	tapNone: (f) => (data) => {
+		if (isNone(data)) f();
+		return data;
+	},
+	/**
+	* Filters a Maybe based on a predicate or type guard.
 	* Returns None if the predicate returns false or if the Maybe is already None.
 	*
 	* @example
 	* ```ts
 	* pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
 	* pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
+	* pipe(Maybe.make.some("hi"), Maybe.filter((x): x is string => typeof x === "string")); // Some("hi")
 	* ```
 	*/
-	filter: (predicate) => (data) => isSome(data) ? predicate(data.value) ? data : makeNone$1() : data,
+	filter: ((predicate) => (data) => isSome(data) ? predicate(data.value) ? data : makeNone$1() : data),
 	/**
 	* Recovers from a None by providing a fallback Maybe.
 	* The fallback can produce a different type, widening the result to `Maybe<A | B>`.
@@ -3837,189 +4054,6 @@ const State = {
 	}
 };
 //#endregion
-//#region src/Core/Stream.ts
-const makeStream = (options) => ({
-	options,
-	_listeners: /* @__PURE__ */ new Set(),
-	_listenerArray: null,
-	_queue: [],
-	_isEmitting: false
-});
-const emitStream = (target, message) => {
-	const targets = Array.isArray(target) ? target : [target];
-	const msg = message;
-	for (const stream of targets) {
-		stream._queue.push(msg);
-		if (!stream._isEmitting) {
-			stream._isEmitting = true;
-			try {
-				while (stream._queue.length > 0) {
-					const nextMsg = stream._queue.shift();
-					if (stream._listenerArray === null) stream._listenerArray = Array.from(stream._listeners);
-					const listeners = stream._listenerArray;
-					for (const listener of listeners) try {
-						listener(nextMsg);
-					} catch (err) {
-						if (stream.options?.onError) stream.options.onError(err);
-						else throw err;
-					}
-				}
-			} finally {
-				stream._isEmitting = false;
-			}
-		}
-	}
-};
-const forwardStream = (options) => {
-	const targets = Array.isArray(options.to) ? options.to : [options.to];
-	const filterSet = options.only ? new Set(options.only) : null;
-	const handler = (msg) => {
-		if (filterSet !== null && !filterSet.has(msg.kind)) return;
-		for (const target of targets) emitStream(target, msg);
-	};
-	options.from._listeners.add(handler);
-	options.from._listenerArray = null;
-	return () => {
-		options.from._listeners.delete(handler);
-		options.from._listenerArray = null;
-	};
-};
-const listenStream = (stream, events, options) => {
-	const eventList = Array.isArray(events) ? events : [events];
-	const isOrdered = options?.ordered ?? false;
-	const isStrict = options?.strict ?? false;
-	const isOnce = options?.once ?? false;
-	const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
-	const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
-	const createMatcher = (onMatch) => {
-		let sequenceIndex = 0;
-		return (msg) => {
-			if (resetKinds !== null && resetKinds.has(msg.kind)) {
-				sequenceIndex = 0;
-				return;
-			}
-			if (!isOrdered) {
-				if (eventList.includes(msg.kind)) onMatch(msg);
-				return;
-			}
-			let expectedKind = eventList[sequenceIndex];
-			if (expectedKind !== msg.kind && optionalKinds !== null) {
-				let lookaheadIndex = sequenceIndex;
-				while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) lookaheadIndex++;
-				if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
-					sequenceIndex = lookaheadIndex;
-					expectedKind = eventList[sequenceIndex];
-				}
-			}
-			if (msg.kind === expectedKind) {
-				sequenceIndex++;
-				if (sequenceIndex === eventList.length) {
-					sequenceIndex = 0;
-					onMatch(msg);
-				}
-			} else if (isStrict) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
-			else if (eventList.includes(msg.kind)) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
-		};
-	};
-	return {
-		reduce: (reducer, initialState) => {
-			let currentState = initialState;
-			const listenerFn = createMatcher((msg) => {
-				currentState = reducer(msg, currentState);
-				if (isOnce) {
-					stream._listeners.delete(listenerFn);
-					stream._listenerArray = null;
-				}
-			});
-			const unsubscribe = () => {
-				stream._listeners.delete(listenerFn);
-				stream._listenerArray = null;
-			};
-			stream._listeners.add(listenerFn);
-			stream._listenerArray = null;
-			return {
-				unsubscribe,
-				getState: () => currentState
-			};
-		},
-		tap: (effect) => {
-			const listenerFn = createMatcher((msg) => {
-				effect(msg);
-				if (isOnce) {
-					stream._listeners.delete(listenerFn);
-					stream._listenerArray = null;
-				}
-			});
-			const unsubscribe = () => {
-				stream._listeners.delete(listenerFn);
-				stream._listenerArray = null;
-			};
-			stream._listeners.add(listenerFn);
-			stream._listenerArray = null;
-			return unsubscribe;
-		}
-	};
-};
-const Stream = {
-	/**
-	* Constructs a new `Stream` instance.
-	*
-	* @example
-	* ```ts
-	* const stream = Stream.make<AppMessages>({ name: "app" });
-	* ```
-	*/
-	make: makeStream,
-	/**
-	* Emits a message payload to one or more target streams.
-	*
-	* Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
-	*
-	* @example
-	* ```ts
-	* Stream.emit(streamA, {
-	*   kind: "userLoggedIn",
-	*   value: { userId: "user-1" },
-	* });
-	*
-	* Stream.emit([streamA, streamB], {
-	*   kind: "userLoggedIn",
-	*   value: { userId: "user-1" },
-	* });
-	* ```
-	*/
-	emit: emitStream,
-	/**
-	* Forwards messages from one stream to another (or multiple).
-	*
-	* @example
-	* ```ts
-	* const stop = Stream.forward({
-	*   from: authStream,
-	*   to: analyticsStream,
-	*   only: ["userLoggedIn"],
-	* });
-	* ```
-	*/
-	forward: forwardStream,
-	/**
-	* Initiates listener registration on a stream for specific event kind(s) or sequence.
-	*
-	* @example
-	* ```ts
-	* const sub = Stream.listen(
-	*   appStream,
-	*   ["userLoggedIn", "checkoutStarted"],
-	*   { ordered: true }
-	* ).reduce(
-	*   (msg, state) => ({ count: state.count + 1 }),
-	*   { count: 0 }
-	* );
-	* ```
-	*/
-	listen: listenStream
-};
-//#endregion
 //#region src/Core/TaskMaybe.ts
 const makeSome = (value) => Task.resolve(Maybe.make.some(value));
 const makeNone = () => Task.resolve(Maybe.make.none());
@@ -4481,14 +4515,15 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* Retries a fallible Task.Result according to a RetryPolicy.
 	* If the task succeeds, returns Ok immediately.
 	* If the task fails, retries up to policy.attempts times with delays generated by policy.
+	* An optional `when` predicate selectively retries only specific errors (e.g. transient network errors).
 	*
 	* @example
 	* ```ts
 	* const policy = RetryPolicy.exponential({ attempts: 3, initial: Duration.milliseconds(100) });
-	* const retryableFetch = pipe(fetchData, Task.Result.retry(policy));
+	* const retryableFetch = pipe(fetchData, Task.Result.retry(policy, { when: (err) => isTransient(err) }));
 	* ```
 	*/
-	retry: (policy) => (task) => (signal) => Deferred.from.Promise((() => {
+	retry: (policy, options) => (task) => (signal) => Deferred.from.Promise((() => {
 		const { attempts } = policy;
 		const wait = (duration) => new Promise((res) => {
 			let timerId;
@@ -4496,10 +4531,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 				clearTimeout(timerId);
 				res();
 			};
-			if (signal) {
-				if (signal.aborted) return res();
-				signal.addEventListener("abort", onAbort, { once: true });
-			}
+			if (signal) signal.addEventListener("abort", onAbort, { once: true });
 			timerId = setTimeout(() => {
 				signal?.removeEventListener("abort", onAbort);
 				res();
@@ -4507,6 +4539,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 		});
 		const executeAttempt = (attempt) => Deferred.to.Promise(task(signal)).then((res) => {
 			if (Result.is.ok(res) || attempt >= attempts || signal?.aborted) return res;
+			if (options?.when && !options.when(res.error)) return res;
 			const delay = policy.getDelay(attempt);
 			return wait(delay).then(() => executeAttempt(attempt + 1));
 		});
@@ -4564,7 +4597,35 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* // [Ok(val1), Err(err2), Ok(val3)]
 	* ```
 	*/
-	allSettled: (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))))
+	allSettled: (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal))))),
+	/**
+	* Narrows the Ok value with a predicate. If the predicate returns false,
+	* converts the value to an Err using onFail.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Task.Result.make.ok(42),
+	*   Task.Result.ensure(n => n > 50, () => "too small")
+	* ); // Task.Result resolving to Err("too small")
+	* ```
+	*/
+	ensure: (predicate, onFail) => (task) => (signal) => Deferred.from.Promise(Deferred.to.Promise(task(signal)).then(Result.ensure(predicate, onFail))),
+	/**
+	* Maps both the Err and Ok channels simultaneously.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Task.Result.make.ok(42),
+	*   Task.Result.bimap(
+	*     (err: string) => new Error(err),
+	*     (n: number) => n * 2
+	*   )
+	* ); // Task.Result resolving to Ok(84)
+	* ```
+	*/
+	bimap: (onErr, onOk) => (task) => (signal) => Deferred.from.Promise(Deferred.to.Promise(task(signal)).then(Result.bimap(onErr, onOk)))
 };
 //#endregion
 //#region src/internal/InternalTypes.ts
@@ -5360,14 +5421,33 @@ sync: syncTask },
 	})),
 	/**
 	* Runs multiple Tasks in parallel and collects their results.
+	* An optional `concurrency` option limits the number of tasks executing at any given time.
 	*
 	* @example
 	* ```ts
 	* Task.all([loadConfig, detectLocale, loadTheme])();
 	* // Deferred<[Config, string, Theme]>
+	*
+	* Task.all([loadConfig, detectLocale, loadTheme], { concurrency: 2 })();
 	* ```
 	*/
-	all: (tasks) => fromPromise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))),
+	all: (tasks, options) => fromPromise((signal) => {
+		const concurrency = options?.concurrency;
+		if (concurrency === void 0 || concurrency <= 0 || tasks.length <= concurrency) return Promise.all(tasks.map((t) => toPromise(t, signal)));
+		const len = tasks.length;
+		const results = new Array(len);
+		let nextIndex = 0;
+		const worker = async () => {
+			while (nextIndex < len) {
+				const currentIndex = nextIndex++;
+				results[currentIndex] = await toPromise(tasks[currentIndex], signal);
+			}
+		};
+		const workerCount = Math.min(concurrency, len);
+		const workers = [];
+		for (let i = 0; i < workerCount; i++) workers.push(worker());
+		return Promise.all(workers).then(() => results);
+	}),
 	/**
 	* Delays the execution of a Task by the specified duration.
 	* Useful for debouncing or rate limiting.
@@ -5434,21 +5514,21 @@ sync: syncTask },
 		return run(times);
 	}),
 	/**
-	* Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-	* An optional delay duration can be inserted between runs.
-	* An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+	* Polls a Task repeatedly until the result satisfies a predicate, returning that result.
+	* An optional delay duration can be inserted between polling runs.
+	* An optional `attempts` cap stops the loop after N calls — the last value is returned
 	* regardless of whether the predicate was satisfied.
 	*
 	* @example
 	* ```ts
 	* pipe(
 	*   checkStatus,
-	*   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+	*   Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
 	* )(); // polls every 500ms until status is "ready"
 	* ```
 	*/
-	repeatUntil: (options) => (task) => fromPromise((signal) => {
-		const { when: predicate, delay: delayDuration, maxAttempts } = options;
+	poll: (options) => (task) => fromPromise((signal) => {
+		const { until: predicate, delay: delayDuration, attempts } = options;
 		const wait = () => new Promise((r) => {
 			let timerId;
 			const onAbort = () => {
@@ -5465,7 +5545,7 @@ sync: syncTask },
 			if (signal?.aborted && lastValue !== void 0) return Promise.resolve(lastValue);
 			return toPromise(task, signal).then((a) => {
 				if (predicate(a)) return a;
-				if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+				if (attempts !== void 0 && attempt >= attempts) return a;
 				if (signal?.aborted) return a;
 				return wait().then(() => run(attempt + 1, a));
 			});
@@ -6007,4 +6087,4 @@ const These = {
 	}
 };
 //#endregion
-export { Combinable as C, Deferred as S, Maybe as _, Stream as a, Lazy as b, Resource as c, Reader as d, Predicate as f, Op as g, Optional as h, isNonEmptyArr as i, RemoteData as l, Ordering as m, Task as n, State as o, Pair as p, Validation as r, Result as s, These as t, Refinement as u, Logged as v, Equality as x, Lens as y };
+export { Combinable as C, Deferred as S, Logged as _, State as a, EventBus as b, RemoteData as c, Predicate as d, Pair as f, Maybe as g, Op as h, isNonEmptyArr as i, Refinement as l, Optional as m, Task as n, Result as o, Ordering as p, Validation as r, Resource as s, These as t, Reader as u, Lens as v, Equality as x, Lazy as y };

package/dist/core.cjs

@@ -1,8 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_Core = require("./Core-BDXRLmMa.cjs");
+const require_Core = require("./Core-6SkC-fh5.cjs");
 exports.Combinable = require_Core.Combinable;
 exports.Deferred = require_Core.Deferred;
 exports.Equality = require_Core.Equality;
+exports.EventBus = require_Core.EventBus;
 exports.Lazy = require_Core.Lazy;
 exports.Lens = require_Core.Lens;
 exports.Logged = require_Core.Logged;
@@ -18,7 +19,6 @@ exports.RemoteData = require_Core.RemoteData;
 exports.Resource = require_Core.Resource;
 exports.Result = require_Core.Result;
 exports.State = require_Core.State;
-exports.Stream = require_Core.Stream;
 exports.Task = require_Core.Task;
 exports.These = require_Core.These;
 exports.Validation = require_Core.Validation;

package/dist/core.d.cts

@@ -1,3 +1,3 @@
 import { x as Deferred } from "./InternalTypes-B1Lh9uw_.cjs";
-import { A as Logged, C as Pair, D as Maybe, E as Op, M as Lazy, N as Equality, O as None, P as Combinable, S as Predicate, T as Optional, _ as NotAsked, a as Task, b as Refinement, c as Validation, d as Err, f as Ok, g as Loading, h as Failure, i as TheseSecond, j as Lens, k as Some, l as Stream, m as Resource, n as TheseBoth, o as Failed, p as Result, r as TheseFirst, s as Passed, t as These, u as State, v as RemoteData, w as Ordering, x as Reader, y as Success } from "./index-DCK_VPog.cjs";
-export { Combinable, Deferred, Equality, Err, Failed, Failure, Lazy, Lens, Loading, Logged, Maybe, None, NotAsked, Ok, Op, Optional, Ordering, Pair, Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, Some, State, Stream, Success, Task, These, TheseBoth, TheseFirst, TheseSecond, Validation };
+import { A as Lens, C as Ordering, D as None, E as Maybe, M as EventBus, N as Equality, O as Some, P as Combinable, S as Pair, T as Op, _ as RemoteData, a as Task, b as Reader, c as Validation, d as Ok, f as Result, g as NotAsked, h as Loading, i as TheseSecond, j as Lazy, k as Logged, l as State, m as Failure, n as TheseBoth, o as Failed, p as Resource, r as TheseFirst, s as Passed, t as These, u as Err, v as Success, w as Optional, x as Predicate, y as Refinement } from "./index-8A9NqJTq.cjs";
+export { Combinable, Deferred, Equality, Err, EventBus, Failed, Failure, Lazy, Lens, Loading, Logged, Maybe, None, NotAsked, Ok, Op, Optional, Ordering, Pair, Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, Some, State, Success, Task, These, TheseBoth, TheseFirst, TheseSecond, Validation };

package/dist/core.d.ts

@@ -1,3 +1,3 @@
 import { x as Deferred } from "./InternalTypes-DzDey5Do.js";
-import { A as Logged, C as Pair, D as Maybe, E as Op, M as Lazy, N as Equality, O as None, P as Combinable, S as Predicate, T as Optional, _ as NotAsked, a as Task, b as Refinement, c as Validation, d as Err, f as Ok, g as Loading, h as Failure, i as TheseSecond, j as Lens, k as Some, l as Stream, m as Resource, n as TheseBoth, o as Failed, p as Result, r as TheseFirst, s as Passed, t as These, u as State, v as RemoteData, w as Ordering, x as Reader, y as Success } from "./index-B07Wr815.js";
-export { Combinable, Deferred, Equality, Err, Failed, Failure, Lazy, Lens, Loading, Logged, Maybe, None, NotAsked, Ok, Op, Optional, Ordering, Pair, Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, Some, State, Stream, Success, Task, These, TheseBoth, TheseFirst, TheseSecond, Validation };
+import { A as Lens, C as Ordering, D as None, E as Maybe, M as EventBus, N as Equality, O as Some, P as Combinable, S as Pair, T as Op, _ as RemoteData, a as Task, b as Reader, c as Validation, d as Ok, f as Result, g as NotAsked, h as Loading, i as TheseSecond, j as Lazy, k as Logged, l as State, m as Failure, n as TheseBoth, o as Failed, p as Resource, r as TheseFirst, s as Passed, t as These, u as Err, v as Success, w as Optional, x as Predicate, y as Refinement } from "./index-CY4ZLbjM.js";
+export { Combinable, Deferred, Equality, Err, EventBus, Failed, Failure, Lazy, Lens, Loading, Logged, Maybe, None, NotAsked, Ok, Op, Optional, Ordering, Pair, Passed, Predicate, Reader, Refinement, RemoteData, Resource, Result, Some, State, Success, Task, These, TheseBoth, TheseFirst, TheseSecond, Validation };

package/dist/core.mjs

@@ -1,2 +1,2 @@
-import { C as Combinable, S as Deferred, _ as Maybe, a as Stream, b as Lazy, c as Resource, d as Reader, f as Predicate, g as Op, h as Optional, l as RemoteData, m as Ordering, n as Task, o as State, p as Pair, r as Validation, s as Result, t as These, u as Refinement, v as Logged, x as Equality, y as Lens } from "./Core-BHN87zoB.mjs";
-export { Combinable, Deferred, Equality, Lazy, Lens, Logged, Maybe, Op, Optional, Ordering, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, Task, These, Validation };
+import { C as Combinable, S as Deferred, _ as Logged, a as State, b as EventBus, c as RemoteData, d as Predicate, f as Pair, g as Maybe, h as Op, l as Refinement, m as Optional, n as Task, o as Result, p as Ordering, r as Validation, s as Resource, t as These, u as Reader, v as Lens, x as Equality, y as Lazy } from "./Core-D7_9dZpV.mjs";
+export { Combinable, Deferred, Equality, EventBus, Lazy, Lens, Logged, Maybe, Op, Optional, Ordering, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Task, These, Validation };