evt - npm Package Compare versions

dist/lib/types/helper/UnpackCtx.d.ts

dist/lib/types/helper/UnpackCtx.js

dist/lib/types/helper/UnpackCtx.js.map

src/lib/types/helper/UnpackCtx.ts

40

dist/lib/Ctx.d.ts

		import { Handler } from "./types/Handler";
		import { Evt } from "./Evt";
		declare type EvtCore<T> = import("./EvtCore").EvtCore<T>;
		declare type Done<T> = [Error \| null, T, Handler.WithEvt<any>[]];
		declare type EvtLike<T> = import("./Evt").EvtLike<T>;
		export declare type CtxEvtDoneData<Result> = [Error \| null, Result, Handler.WithEvt<any, Result>[]];
		export interface CtxLike<Result = any> {
		done(result: Result): void;
		abort(error: Error): void;
		zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: EvtLike<T>): void;
		zz__removeHandler<T>(handler: Handler<T, any, CtxLike<Result>>): void;
		}
		/** https://docs.evt.land/api/ctx */
		export declare class Ctx<T = any> {
		export declare class Ctx<Result> implements CtxLike<Result> {
		/**
		@@ -12,3 +18,3 @@ * https://docs.evt.land/api/ctx#ctx-getevtdone
		*/
		readonly getEvtDone: () => Evt<Done<T>>;
		readonly getEvtDone: () => Evt<CtxEvtDoneData<Result>>;
		/**
		@@ -24,3 +30,3 @@ *
		*/
		getPrDone(timeout?: number): Promise<T>;
		getPrDone(timeout?: number): Promise<Result>;
		/**
		@@ -31,3 +37,3 @@ * https://docs.evt.land/api/ctx#ctx-getevtattach
		* */
		readonly getEvtAttach: () => Evt<Handler.WithEvt<any>>;
		readonly getEvtAttach: () => Evt<Handler.WithEvt<any, Result>>;
		/**
		@@ -38,3 +44,3 @@ * https://docs.evt.land/api/ctx#ctx-getevtdetach
		* */
		readonly getEvtDetach: () => Evt<Handler.WithEvt<any>>;
		readonly getEvtDetach: () => Evt<Handler.WithEvt<any, Result>>;
		private readonly onDone;
		@@ -51,3 +57,3 @@ private readonly onAttach;
		*/
		abort(error: Error): Handler.WithEvt<any>[];
		abort(error: Error): Handler.WithEvt<any, Result>[];
		/**
		@@ -60,3 +66,3 @@ * https://docs.evt.land/api/ctx#ctx-done-result
		*/
		done(result: T): Handler.WithEvt<any>[];
		done(result: Result): Handler.WithEvt<any, Result>[];
		/** Detach all handler bound to this context from theirs respective Evt and post getEvtDone() */
		@@ -67,9 +73,13 @@ private __done;
		/** https://docs.evt.land/api/ctx#ctx-gethandlers */
		getHandlers(): Handler.WithEvt<any>[];
		static __addHandlerToCtxCore<T>(handler: Handler<T, any, Ctx<T>>, evt: EvtCore<T>): void;
		static __removeHandlerFromCtxCore(handler: Handler<any, any, Ctx>): void;
		static __matchHandlerBoundToCtx<T>(handler: Handler<T, any>): handler is Handler<T, any, Ctx>;
		getHandlers(): Handler.WithEvt<any, Result>[];
		/** Exposed only to enable safe interoperability between mismatching EVT versions, do not use */
		zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: EvtLike<T>): void;
		/** Exposed only to enable safe interoperability between EVT versions, do not use */
		zz__removeHandler<T>(handler: Handler<T, any, CtxLike<Result>>): void;
		}
		export interface VoidCtxLike extends CtxLike<void> {
		done(): void;
		}
		/** https://docs.evt.land/api/ctx */
		export declare class VoidCtx extends Ctx<undefined> {
		export declare class VoidCtx extends Ctx<void> implements VoidCtxLike {
		/**
		@@ -80,4 +90,4 @@ * Detach all handlers.
		*/
		done(): ReturnType<typeof Ctx.prototype.done>;
		done(): Handler.WithEvt<any, void>[];
		}
		export {};

28

dist/lib/Ctx.js

		@@ -46,2 +46,4 @@ "use strict";
		var getLazyEvtFactory_1 = require("./util/getLazyEvtFactory");
		var assert_1 = require("../tools/typeSafety/assert");
		var typeGuard_1 = require("../tools/typeSafety/typeGuard");
		/** https://docs.evt.land/api/ctx */
		@@ -149,20 +151,20 @@ var Ctx = /** @class */ (function () {
		};
		Ctx.__addHandlerToCtxCore = function (handler, evt) {
		var ctx = handler.ctx;
		ctx.handlers.add(handler);
		ctx.evtByHandler.set(handler, evt);
		ctx.onAttach({ handler: handler, evt: evt });
		/** Exposed only to enable safe interoperability between mismatching EVT versions, do not use */
		Ctx.prototype.zz__addHandler = function (handler, evt) {
		assert_1.assert(handler.ctx === this);
		assert_1.assert(typeGuard_1.typeGuard(handler));
		this.handlers.add(handler);
		this.evtByHandler.set(handler, evt);
		this.onAttach({ handler: handler, evt: evt });
		};
		Ctx.__removeHandlerFromCtxCore = function (handler) {
		var ctx = handler.ctx;
		ctx.onDetach({ handler: handler, "evt": ctx.evtByHandler.get(handler) });
		ctx.handlers["delete"](handler);
		/** Exposed only to enable safe interoperability between EVT versions, do not use */
		Ctx.prototype.zz__removeHandler = function (handler) {
		assert_1.assert(handler.ctx === this);
		assert_1.assert(typeGuard_1.typeGuard(handler));
		this.onDetach({ handler: handler, "evt": this.evtByHandler.get(handler) });
		this.handlers["delete"](handler);
		};
		Ctx.__matchHandlerBoundToCtx = function (handler) {
		return handler.ctx !== undefined;
		};
		return Ctx;
		}());
		exports.Ctx = Ctx;
		//NOTE: Could be declared only, but in case someone import it, to avoid runtime error we declare it.
		/** https://docs.evt.land/api/ctx */
		@@ -169,0 +171,0 @@ var VoidCtx = /** @class */ (function (_super) {

263

dist/lib/Evt.d.ts

		@@ -1,2 +0,2 @@
		import { EvtCore } from "./EvtCore";
		import "minimal-polyfills/dist/lib/Array.prototype.find";
		import { Handler } from "./types/Handler";
		@@ -8,4 +8,9 @@ import { Operator } from "./types/Operator";
		declare type VoidCtx = import("./Ctx").VoidCtx;
		declare type CtxLike<Result> = import("./Ctx").CtxLike<Result>;
		export declare const setPostCount: (evt: Evt<any>, value: number) => void;
		export interface EvtLike<T> {
		isHandled(data?: T): void;
		}
		/** https://docs.evt.land/api/evt */
		export declare class Evt<T> extends EvtCore<T> {
		export declare class Evt<T> implements EvtLike<any> {
		/**
		@@ -34,20 +39,103 @@ * https://docs.evt.land/api/evt/newctx
		readonly getEvtDetach: () => Evt<Handler<T, any>>;
		private readonly onHandler;
		constructor();
		/** https://docs.evt.land/api/evt/post */
		postAsyncOnceHandled(data: T): number \| Promise<number>;
		private __maxHandlers;
		/**
		*
		* By default EventEmitters will print a warning if more than 25 handlers are added for
		* a particular event. This is a useful default that helps finding memory leaks.
		* Not all events should be limited to 25 handlers. The evt.setMaxHandlers() method allows the limit to be
		* modified for this specific EventEmitter instance.
		* The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
		* Returns a reference to the EventEmitter, so that calls can be chained.
		*
		*/
		setMaxHandlers(n: number): this;
		/**
		* https://docs.evt.land/api/evt/post
		*
		* Number of times .post(data) have been called.
		*/
		readonly postCount: number;
		private traceId;
		private traceFormatter;
		private log;
		/** https://docs.evt.land/api/evt/enabletrace */
		enableTrace(id: string, formatter?: (data: T) => string, log?: (message?: any, ...optionalParams: any[]) => void): void;
		/** https://docs.evt.land/api/evt/enabletrace */
		disableTrace(): void;
		private readonly handlers;
		private readonly handlerTriggers;
		private readonly asyncHandlerChronologyMark;
		private readonly asyncHandlerChronologyExceptionRange;
		private readonly getChronologyMark;
		private readonly statelessByStatefulOp;
		private detachHandler;
		private static doDetachIfNeeded;
		private triggerHandler;
		private addHandler;
		/** https://docs.evt.land/api/evt/getstatelessop */
		getStatelessOp<U, CtxResult>(op: Operator<T, U, CtxResult>): Operator.Stateless<T, U, CtxResult>;
		private trace;
		/**
		* https://garronej.github.io/ts-evt/#evtattach-evtattachonce-and-evtpost
		*
		* Returns post count
		* */
		post(data: T): number;
		/** Return isExtracted */
		private postSync;
		private readonly postAsync;
		private __waitFor;
		private __attach;
		private __attachExtract;
		private __attachPrepend;
		private __attachOnce;
		private __attachOncePrepend;
		private __attachOnceExtract;
		/**
		* https://docs.evt.land/api/evt/ishandled
		*
		* Test if posting a given event data will have an effect.
		*
		* Return true if:
		* -There is at least one handler matching
		* this event data ( at least one handler's callback function
		* will be invoked if the data is posted. )
		* -Handlers could be will be detached
		* if the event data is posted.
		*
		*/
		isHandled(data: T): boolean;
		/** https://docs.evt.land/api/evt/gethandler */
		getHandlers(): Handler<T, any>[];
		/**
		* https://docs.evt.land/api/evt/detach
		*
		* Detach every handlers of the Evt that are bound to the provided context
		* */
		detach<CtxResult>(ctx: CtxLike<CtxResult>): Handler<T, any, CtxLike<CtxResult>>[];
		/**
		* https://docs.evt.land/api/evt/detach
		*
		* (unsafe) Detach every handlers from the Evt
		* */
		detach(): Handler<T, any>[];
		private __parseOverloadParams;
		/** https://docs.evt.land/api/evt/pipe */
		pipe(): Evt<T>;
		pipe<U>(op: Operator.fλ<T, U>): Evt<U>;
		pipe<U, CtxResult>(op: Operator.fλ<T, U, CtxResult>): Evt<U>;
		pipe<U extends T>(op: (data: T) => data is U): Evt<U>;
		pipe(op: (data: T) => boolean): Evt<T>;
		pipe(ctx: Ctx): Evt<T>;
		pipe<U>(ctx: Ctx, op: Operator.fλ<T, U>): Evt<U>;
		pipe<U extends T>(ctx: Ctx, op: (data: T) => data is U): Evt<U>;
		pipe(ctx: Ctx, op: (data: T) => boolean): Evt<T>;
		pipe<B, C>(op1: Operator.fλ<T, B>, op2: Operator.fλ<B, C>): Evt<C>;
		pipe<B, C extends B>(op1: Operator.fλ<T, B>, op2: (data: B) => data is C): Evt<C>;
		pipe<B>(op1: Operator.fλ<T, B>, op2: (data: B) => boolean): Evt<B>;
		pipe<B extends T, C>(op1: (data: T) => data is B, op2: Operator.fλ<B, C>): Evt<B>;
		pipe<B>(op1: (data: T) => boolean, op2: Operator.fλ<T, B>): Evt<B>;
		pipe(ctx: CtxLike<any>): Evt<T>;
		pipe<U, CtxResult>(ctx: CtxLike<any>, op: Operator.fλ<T, U, CtxResult>): Evt<U>;
		pipe<U extends T>(ctx: CtxLike<any>, op: (data: T) => data is U): Evt<U>;
		pipe(ctx: CtxLike<any>, op: (data: T) => boolean): Evt<T>;
		pipe<B, C, CtxResultOp1, CtxResultOp2>(op1: Operator.fλ<T, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>): Evt<C>;
		pipe<B, C extends B, CtxResult>(op1: Operator.fλ<T, B, CtxResult>, op2: (data: B) => data is C): Evt<C>;
		pipe<B, CtxResult>(op1: Operator.fλ<T, B, CtxResult>, op2: (data: B) => boolean): Evt<B>;
		pipe<B extends T, C, CtxResult>(op1: (data: T) => data is B, op2: Operator.fλ<B, C, CtxResult>): Evt<B>;
		pipe<B, CtxResult>(op1: (data: T) => boolean, op2: Operator.fλ<T, B, CtxResult>): Evt<B>;
		pipe<B extends T, C extends B>(op1: (data: T) => data is B, op2: (data: B) => data is C): Evt<C>;
		@@ -57,12 +145,12 @@ pipe<B extends T>(op1: (data: T) => data is B, op2: (data: B) => boolean): Evt<B>;
		pipe<T>(op1: (data: T) => boolean, op2: (data: T) => boolean): Evt<T>;
		pipe<B, C, D>(op1: Operator.fλ<T, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>): Evt<D>;
		pipe<B, C, D, E>(op1: Operator.fλ<T, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>, op4: Operator.fλ<D, E>): Evt<E>;
		pipe<B, C, D, E>(op1: Operator.fλ<T, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>, op4: Operator.fλ<D, E>): Evt<E>;
		pipe<B, C, D, E, F>(op1: Operator.fλ<T, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>, op4: Operator.fλ<D, E>, op5: Operator.fλ<E, F>): Evt<F>;
		pipe<B, C>(op1: Operator<T, B>, op2: Operator<B, C>): Evt<C>;
		pipe<B, C, D>(op1: Operator<T, B>, op2: Operator<B, C>, op3: Operator<C, D>): Evt<D>;
		pipe<B, C, D, E>(op1: Operator<T, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>): Evt<E>;
		pipe<B, C, D, E, F>(op1: Operator<T, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>): Evt<F>;
		pipe(...ops: [Operator<T, any>, ...Operator<any, any>[]]): Evt<any>;
		pipe<T>(...ops: [Operator<T, any>, ...Operator<any, any>[]]): Evt<any>;
		pipe<B, C, D, CtxResultOp1, CtxResultOp2, CtxResultOp3>(op1: Operator.fλ<T, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>): Evt<D>;
		pipe<B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(op1: Operator.fλ<T, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>, op4: Operator.fλ<D, E, CtxResultOp4>): Evt<E>;
		pipe<B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(op1: Operator.fλ<T, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>, op4: Operator.fλ<D, E, CtxResultOp4>): Evt<E>;
		pipe<B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(op1: Operator.fλ<T, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>, op4: Operator.fλ<D, E, CtxResultOp4>, op5: Operator.fλ<E, F, CtxResultOp5>): Evt<F>;
		pipe<B, C, CtxResultOp1 = any, CtxResultOp2 = any>(op1: Operator<T, B, CtxResultOp2>, op2: Operator<B, C, CtxResultOp2>): Evt<C>;
		pipe<B, C, D, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any>(op1: Operator<T, B, CtxResultOp1>, op2: Operator<B, C, CtxResultOp2>, op3: Operator<C, D, CtxResultOp3>): Evt<D>;
		pipe<B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(op1: Operator<T, B, CtxResultOp1>, op2: Operator<B, C, CtxResultOp2>, op3: Operator<C, D, CtxResultOp3>, op4: Operator<D, E, CtxResultOp4>): Evt<E>;
		pipe<B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(op1: Operator<T, B, CtxResultOp1>, op2: Operator<B, C, CtxResultOp2>, op3: Operator<C, D, CtxResultOp3>, op4: Operator<D, E, CtxResultOp4>, op5: Operator<E, F, CtxResultOp5>): Evt<F>;
		pipe(...ops: [Operator<T, any, any>, ...Operator<any, any, any>[]]): Evt<any>;
		pipe<T>(...ops: [Operator<T, any, any>, ...Operator<any, any, any>[]]): Evt<any>;
		/**
		@@ -77,3 +165,3 @@ * https://docs.evt.land/api/evt/waitfor
		*/
		waitFor<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, timeout?: number): Promise<U>;
		waitFor<U, CtxResult>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, timeout?: number): Promise<U>;
		/**
		@@ -88,3 +176,3 @@ * https://docs.evt.land/api/evt/waitfor
		*/
		waitFor<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout?: number): Promise<Q>;
		waitFor<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout?: number): Promise<Q>;
		/**
		@@ -99,3 +187,3 @@ * https://docs.evt.land/api/evt/waitfor
		*/
		waitFor(op: (data: T) => boolean, ctx: Ctx, timeout?: number): Promise<T>;
		waitFor(op: (data: T) => boolean, ctx: CtxLike<any>, timeout?: number): Promise<T>;
		/**
		@@ -108,3 +196,3 @@ * https://docs.evt.land/api/evt/waitfor
		*/
		waitFor<U>(op: Operator.fλ.Stateless<T, U>, timeout?: number): Promise<U>;
		waitFor<U, CtxResult>(op: Operator.fλ.Stateless<T, U, CtxResult>, timeout?: number): Promise<U>;
		/**
		@@ -133,3 +221,3 @@ * https://docs.evt.land/api/evt/waitfor
		*/
		waitFor(ctx: Ctx, timeout?: number): Promise<T>;
		waitFor(ctx: CtxLike<any>, timeout?: number): Promise<T>;
		/**
		@@ -152,3 +240,3 @@ * https://docs.evt.land/api/evt/waitfor
		*/
		$attach<U>(op: Operator.fλ<T, U>, ctx: Ctx, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attach<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, ctx: CtxLike<any>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -163,3 +251,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attach<U>(op: Operator.fλ<T, U>, ctx: Ctx, callback: (transformedData: U) => void): Promise<U>;
		$attach<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, ctx: CtxLike<CtxResult>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -174,3 +262,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attach<U>(op: Operator.fλ<T, U>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attach<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -183,3 +271,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attach<U>(op: Operator.fλ<T, U>, callback: (transformedData: U) => void): Promise<U>;
		$attach<U, R>(op: Operator.fλ<T, U, R>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -196,3 +284,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attach<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout: number, callback: (data: Q) => void): Promise<Q>;
		attach<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout: number, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -209,3 +297,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attach(op: (data: T) => boolean, ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attach(op: (data: T) => boolean, ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -220,3 +308,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attach<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, callback: (data: Q) => void): Promise<Q>;
		attach<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -231,3 +319,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attach(op: (data: T) => boolean, ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attach(op: (data: T) => boolean, ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -262,3 +350,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attach(ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attach(ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -287,3 +375,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attach(ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attach(ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -314,3 +402,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnce<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachOnce<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -325,3 +413,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnce<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, callback: (transformedData: U) => void): Promise<U>;
		$attachOnce<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -336,3 +424,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnce<U>(op: Operator.fλ.Stateless<T, U>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachOnce<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -345,3 +433,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnce<U>(op: Operator.fλ.Stateless<T, U>, callback: (transformedData: U) => void): Promise<U>;
		$attachOnce<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -358,3 +446,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnce<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout: number, callback: (data: Q) => void): Promise<Q>;
		attachOnce<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout: number, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -371,3 +459,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnce(op: (data: T) => boolean, ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachOnce(op: (data: T) => boolean, ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -382,3 +470,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnce<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, callback: (data: Q) => void): Promise<Q>;
		attachOnce<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -393,3 +481,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnce(op: (data: T) => boolean, ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachOnce(op: (data: T) => boolean, ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -424,3 +512,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnce(ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachOnce(ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -449,3 +537,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnce(ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachOnce(ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -476,3 +564,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachExtract<U>(op: Operator.fλ<T, U>, ctx: Ctx, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachExtract<U, CtxResult>(op: Operator.fλ<T, U, CtxResult>, ctx: CtxLike<any>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -487,3 +575,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachExtract<U>(op: Operator.fλ<T, U>, ctx: Ctx, callback: (transformedData: U) => void): Promise<U>;
		$attachExtract<U, CtxResult>(op: Operator.fλ<T, U, CtxResult>, ctx: CtxLike<any>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -498,3 +586,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachExtract<U>(op: Operator.fλ<T, U>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachExtract<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -507,3 +595,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachExtract<U>(op: Operator.fλ<T, U>, callback: (transformedData: U) => void): Promise<U>;
		$attachExtract<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -520,3 +608,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachExtract<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout: number, callback: (data: Q) => void): Promise<Q>;
		attachExtract<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout: number, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -533,3 +621,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachExtract(op: (data: T) => boolean, ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachExtract(op: (data: T) => boolean, ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -544,3 +632,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachExtract<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, callback: (data: Q) => void): Promise<Q>;
		attachExtract<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -555,3 +643,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachExtract(op: (data: T) => boolean, ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachExtract(op: (data: T) => boolean, ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -604,3 +692,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachPrepend<U>(op: Operator.fλ<T, U>, ctx: Ctx, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachPrepend<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, ctx: CtxLike<any>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -615,3 +703,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachPrepend<U>(op: Operator.fλ<T, U>, ctx: Ctx, callback: (transformedData: U) => void): Promise<U>;
		$attachPrepend<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, ctx: CtxLike<any>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -626,3 +714,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachPrepend<U>(op: Operator.fλ<T, U>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachPrepend<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -635,3 +723,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachPrepend<U>(op: Operator.fλ<T, U>, callback: (transformedData: U) => void): Promise<U>;
		$attachPrepend<U, CtxResult = any>(op: Operator.fλ<T, U, CtxResult>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -648,3 +736,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachPrepend<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout: number, callback: (data: Q) => void): Promise<Q>;
		attachPrepend<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout: number, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -661,3 +749,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachPrepend(op: (data: T) => boolean, ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachPrepend(op: (data: T) => boolean, ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -672,3 +760,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachPrepend<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, callback: (data: Q) => void): Promise<Q>;
		attachPrepend<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -683,3 +771,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachPrepend(op: (data: T) => boolean, ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachPrepend(op: (data: T) => boolean, ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -714,3 +802,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachPrepend(ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachPrepend(ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -739,3 +827,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachPrepend(ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachPrepend(ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -766,3 +854,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOncePrepend<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachOncePrepend<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -777,3 +865,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOncePrepend<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, callback: (transformedData: U) => void): Promise<U>;
		$attachOncePrepend<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -788,3 +876,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOncePrepend<U>(op: Operator.fλ.Stateless<T, U>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachOncePrepend<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -797,3 +885,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOncePrepend<U>(op: Operator.fλ.Stateless<T, U>, callback: (transformedData: U) => void): Promise<U>;
		$attachOncePrepend<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -810,3 +898,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOncePrepend<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout: number, callback: (data: Q) => void): Promise<Q>;
		attachOncePrepend<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout: number, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -823,3 +911,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOncePrepend(op: (data: T) => boolean, ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachOncePrepend(op: (data: T) => boolean, ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -834,3 +922,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOncePrepend<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, callback: (data: Q) => void): Promise<Q>;
		attachOncePrepend<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -845,3 +933,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOncePrepend(op: (data: T) => boolean, ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachOncePrepend(op: (data: T) => boolean, ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -876,3 +964,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOncePrepend(ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachOncePrepend(ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -901,3 +989,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOncePrepend(ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachOncePrepend(ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -928,3 +1016,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnceExtract<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachOnceExtract<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -939,3 +1027,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnceExtract<U>(op: Operator.fλ.Stateless<T, U>, ctx: Ctx, callback: (transformedData: U) => void): Promise<U>;
		$attachOnceExtract<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, ctx: CtxLike<any>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -950,3 +1038,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnceExtract<U>(op: Operator.fλ.Stateless<T, U>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		$attachOnceExtract<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, timeout: number, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -959,3 +1047,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		$attachOnceExtract<U>(op: Operator.fλ.Stateless<T, U>, callback: (transformedData: U) => void): Promise<U>;
		$attachOnceExtract<U, CtxResult = any>(op: Operator.fλ.Stateless<T, U, CtxResult>, callback: (transformedData: U) => void): Promise<U>;
		/**
		@@ -972,3 +1060,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnceExtract<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, timeout: number, callback: (data: Q) => void): Promise<Q>;
		attachOnceExtract<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, timeout: number, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -985,3 +1073,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnceExtract(op: (data: T) => boolean, ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachOnceExtract(op: (data: T) => boolean, ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -996,3 +1084,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnceExtract<Q extends T>(op: (data: T) => data is Q, ctx: Ctx, callback: (data: Q) => void): Promise<Q>;
		attachOnceExtract<Q extends T>(op: (data: T) => data is Q, ctx: CtxLike<any>, callback: (data: Q) => void): Promise<Q>;
		/**
		@@ -1007,3 +1095,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnceExtract(op: (data: T) => boolean, ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachOnceExtract(op: (data: T) => boolean, ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -1036,3 +1124,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnceExtract(ctx: Ctx, timeout: number, callback: (data: T) => void): Promise<T>;
		attachOnceExtract(ctx: CtxLike<any>, timeout: number, callback: (data: T) => void): Promise<T>;
		/**
		@@ -1061,3 +1149,3 @@ * https://docs.evt.land/api/evt/attach
		*/
		attachOnceExtract(ctx: Ctx, callback: (data: T) => void): Promise<T>;
		attachOnceExtract(ctx: CtxLike<any>, callback: (data: T) => void): Promise<T>;
		/**
		@@ -1078,2 +1166,7 @@ * https://docs.evt.land/api/evt/attach
		}
		/** https://docs.evt.land/api/voidevt */
		export declare class VoidEvt extends Evt<void> {
		post(): number;
		postAsyncOnceHandled(): Promise<number>;
		}
		export {};

536

dist/lib/Evt.js

		@@ -26,2 +26,38 @@ "use strict";
		};
		var __awaiter = (this && this.__awaiter) \|\| function (thisArg, _arguments, P, generator) {
		function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
		return new (P \|\| (P = Promise))(function (resolve, reject) {
		function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
		function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
		function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
		step((generator = generator.apply(thisArg, _arguments \|\| [])).next());
		});
		};
		var __generator = (this && this.__generator) \|\| function (thisArg, body) {
		var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
		return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		function verb(n) { return function (v) { return step([n, v]); }; }
		function step(op) {
		if (f) throw new TypeError("Generator is already executing.");
		while (_) try {
		if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] \|\| ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		if (y = 0, t) op = [op[0] & 2, t.value];
		switch (op[0]) {
		case 0: case 1: t = op; break;
		case 4: _.label++; return { value: op[1], done: false };
		case 5: _.label++; y = op[1]; op = [0]; continue;
		case 7: op = _.ops.pop(); _.trys.pop(); continue;
		default:
		if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 \|\| op[0] === 2)) { _ = 0; continue; }
		if (op[0] === 3 && (!t \|\| (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		if (t[2]) _.ops.pop();
		_.trys.pop(); continue;
		}
		op = body.call(thisArg, _);
		} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		}
		};
		var __read = (this && this.__read) \|\| function (o, n) {
		@@ -47,4 +83,23 @@ var m = typeof Symbol === "function" && o[Symbol.iterator];
		};
		var __values = (this && this.__values) \|\| function(o) {
		var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
		if (m) return m.call(o);
		if (o && typeof o.length === "number") return {
		next: function () {
		if (o && i >= o.length) o = void 0;
		return { value: o && o[i++], done: !o };
		}
		};
		throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
		};
		exports.__esModule = true;
		var EvtCore_1 = require("./EvtCore");
		require("minimal-polyfills/dist/lib/Array.prototype.find");
		var Map_1 = require("minimal-polyfills/dist/lib/Map");
		var WeakMap_1 = require("minimal-polyfills/dist/lib/WeakMap");
		var runExclusive = require("run-exclusive");
		var EvtError_1 = require("./types/EvtError");
		var overwriteReadonlyProp_1 = require("../tools/overwriteReadonlyProp");
		var encapsulateOpState_1 = require("./util/encapsulateOpState");
		var typeGuard_1 = require("../tools/typeSafety/typeGuard");
		var Operator_1 = require("./types/Operator");
		var Ctx_1 = require("./Ctx");
		@@ -57,16 +112,128 @@ var invokeOperator_1 = require("./util/invokeOperator");
		var getCtxFactory_1 = require("./util/getCtxFactory");
		exports.setPostCount = function (evt, value) {
		return overwriteReadonlyProp_1.overwriteReadonlyProp(evt, "postCount", value);
		};
		/** https://docs.evt.land/api/evt */
		var Evt = /** @class */ (function (_super) {
		__extends(Evt, _super);
		var Evt = /** @class */ (function () {
		function Evt() {
		var _this_1 = _super.call(this) \|\| this;
		_this_1.__parseOverloadParams = parseOverloadParams_1.parseOverloadParamsFactory();
		var _this_1 = this;
		this.__maxHandlers = 25;
		//NOTE: Not really readonly but we want to prevent user from setting the value
		//manually and we cant user accessor because we target es3.
		/**
		* https://docs.evt.land/api/evt/post
		*
		* Number of times .post(data) have been called.
		*/
		this.postCount = 0;
		this.traceId = null;
		this.handlers = [];
		this.handlerTriggers = new Map_1.Polyfill();
		//NOTE: An async handler ( attached with waitFor ) is only eligible to handle a post if the post
		//occurred after the handler was set. We don't want to waitFor event from the past.
		//private readonly asyncHandlerChronologyMark = new WeakMap<ImplicitParams.Async, number>();
		this.asyncHandlerChronologyMark = new WeakMap_1.Polyfill();
		//NOTE: There is an exception to the above rule, we want to allow async waitFor loop
		//do so we have to handle the case where multiple event would be posted synchronously.
		this.asyncHandlerChronologyExceptionRange = new WeakMap_1.Polyfill();
		/*
		NOTE: Used as Date.now() would be used to compare if an event is anterior
		or posterior to an other. We don't use Date.now() because two call within
		less than a ms will return the same value unlike this function.
		*/
		this.getChronologyMark = (function () {
		var currentChronologyMark = 0;
		return function () { return currentChronologyMark++; };
		})();
		this.statelessByStatefulOp = new WeakMap_1.Polyfill();
		this.postAsync = runExclusive.buildMethodCb(function (data, postChronologyMark, releaseLock) {
		var e_1, _a;
		var promises = [];
		var chronologyMarkStartResolveTick;
		//NOTE: Must be before handlerTrigger call.
		Promise.resolve().then(function () { return chronologyMarkStartResolveTick = _this_1.getChronologyMark(); });
		var _loop_1 = function (handler) {
		if (!handler.async) {
		return "continue";
		}
		var opResult = invokeOperator_1.invokeOperator(_this_1.getStatelessOp(handler.op), data, true);
		if (Operator_1.Operator.fλ.Result.NotMatched.match(opResult)) {
		Evt.doDetachIfNeeded(handler, opResult);
		return "continue";
		}
		var handlerTrigger = _this_1.handlerTriggers.get(handler);
		if (!handlerTrigger) {
		return "continue";
		}
		var shouldCallHandlerTrigger = (function () {
		var handlerMark = _this_1.asyncHandlerChronologyMark.get(handler);
		if (postChronologyMark > handlerMark) {
		return true;
		}
		var exceptionRange = _this_1.asyncHandlerChronologyExceptionRange.get(handler);
		return (exceptionRange !== undefined &&
		exceptionRange.lowerMark < postChronologyMark &&
		postChronologyMark < exceptionRange.upperMark &&
		handlerMark > exceptionRange.upperMark);
		})();
		if (!shouldCallHandlerTrigger) {
		return "continue";
		}
		promises.push(new Promise(function (resolve) { return handler.promise
		.then(function () { return resolve(); })["catch"](function () { return resolve(); }); }));
		handlerTrigger(opResult);
		};
		try {
		for (var _b = __values(__spread(_this_1.handlers)), _c = _b.next(); !_c.done; _c = _b.next()) {
		var handler = _c.value;
		_loop_1(handler);
		}
		}
		catch (e_1_1) { e_1 = { error: e_1_1 }; }
		finally {
		try {
		if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
		}
		finally { if (e_1) throw e_1.error; }
		}
		if (promises.length === 0) {
		releaseLock();
		return;
		}
		var handlersDump = __spread(_this_1.handlers);
		Promise.all(promises).then(function () {
		var e_2, _a;
		try {
		for (var _b = __values(_this_1.handlers), _c = _b.next(); !_c.done; _c = _b.next()) {
		var handler = _c.value;
		if (!handler.async) {
		continue;
		}
		if (handlersDump.indexOf(handler) >= 0) {
		continue;
		}
		_this_1.asyncHandlerChronologyExceptionRange.set(handler, {
		"lowerMark": postChronologyMark,
		"upperMark": chronologyMarkStartResolveTick
		});
		}
		}
		catch (e_2_1) { e_2 = { error: e_2_1 }; }
		finally {
		try {
		if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
		}
		finally { if (e_2) throw e_2.error; }
		}
		releaseLock();
		});
		});
		this.__parseOverloadParams = parseOverloadParams_1.parseOverloadParamsFactory();
		var _a = getLazyEvtFactory_1.getLazyEvtFactory(), getEvtAttach = _a.getEvt, postEvtAttach = _a.post;
		var _b = getLazyEvtFactory_1.getLazyEvtFactory(), getEvtDetach = _b.getEvt, postEvtDetach = _b.post;
		_this_1.onHandler = function (isAttach, handler) {
		this.onHandler = function (isAttach, handler) {
		return (isAttach ? postEvtAttach : postEvtDetach)(handler);
		};
		_this_1.getEvtAttach = getEvtAttach;
		_this_1.getEvtDetach = getEvtDetach;
		return _this_1;
		this.getEvtAttach = getEvtAttach;
		this.getEvtDetach = getEvtDetach;
		}
		@@ -90,2 +257,330 @@ Evt.newCtx = function () {
		};
		/**
		*
		* By default EventEmitters will print a warning if more than 25 handlers are added for
		* a particular event. This is a useful default that helps finding memory leaks.
		* Not all events should be limited to 25 handlers. The evt.setMaxHandlers() method allows the limit to be
		* modified for this specific EventEmitter instance.
		* The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
		* Returns a reference to the EventEmitter, so that calls can be chained.
		*
		*/
		Evt.prototype.setMaxHandlers = function (n) {
		this.__maxHandlers = isFinite(n) ? n : 0;
		return this;
		};
		/** https://docs.evt.land/api/evt/enabletrace */
		Evt.prototype.enableTrace = function (id, formatter, log
		//NOTE: Not typeof console.log as we don't want to expose types from node
		) {
		this.traceId = id;
		this.traceFormatter = formatter !== null && formatter !== void 0 ? formatter : (function (data) {
		try {
		return JSON.stringify(data, null, 2);
		}
		catch (_a) {
		return "" + data;
		}
		});
		this.log = log !== null && log !== void 0 ? log : (function () {
		var inputs = [];
		for (var _i = 0; _i < arguments.length; _i++) {
		inputs[_i] = arguments[_i];
		}
		return console.log.apply(console, __spread(inputs));
		});
		};
		/** https://docs.evt.land/api/evt/enabletrace */
		Evt.prototype.disableTrace = function () {
		this.traceId = null;
		};
		Evt.prototype.detachHandler = function (handler, wTimer, rejectPr) {
		var _a;
		var index = this.handlers.indexOf(handler);
		if (index < 0) {
		return false;
		}
		if (typeGuard_1.typeGuard(handler, !!handler.ctx)) {
		handler.ctx.zz__removeHandler(handler);
		}
		this.handlers.splice(index, 1);
		this.handlerTriggers["delete"](handler);
		if (wTimer[0] !== undefined) {
		clearTimeout(wTimer[0]);
		rejectPr(new EvtError_1.EvtError.Detached());
		}
		(_a = this.onHandler) === null \|\| _a === void 0 ? void 0 : _a.call(this, false, handler);
		return true;
		};
		Evt.doDetachIfNeeded = function (handler, opResult, once) {
		var detach = Operator_1.Operator.fλ.Result.getDetachArg(opResult);
		if (typeof detach !== "boolean") {
		var _a = __read(detach, 3), ctx = _a[0], error = _a[1], res = _a[2];
		if (!!error) {
		ctx.abort(error);
		}
		else {
		ctx.done(res);
		}
		}
		else if (detach \|\| !!once) {
		handler.detach();
		}
		};
		Evt.prototype.triggerHandler = function (handler, wTimer, resolvePr, opResult) {
		var callback = handler.callback, once = handler.once;
		if (wTimer[0] !== undefined) {
		clearTimeout(wTimer[0]);
		wTimer[0] = undefined;
		}
		Evt.doDetachIfNeeded(handler, opResult, once);
		var _a = __read(opResult, 1), transformedData = _a[0];
		callback === null \|\| callback === void 0 ? void 0 : callback.call(this, transformedData);
		resolvePr(transformedData);
		};
		Evt.prototype.addHandler = function (propsFromArgs, propsFromMethodName) {
		var _this_1 = this;
		var _a;
		if (Operator_1.Operator.fλ.Stateful.match(propsFromArgs.op)) {
		this.statelessByStatefulOp.set(propsFromArgs.op, encapsulateOpState_1.encapsulateOpState(propsFromArgs.op));
		}
		var handler = __assign(__assign(__assign({}, propsFromArgs), propsFromMethodName), { "detach": null, "promise": null });
		if (handler.async) {
		this.asyncHandlerChronologyMark.set(handler, this.getChronologyMark());
		}
		handler.promise = new Promise(function (resolve, reject) {
		var wTimer = [undefined];
		if (typeof handler.timeout === "number") {
		wTimer[0] = setTimeout(function () {
		wTimer[0] = undefined;
		handler.detach();
		reject(new EvtError_1.EvtError.Timeout(handler.timeout));
		}, handler.timeout);
		}
		handler.detach =
		function () { return _this_1.detachHandler(handler, wTimer, reject); };
		_this_1.handlerTriggers.set(handler, function (opResult) { return _this_1.triggerHandler(handler, wTimer, resolve, opResult); });
		});
		if (handler.prepend) {
		var i = void 0;
		for (i = 0; i < this.handlers.length; i++) {
		if (this.handlers[i].extract) {
		continue;
		}
		break;
		}
		this.handlers.splice(i, 0, handler);
		}
		else {
		this.handlers.push(handler);
		}
		if (this.__maxHandlers !== 0 &&
		this.handlers.length % (this.__maxHandlers + 1) === 0) {
		var message = [
		"MaxHandlersExceededWarning: Possible Evt memory leak detected.",
		this.handlers.length + " handlers attached" + (this.traceId ? " to " + this.traceId : "") + ".",
		"Use evt.setMaxHandlers() to increase limit."
		].join(" ");
		try {
		console.warn(message);
		}
		catch (_b) {
		}
		}
		if (typeGuard_1.typeGuard(handler, !!handler.ctx)) {
		handler.ctx.zz__addHandler(handler, this);
		}
		(_a = this.onHandler) === null \|\| _a === void 0 ? void 0 : _a.call(this, true, handler);
		return handler;
		};
		/** https://docs.evt.land/api/evt/getstatelessop */
		Evt.prototype.getStatelessOp = function (op) {
		return Operator_1.Operator.fλ.Stateful.match(op) ?
		this.statelessByStatefulOp.get(op) :
		op;
		};
		Evt.prototype.trace = function (data) {
		var _this_1 = this;
		if (this.traceId === null) {
		return;
		}
		var message = "(" + this.traceId + ") ";
		var isExtracted = !!this.handlers.find(function (_a) {
		var extract = _a.extract, op = _a.op;
		return (extract &&
		!!_this_1.getStatelessOp(op)(data));
		});
		if (isExtracted) {
		message += "extracted ";
		}
		else {
		var handlerCount = this.handlers
		.filter(function (_a) {
		var extract = _a.extract, op = _a.op;
		return !extract &&
		!!_this_1.getStatelessOp(op)(data);
		})
		.length;
		message += handlerCount + " handler" + ((handlerCount > 1) ? "s" : "") + " => ";
		}
		this.log(message + this.traceFormatter(data));
		};
		/**
		* https://garronej.github.io/ts-evt/#evtattach-evtattachonce-and-evtpost
		*
		* Returns post count
		* */
		Evt.prototype.post = function (data) {
		this.trace(data);
		exports.setPostCount(this, this.postCount + 1);
		//NOTE: Must be before postSync.
		var postChronologyMark = this.getChronologyMark();
		var isExtracted = this.postSync(data);
		if (!isExtracted) {
		this.postAsync(data, postChronologyMark);
		}
		return this.postCount;
		};
		/** Return isExtracted */
		Evt.prototype.postSync = function (data) {
		var e_3, _a;
		try {
		for (var _b = __values(__spread(this.handlers)), _c = _b.next(); !_c.done; _c = _b.next()) {
		var handler = _c.value;
		var async = handler.async, op = handler.op, extract = handler.extract;
		if (async) {
		continue;
		}
		var opResult = invokeOperator_1.invokeOperator(this.getStatelessOp(op), data, true);
		if (Operator_1.Operator.fλ.Result.NotMatched.match(opResult)) {
		Evt.doDetachIfNeeded(handler, opResult);
		continue;
		}
		var handlerTrigger = this.handlerTriggers.get(handler);
		//NOTE: Possible if detached while in the loop.
		if (!handlerTrigger) {
		continue;
		}
		handlerTrigger(opResult);
		if (extract) {
		return true;
		}
		}
		}
		catch (e_3_1) { e_3 = { error: e_3_1 }; }
		finally {
		try {
		if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
		}
		finally { if (e_3) throw e_3.error; }
		}
		return false;
		};
		Evt.prototype.__waitFor = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": true,
		"extract": false,
		"once": true,
		"prepend": false
		}).promise;
		};
		Evt.prototype.__attach = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": false,
		"extract": false,
		"once": false,
		"prepend": false
		}).promise;
		};
		Evt.prototype.__attachExtract = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": false,
		"extract": true,
		"once": false,
		"prepend": true
		}).promise;
		};
		Evt.prototype.__attachPrepend = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": false,
		"extract": false,
		"once": false,
		"prepend": true
		}).promise;
		};
		Evt.prototype.__attachOnce = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": false,
		"extract": false,
		"once": true,
		"prepend": false
		}).promise;
		};
		Evt.prototype.__attachOncePrepend = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": false,
		"extract": false,
		"once": true,
		"prepend": true
		}).promise;
		};
		Evt.prototype.__attachOnceExtract = function (attachParams) {
		return this.addHandler(attachParams, {
		"async": false,
		"extract": true,
		"once": true,
		"prepend": true
		}).promise;
		};
		/**
		* https://docs.evt.land/api/evt/ishandled
		*
		* Test if posting a given event data will have an effect.
		*
		* Return true if:
		* -There is at least one handler matching
		* this event data ( at least one handler's callback function
		* will be invoked if the data is posted. )
		* -Handlers could be will be detached
		* if the event data is posted.
		*
		*/
		Evt.prototype.isHandled = function (data) {
		var _this_1 = this;
		return !!this.getHandlers()
		.find(function (_a) {
		var op = _a.op;
		return !!_this_1.getStatelessOp(op)(data);
		});
		};
		/** https://docs.evt.land/api/evt/gethandler */
		Evt.prototype.getHandlers = function () {
		return __spread(this.handlers);
		};
		Evt.prototype.detach = function (ctx) {
		var e_4, _a;
		var detachedHandlers = [];
		try {
		for (var _b = __values(this.getHandlers()), _c = _b.next(); !_c.done; _c = _b.next()) {
		var handler = _c.value;
		if (ctx !== undefined && handler.ctx !== ctx) {
		continue;
		}
		var wasStillAttached = handler.detach();
		//NOTE: It should not be possible.
		if (!wasStillAttached) {
		continue;
		}
		detachedHandlers.push(handler);
		}
		}
		catch (e_4_1) { e_4 = { error: e_4_1 }; }
		finally {
		try {
		if (_c && !_c.done && (_a = _b["return"])) _a.call(_b);
		}
		finally { if (e_4) throw e_4.error; }
		}
		return detachedHandlers;
		};
		Evt.prototype.pipe = function () {
		@@ -105,3 +600,3 @@ var inputs = [];
		}
		return _super.prototype.__waitFor.call(this, this.__parseOverloadParams(inputs, "waitFor"));
		return this.__waitFor(this.__parseOverloadParams(inputs, "waitFor"));
		};
		@@ -205,4 +700,23 @@ Evt.prototype.$attach = function () {
		return Evt;
		}(EvtCore_1.EvtCore));
		}());
		exports.Evt = Evt;
		/** https://docs.evt.land/api/voidevt */
		var VoidEvt = /** @class */ (function (_super) {
		__extends(VoidEvt, _super);
		function VoidEvt() {
		return _super !== null && _super.apply(this, arguments) \|\| this;
		}
		VoidEvt.prototype.post = function () {
		return _super.prototype.post.call(this, undefined);
		};
		VoidEvt.prototype.postAsyncOnceHandled = function () {
		return __awaiter(this, void 0, void 0, function () {
		return __generator(this, function (_a) {
		return [2 /return/, _super.prototype.postAsyncOnceHandled.call(this, undefined)];
		});
		});
		};
		return VoidEvt;
		}(Evt));
		exports.VoidEvt = VoidEvt;
		//# sourceMappingURL=Evt.js.map

3

dist/lib/index.d.ts

		export * from "./Evt";
		export * from "./VoidEvt";
		export * from "./Ctx";
		export * from "./types";
		export * from "./Observable";
		export * from "./util";
		export * from "./Ctx";

3

dist/lib/index.js

		@@ -7,7 +7,6 @@ "use strict";
		__export(require("./Evt"));
		__export(require("./VoidEvt"));
		__export(require("./Ctx"));
		__export(require("./types"));
		__export(require("./Observable"));
		__export(require("./util"));
		__export(require("./Ctx"));
		//# sourceMappingURL=index.js.map

8

dist/lib/types/EventTargetLike.js

		@@ -9,3 +9,3 @@ "use strict";
		function match(eventTarget) {
		return (typeSafety_1.typeGuard.dry(eventTarget) &&
		return (typeSafety_1.typeGuard(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -20,3 +20,3 @@ typeof eventTarget.subscribe === "function");
		function match(eventTarget) {
		return (typeSafety_1.typeGuard.dry(eventTarget) &&
		return (typeSafety_1.typeGuard(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -31,3 +31,3 @@ typeof eventTarget.addListener === "function" &&
		function match(eventTarget) {
		return (typeSafety_1.typeGuard.dry(eventTarget) &&
		return (typeSafety_1.typeGuard(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -42,3 +42,3 @@ typeof eventTarget.on === "function" &&
		function match(eventTarget) {
		return (typeSafety_1.typeGuard.dry(eventTarget) &&
		return (typeSafety_1.typeGuard(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -45,0 +45,0 @@ typeof eventTarget.addEventListener === "function" &&

16

dist/lib/types/Handler.d.ts

		import { Operator } from "./Operator";
		declare type EvtCore<T> = import("../EvtCore").EvtCore<T>;
		declare type Ctx<T = any> = import("../Ctx").Ctx<T>;
		declare type EvtLike<T> = import("../Evt").EvtLike<T>;
		declare type CtxLike<T> = import("../Ctx").CtxLike<T>;
		/** https://docs.evt.land/api/handler */
		export declare type Handler<T, U, CtxProp extends Ctx<any> \| undefined = Ctx \| undefined> = Handler.PropsFromArgs<T, U, CtxProp> & Handler.PropsFromMethodName & Readonly<{
		export declare type Handler<T, U, CtxProp extends CtxLike<any> \| undefined = CtxLike<any> \| undefined> = Handler.PropsFromArgs<T, U, CtxProp> & Handler.PropsFromMethodName & Readonly<{
		detach(): boolean;
		@@ -11,6 +11,6 @@ promise: Promise<U>;
		/** Handlers params that come from the arguments passed to the method invoked */
		type PropsFromArgs<T, U, CtxProp extends Ctx \| undefined = Ctx \| undefined> = {
		type PropsFromArgs<T, U, CtxProp extends CtxLike<any> \| undefined = CtxLike<any> \| undefined> = {
		ctx: CtxProp;
		timeout: number \| undefined;
		op: Operator<T, U>;
		op: Operator<T, U, CtxProp extends CtxLike<infer CtxResult> ? CtxResult : undefined>;
		callback: ((transformedData: U) => void) \| undefined;
		@@ -43,7 +43,7 @@ };
		}
		type WithEvt<T> = {
		handler: Handler<T, any, Ctx>;
		evt: EvtCore<T>;
		type WithEvt<T, CtxResult> = {
		handler: Handler<T, any, CtxLike<CtxResult>>;
		evt: EvtLike<T>;
		};
		}
		export {};

2

dist/lib/types/helper/index.d.ts

		export * from "./NonPostable";
		export * from "./UnpackEvt";
		export * from "./EvtLike";
		export * from "./UnpackCtx";

2

dist/lib/types/helper/NonPostable.d.ts

		@@ -1,2 +0,2 @@
		import { EvtLike } from "./EvtLike";
		declare type EvtLike<T> = import("../../Evt").EvtLike<T>;
		/**
		@@ -3,0 +3,0 @@ * Construct a type with the properties of T except for those in type K.

1

dist/lib/types/helper/NonPostable.js

		"use strict";
		//type EvtCore<T> = import("../../EvtCore").EvtCore<T>;
		exports.__esModule = true;
		//# sourceMappingURL=NonPostable.js.map

3

dist/lib/types/helper/UnpackEvt.d.ts

		@@ -1,3 +0,4 @@
		import { EvtLike } from "./EvtLike";
		declare type EvtLike<T> = import("../../Evt").EvtLike<T>;
		/** https://docs.evt.land/api/unpackevt */
		export declare type UnpackEvt<T extends EvtLike<any>> = T extends EvtLike<infer U> ? U : never;
		export {};

64

dist/lib/types/Operator.d.ts

		@@ -1,29 +0,29 @@
		declare type Ctx<T = any> = import("../Ctx").Ctx<T>;
		declare type VoidCtx = import("../Ctx").VoidCtx;
		declare type CtxLike<Result> = import("../Ctx").CtxLike<Result>;
		declare type VoidCtxLike = import("../Ctx").VoidCtxLike;
		/** https://docs.evt.land/api/operator */
		export declare type Operator<T, U> = Operator.fλ<T, U> \| ((data: U) => boolean) \| //Filter
		export declare type Operator<T, U, CtxResult> = Operator.fλ<T, U, CtxResult> \| ((data: U) => boolean) \| //Filter
		(U extends T ? (data: T) => data is U : never);
		export declare namespace Operator {
		type fλ<T, U> = fλ.Stateless<T, U> \| fλ.Stateful<T, U>;
		type fλ<T, U, CtxResult> = fλ.Stateless<T, U, CtxResult> \| fλ.Stateful<T, U, CtxResult>;
		namespace fλ {
		type Stateless<T, U> = (data: T, prev?: undefined, isPost?: true) => Result<U>;
		type Stateful<T, U> = [(data: T, prev: U, isPost?: true) => Result<U>, U];
		type Stateless<T, U, CtxResult> = (data: T, prev?: undefined, isPost?: true) => Result<U, CtxResult>;
		type Stateful<T, U, CtxResult> = [(data: T, prev: U, isPost?: true) => Result<U, CtxResult>, U];
		namespace Stateful {
		function match<T, U>(op: Operator<T, U>): op is Stateful<T, U>;
		function match<T, U, CtxResult>(op: Operator<T, U, CtxResult>): op is Stateful<T, U, CtxResult>;
		}
		type Result<U> = Result.Matched<U> \| Result.NotMatched;
		type Result<U, CtxResult> = Result.Matched<U, CtxResult> \| Result.NotMatched<CtxResult>;
		namespace Result {
		function match<U>(result: any): result is Result<U>;
		function getDetachArg(result: Result<any>): boolean \| [Ctx, undefined \| Error, any];
		type NotMatched = Detach \| null;
		function match<U, CtxResult>(result: any): result is Result<U, CtxResult>;
		function getDetachArg<CtxResult>(result: Result<any, CtxResult>): boolean \| [CtxLike<CtxResult>, undefined \| Error, CtxResult];
		type NotMatched<CtxResult> = Detach<CtxResult> \| null;
		namespace NotMatched {
		function match(result: any): result is NotMatched;
		function match<CtxResult>(result: any): result is NotMatched<CtxResult>;
		}
		type Matched<U> = Matched.NoDetachArg<U> \| Matched.WithDetachArg<U>;
		type Matched<U, CtxResult> = Matched.NoDetachArg<U> \| Matched.WithDetachArg<U, CtxResult>;
		namespace Matched {
		type NoDetachArg<U> = readonly [U];
		type WithDetachArg<U> = readonly [U, Detach \| null];
		function match(result: any): result is Matched<any>;
		type WithDetachArg<U, CtxResult> = readonly [U, Detach<CtxResult> \| null];
		function match<U, CtxResult>(result: any): result is Matched<U, CtxResult>;
		}
		type Detach = Detach.FromEvt \| Detach.WithCtxArg;
		type Detach<CtxResult> = Detach.FromEvt \| Detach.WithCtxArg<CtxResult>;
		namespace Detach {
		@@ -34,23 +34,25 @@ type FromEvt = "DETACH";
		}
		type WithCtxArg<T = any> = {
		DETACH: Ctx<T>;
		err: Error;
		} \| {
		DETACH: Ctx<T>;
		res: T;
		} \| {
		DETACH: VoidCtx;
		err: Error;
		} \| {
		DETACH: VoidCtx;
		};
		type WithCtxArg<CtxResult> = WithCtxArg.Void \| WithCtxArg.Arg<CtxResult>;
		namespace WithCtxArg {
		function match(detach: any): detach is WithCtxArg;
		type Void = {
		DETACH: VoidCtxLike;
		err: Error;
		} \| {
		DETACH: VoidCtxLike;
		};
		type Arg<CtxResult> = {
		DETACH: CtxLike<CtxResult>;
		err: Error;
		} \| {
		DETACH: CtxLike<CtxResult>;
		res: CtxResult;
		};
		function match<CtxResult>(detach: any): detach is WithCtxArg<CtxResult>;
		}
		function match(detach: any): detach is Detach;
		function match<CtxResult>(detach: any): detach is Detach<CtxResult>;
		}
		}
		}
		type Stateless<T, U> = fλ.Stateless<T, U> \| ((data: U) => boolean) \| (U extends T ? (data: T) => data is U : never);
		type Stateless<T, U, CtxResult> = fλ.Stateless<T, U, CtxResult> \| ((data: U) => boolean) \| (U extends T ? (data: T) => data is U : never);
		}
		export {};

4

dist/lib/types/Operator.js

		@@ -47,3 +47,3 @@ "use strict";
		function match(result) {
		return (typeSafety_1.typeGuard.dry(result) &&
		return (typeSafety_1.typeGuard(result) &&
		result instanceof Object &&
		@@ -69,3 +69,3 @@ (result.length === 1 \|\|
		function match(detach) {
		return (typeSafety_1.typeGuard.dry(detach) &&
		return (typeSafety_1.typeGuard(detach) &&
		detach instanceof Object &&
		@@ -72,0 +72,0 @@ detach.DETACH instanceof Object);

36

dist/lib/util/compose.d.ts

		import { Operator } from "../types/Operator";
		export declare function compose<A, B, C>(op1: Operator.fλ<A, B>, op2: Operator.fλ<B, C>): Operator.fλ.Stateless<A, C>;
		export declare function compose<A, B, C extends B>(op1: Operator.fλ<A, B>, op2: (data: B) => data is C): Operator.fλ.Stateless<A, C>;
		export declare function compose<A, B>(op1: Operator.fλ<A, B>, op2: (data: B) => boolean): Operator.fλ.Stateless<A, B>;
		export declare function compose<A, B extends A, C>(op1: (data: A) => data is B, op2: Operator.fλ<B, C>): Operator.fλ.Stateless<A, B>;
		export declare function compose<A, B>(op1: (data: A) => boolean, op2: Operator.fλ<A, B>): Operator.fλ.Stateless<A, B>;
		export declare function compose<A, B extends A, C extends B>(op1: (data: A) => data is B, op2: (data: B) => data is C): Operator.fλ.Stateless<A, C>;
		export declare function compose<A, B extends A>(op1: (data: A) => data is B, op2: (data: B) => boolean): Operator.fλ.Stateless<A, B>;
		export declare function compose<A, B extends A>(op1: (data: A) => boolean, op2: (data: A) => data is B): Operator.fλ.Stateless<A, B>;
		export declare function compose<A>(op1: (data: A) => boolean, op2: (data: A) => boolean): Operator.fλ.Stateless<A, A>;
		export declare function compose<A, B, C, D>(op1: Operator.fλ<A, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>): Operator.fλ.Stateless<A, D>;
		export declare function compose<A, B, C, D, E>(op1: Operator.fλ<A, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>, op4: Operator.fλ<D, E>): Operator.fλ.Stateless<A, E>;
		export declare function compose<A, B, C, D, E>(op1: Operator.fλ<A, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>, op4: Operator.fλ<D, E>): Operator.fλ.Stateless<A, E>;
		export declare function compose<A, B, C, D, E, F>(op1: Operator.fλ<A, B>, op2: Operator.fλ<B, C>, op3: Operator.fλ<C, D>, op4: Operator.fλ<D, E>, op5: Operator.fλ<E, F>): Operator.fλ.Stateless<A, F>;
		export declare function compose<A, B, C>(op1: Operator<A, B>, op2: Operator<B, C>): Operator.fλ.Stateless<A, C>;
		export declare function compose<A, B, C, D>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>): Operator.fλ.Stateless<A, D>;
		export declare function compose<A, B, C, D, E>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>): Operator.fλ.Stateless<A, E>;
		export declare function compose<A, B, C, D, E, F>(op1: Operator<A, B>, op2: Operator<B, C>, op3: Operator<C, D>, op4: Operator<D, E>, op5: Operator<E, F>): Operator.fλ.Stateless<A, F>;
		export declare function compose<T>(...ops: [Operator<T, any>, ...Operator<any, any>[]]): Operator.Stateless<T, any>;
		export declare function compose<A, B, C, CtxResultOp1 = any, CtxResultOp2 = any>(op1: Operator.fλ<A, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>): Operator.fλ.Stateless<A, C, CtxResultOp1 \| CtxResultOp2>;
		export declare function compose<A, B, C extends B, CtxResult = any>(op1: Operator.fλ<A, B, CtxResult>, op2: (data: B) => data is C): Operator.fλ.Stateless<A, C, CtxResult>;
		export declare function compose<A, B, CtxResult = any>(op1: Operator.fλ<A, B, CtxResult>, op2: (data: B) => boolean): Operator.fλ.Stateless<A, B, CtxResult>;
		export declare function compose<A, B extends A, C, CtxResult = any>(op1: (data: A) => data is B, op2: Operator.fλ<B, C, CtxResult>): Operator.fλ.Stateless<A, B, CtxResult>;
		export declare function compose<A, B, CtxResult = any>(op1: (data: A) => boolean, op2: Operator.fλ<A, B, CtxResult>): Operator.fλ.Stateless<A, B, CtxResult>;
		export declare function compose<A, B extends A, C extends B>(op1: (data: A) => data is B, op2: (data: B) => data is C): Operator.fλ.Stateless<A, C, never>;
		export declare function compose<A, B extends A>(op1: (data: A) => data is B, op2: (data: B) => boolean): Operator.fλ.Stateless<A, B, never>;
		export declare function compose<A, B extends A>(op1: (data: A) => boolean, op2: (data: A) => data is B): Operator.fλ.Stateless<A, B, never>;
		export declare function compose<A>(op1: (data: A) => boolean, op2: (data: A) => boolean): Operator.fλ.Stateless<A, A, never>;
		export declare function compose<A, B, C, D, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any>(op1: Operator.fλ<A, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>): Operator.fλ.Stateless<A, D, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3>;
		export declare function compose<A, B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(op1: Operator.fλ<A, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>, op4: Operator.fλ<D, E, CtxResultOp4>): Operator.fλ.Stateless<A, E, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4>;
		export declare function compose<A, B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(op1: Operator.fλ<A, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>, op4: Operator.fλ<D, E, CtxResultOp4>): Operator.fλ.Stateless<A, E, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4>;
		export declare function compose<A, B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(op1: Operator.fλ<A, B, CtxResultOp1>, op2: Operator.fλ<B, C, CtxResultOp2>, op3: Operator.fλ<C, D, CtxResultOp3>, op4: Operator.fλ<D, E, CtxResultOp4>, op5: Operator.fλ<E, F, CtxResultOp5>): Operator.fλ.Stateless<A, F, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4 \| CtxResultOp5>;
		export declare function compose<A, B, C, CtxResultOp1 = any, CtxResultOp2 = any>(op1: Operator<A, B, CtxResultOp1>, op2: Operator<B, C, CtxResultOp2>): Operator.fλ.Stateless<A, C, CtxResultOp1 \| CtxResultOp2>;
		export declare function compose<A, B, C, D, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any>(op1: Operator<A, B, any>, op2: Operator<B, C, any>, op3: Operator<C, D, any>): Operator.fλ.Stateless<A, D, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3>;
		export declare function compose<A, B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(op1: Operator<A, B, CtxResultOp1>, op2: Operator<B, C, CtxResultOp2>, op3: Operator<C, D, CtxResultOp3>, op4: Operator<D, E, CtxResultOp4>): Operator.fλ.Stateless<A, E, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4 \| CtxResultOp5>;
		export declare function compose<A, B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(op1: Operator<A, B, CtxResultOp1>, op2: Operator<B, C, CtxResultOp2>, op3: Operator<C, D, CtxResultOp3>, op4: Operator<D, E, CtxResultOp4>, op5: Operator<E, F, CtxResultOp5>): Operator.fλ.Stateless<A, F, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4 \| CtxResultOp5>;
		export declare function compose<T>(...ops: [Operator<T, any, any>, ...Operator<any, any, any>[]]): Operator.Stateless<T, any, any>;

100

dist/lib/util/compose.js

		@@ -27,2 +27,4 @@ "use strict";
		var id_1 = require("../../tools/typeSafety/id");
		var assert_1 = require("../../tools/typeSafety/assert");
		var typeGuard_1 = require("../../tools/typeSafety/typeGuard");
		function f_o_g(op1, op2) {
		@@ -40,12 +42,18 @@ var opAtoB = Operator_1.Operator.fλ.Stateful.match(op1) ?
		}
		var _b = __read(_a, 3), dataA = _b[0], cbInvokedIfMatched = _b[2];
		var _b = __read(_a, 3), dataA = _b[0], isPost = _b[2];
		var _c, _d;
		var resultB = invokeOperator_1.invokeOperator(opAtoB, dataA, cbInvokedIfMatched);
		var resultB = invokeOperator_1.invokeOperator(opAtoB, dataA, isPost);
		if (Operator_1.Operator.fλ.Result.NotMatched.match(resultB)) {
		//CtxResultOp1 assignable to CtxResultOp1 \| CtxResultOp2...
		assert_1.assert(typeGuard_1.typeGuard(resultB));
		return resultB;
		}
		var detachOp1 = (_c = resultB[1]) !== null && _c !== void 0 ? _c : null;
		//...same...
		assert_1.assert(typeGuard_1.typeGuard(detachOp1));
		var _e = __read(resultB, 1), dataB = _e[0];
		var resultC = invokeOperator_1.invokeOperator(opBtoC, dataB, cbInvokedIfMatched);
		var resultC = invokeOperator_1.invokeOperator(opBtoC, dataB, isPost);
		if (Operator_1.Operator.fλ.Result.NotMatched.match(resultC)) {
		//...same
		assert_1.assert(typeGuard_1.typeGuard(resultC));
		return detachOp1 !== null && detachOp1 !== void 0 ? detachOp1 : resultC;
		@@ -78,88 +86,2 @@ }
		exports.compose = compose;
		/*

		opCompose(
		(data: string)=> [ data.length ],
		data => [ `${data}` ]
		);

		opCompose(
		(data: string)=> true,
		(data)=> [ data.length ],
		);

		opCompose(
		(data: string)=> [ data.length ],
		(data)=> true,
		);
		opCompose(
		(data: string)=> true,
		data=> true,
		);

		opCompose(
		(data: string \| number): data is string => true,
		data=> [ data.length ]
		);

		opCompose(
		(data: string \| number \| Function ): data is (string \| Function) => true,
		(data): data is Function=> true
		);

		opCompose(
		(data: string \| number \| Function ): data is (string \| Function) => true,
		data => typeof data === "string" ? [ data ] : null
		);

		opCompose(
		(data: string \| number \| Function ): data is (string \| Function) => true,
		data => true
		);

		opCompose(
		(data: string \| number \| Function) => true,
		(data): data is (string \| Function) => true,
		);

		opCompose(
		(data: string) => [ data.length > 3 ? data.length : data ],
		(data): data is string => true,
		);


		opCompose(
		id<Operator<string,string>>((data: string) => true),
		id<Operator<string, number>>((data: string) => [data.length] as const)
		);



		opCompose(
		id<Operator<string, string>>(
		(data: string) => true
		),
		id<Operator.fλ<string, number>>(
		(data) => [data.length]
		),
		id<Operator.fλ<number, string>>(
		data => [`${data}`]
		)
		);

		opCompose(
		(data: string)=> [data],
		data => [data],
		data => [data]
		);

		opCompose(
		(data: string)=> [ data],
		data => [ data ],
		data => [ data ],
		data => [ data ],
		data => [ data ]
		);

		*/
		//# sourceMappingURL=compose.js.map

2

dist/lib/util/encapsulateOpState.d.ts

		import { Operator } from "../types/Operator";
		export declare function encapsulateOpState<T, U>(statefulFλOp: Operator.fλ.Stateful<T, U>): Operator.fλ.Stateless<T, U>;
		export declare function encapsulateOpState<T, U, CtxOperator>(statefulFλOp: Operator.fλ.Stateful<T, U, CtxOperator>): Operator.fλ.Stateless<T, U, CtxOperator>;

19

dist/lib/util/from.d.ts

		import { Evt } from "../Evt";
		import { EventTargetLike } from "../types/EventTargetLike";
		import * as dom from "../types/lib.dom";
		declare type Ctx = import("../Ctx").Ctx;
		declare type OneOrMany<T> = T \| ArrayLike<T>;
		export declare function from<K extends keyof dom.HTMLElementEventMap>(ctx: Ctx, target: EventTargetLike.HTMLElement, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.HTMLElementEventMap[K]>;
		export declare function from<K extends keyof dom.WindowEventMap>(ctx: Ctx, target: EventTargetLike.Window, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.WindowEventMap[K]>;
		export declare function from<K extends keyof dom.DocumentEventMap>(ctx: Ctx, target: EventTargetLike.Document, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.DocumentEventMap[K]>;
		export declare function from<T>(ctx: Ctx, target: OneOrMany<EventTargetLike.NodeStyleEventEmitter \| EventTargetLike.JQueryStyleEventEmitter>, eventName: string): Evt<T>;
		export declare function from<T>(ctx: Ctx, target: OneOrMany<EventTargetLike.HasEventTargetAddRemove<T>>, eventName: string, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<T>;
		export declare function from<T>(ctx: Ctx, target: OneOrMany<EventTargetLike.RxJSSubject<T>>): Evt<T>;
		declare type EvtLike<T> = import("../Evt").EvtLike<T>;
		declare type CtxLike<Result> = import("../Ctx").CtxLike<Result> & {
		getEvtDone(): EvtLike<unknown> & {
		attachOnce(callback: () => void): void;
		};
		};
		export declare function from<K extends keyof dom.HTMLElementEventMap>(ctx: CtxLike<any>, target: EventTargetLike.HTMLElement, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.HTMLElementEventMap[K]>;
		export declare function from<K extends keyof dom.WindowEventMap>(ctx: CtxLike<any>, target: EventTargetLike.Window, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.WindowEventMap[K]>;
		export declare function from<K extends keyof dom.DocumentEventMap>(ctx: CtxLike<any>, target: EventTargetLike.Document, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.DocumentEventMap[K]>;
		export declare function from<T>(ctx: CtxLike<any>, target: OneOrMany<EventTargetLike.NodeStyleEventEmitter \| EventTargetLike.JQueryStyleEventEmitter>, eventName: string): Evt<T>;
		export declare function from<T>(ctx: CtxLike<any>, target: OneOrMany<EventTargetLike.HasEventTargetAddRemove<T>>, eventName: string, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<T>;
		export declare function from<T>(ctx: CtxLike<any>, target: OneOrMany<EventTargetLike.RxJSSubject<T>>): Evt<T>;
		export declare function from<K extends keyof dom.HTMLElementEventMap>(target: EventTargetLike.HTMLElement, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.HTMLElementEventMap[K]>;
		@@ -13,0 +18,0 @@ export declare function from<K extends keyof dom.WindowEventMap>(target: EventTargetLike.Window, eventName: K, options?: EventTargetLike.HasEventTargetAddRemove.Options): Evt<dom.WindowEventMap[K]>;

10

dist/lib/util/from.js

		@@ -49,10 +49,10 @@ "use strict";
		if ("getEvtDone" in ctxOrTarget) {
		typeSafety_1.assert(typeSafety_1.typeGuard.dry(targetOrEventName) &&
		typeSafety_1.typeGuard.dry(eventNameOrOptions) &&
		typeSafety_1.typeGuard.dry(options));
		typeSafety_1.assert(typeSafety_1.typeGuard(targetOrEventName) &&
		typeSafety_1.typeGuard(eventNameOrOptions) &&
		typeSafety_1.typeGuard(options));
		return fromImpl(ctxOrTarget, targetOrEventName, eventNameOrOptions, options);
		}
		else {
		typeSafety_1.assert(typeSafety_1.typeGuard.dry(targetOrEventName) &&
		typeSafety_1.typeGuard.dry(eventNameOrOptions));
		typeSafety_1.assert(typeSafety_1.typeGuard(targetOrEventName) &&
		typeSafety_1.typeGuard(eventNameOrOptions));
		return fromImpl(undefined, ctxOrTarget, targetOrEventName, eventNameOrOptions);
		@@ -59,0 +59,0 @@ }

2

dist/lib/util/genericOperators/chunksOf.d.ts

		/** Output Uint8Array of fixed size*/
		export declare const chunksOf: (byteLength: number) => import("../..").Operator.fλ.Stateless<Uint8Array, Uint8Array>;
		export declare const chunksOf: (byteLength: number) => import("../..").Operator.fλ.Stateless<Uint8Array, Uint8Array, any>;

2

dist/lib/util/genericOperators/scan.d.ts

		@@ -1,1 +0,1 @@
		export declare const scan: <T, U>(accumulator: (acc: U, value: T, index: number) => U, seed: U) => import("../..").Operator.fλ.Stateless<T, U>;
		export declare const scan: <T, U>(accumulator: (acc: U, value: T, index: number) => U, seed: U) => import("../..").Operator.fλ.Stateless<T, U, any>;

2

dist/lib/util/genericOperators/throttleTime.d.ts

		@@ -1,1 +0,1 @@
		export declare const throttleTime: <T>(duration: number) => import("../..").Operator.fλ.Stateless<T, T>;
		export declare const throttleTime: <T>(duration: number) => import("../..").Operator.fλ.Stateless<T, T, any>;

2

dist/lib/util/genericOperators/to.d.ts

		import { Operator } from "../../types/Operator";
		export declare const to: <T extends [string, any], K extends T[0]>(eventName: K) => Operator.fλ.Stateless<T, Extract<T, [K, any]>[1]>;
		export declare const to: <T extends [string, any], K extends T[0]>(eventName: K) => Operator.fλ.Stateless<T, Extract<T, [K, any]>[1], never>;

3

dist/lib/util/getCtxFactory.d.ts

		@@ -1,1 +0,2 @@
		export declare function getCtxFactory(): (obj: object) => import("../Ctx").VoidCtx;
		import { VoidCtx } from "../Ctx";
		export declare function getCtxFactory(): (obj: object) => VoidCtx;

3

dist/lib/util/getCtxFactory.js

		@@ -7,7 +7,6 @@ "use strict";
		var ctxByObj = new WeakMap_1.Polyfill();
		//function getCtx<T>(obj: object): Ctx<T>;
		function getCtx(obj) {
		var ctx = ctxByObj.get(obj);
		if (ctx === undefined) {
		ctx = new Ctx_1.Ctx();
		ctx = new Ctx_1.VoidCtx();
		ctxByObj.set(obj, ctx);
		@@ -14,0 +13,0 @@ }

4

dist/lib/util/getLazyEvtFactory.js

		"use strict";
		exports.__esModule = true;
		var Evt_2 = require("../Evt");
		var EvtCore_1 = require("../EvtCore");
		var Evt_3 = require("../Evt");
		function getLazyEvtFactory() {
		@@ -11,3 +11,3 @@ var initialPostCount = 0;
		evt = new Evt_2.Evt();
		EvtCore_1.setPostCount(evt, initialPostCount);
		Evt_3.setPostCount(evt, initialPostCount);
		}
		@@ -14,0 +14,0 @@ return evt;

8

dist/lib/util/invokeOperator.d.ts

		import { Operator } from "../types/Operator";
		/** Invoke any type of stateless operator and return as if it was a fλ*/
		export declare function invokeOperator<T, U>(op: Operator.fλ.Stateless<T, U>, data: T, isPost?: true): Operator.fλ.Result<U>;
		export declare function invokeOperator<T, U extends T>(op: (data: T) => data is U, data: T): Operator.fλ.Result<U>;
		export declare function invokeOperator<T>(op: (data: T) => boolean, data: T): Operator.fλ.Result<T>;
		export declare function invokeOperator<T, U>(op: Operator.Stateless<T, U>, data: T, isPost?: true): Operator.fλ.Result<U>;
		export declare function invokeOperator<T, U, CtxResult>(op: Operator.fλ.Stateless<T, U, CtxResult>, data: T, isPost?: true): Operator.fλ.Result<U, CtxResult>;
		export declare function invokeOperator<T, U extends T>(op: (data: T) => data is U, data: T): Operator.fλ.Result<U, never>;
		export declare function invokeOperator<T>(op: (data: T) => boolean, data: T): Operator.fλ.Result<T, never>;
		export declare function invokeOperator<T, U, CtxResult>(op: Operator.Stateless<T, U, CtxResult>, data: T, isPost?: true): Operator.fλ.Result<U, CtxResult>;

10

dist/lib/util/merge.d.ts

		import { Evt } from "../Evt";
		import { NonPostable } from "../types/helper/NonPostable";
		import { UnpackEvt } from "../types/helper/UnpackEvt";
		declare type Ctx = import("../Ctx").Ctx;
		export declare function mergeImpl<EvtUnion extends NonPostable<Evt<any>>>(ctx: Ctx \| undefined, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
		export declare function merge<EvtUnion extends NonPostable<Evt<any>>>(ctx: Ctx, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
		declare type CtxLike<Result> = import("../Ctx").CtxLike<Result>;
		declare type EvtLike<T> = import("../Evt").EvtLike<T> & {
		attach<T>(callback: (data: T) => void): void;
		attach<T>(ctx: CtxLike<any>, callback: (data: T) => void): void;
		};
		export declare function mergeImpl<EvtUnion extends EvtLike<any>>(ctx: CtxLike<any> \| undefined, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
		export declare function merge<EvtUnion extends NonPostable<Evt<any>>>(ctx: CtxLike<any>, evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
		export declare function merge<EvtUnion extends NonPostable<Evt<any>>>(evts: readonly EvtUnion[]): Evt<UnpackEvt<EvtUnion>>;
		export {};

4

dist/lib/util/merge.js

		"use strict";
		exports.__esModule = true;
		var Evt_2 = require("../Evt");
		//TODO: Fix interoperability between versions.
		function mergeImpl(ctx, evts) {
		var evtUnion = new Evt_2.Evt();
		var callback = function (data) { return evtUnion.post(data); };
		evts
		.forEach(function (evt) {
		evts.forEach(function (evt) {
		if (ctx === undefined) {
		@@ -10,0 +10,0 @@ evt.attach(callback);

2

dist/lib/util/parseOverloadParams.d.ts

		import { Handler } from "../types/Handler";
		export declare function parseOverloadParamsFactory<T>(): (inputs: readonly any[], methodName: "waitFor" \| "attach*" \| "pipe") => Handler.PropsFromArgs<T, any, import("../Ctx").Ctx<any> \| undefined>;
		export declare function parseOverloadParamsFactory<T>(): (inputs: readonly any[], methodName: "pipe" \| "waitFor" \| "attach*") => Handler.PropsFromArgs<T, any, import("../Ctx").CtxLike<any> \| undefined>;

2

dist/lib/util/parseOverloadParams.js

		@@ -40,3 +40,3 @@ "use strict";
		return (p !== undefined &&
		typeGuard_1.typeGuard.dry(p) &&
		typeGuard_1.typeGuard(p) &&
		(typeof p === "function" \|\|
		@@ -43,0 +43,0 @@ typeof p[0] === "function"));

4

dist/tools/inDepthComparison/representsSameData.js

		@@ -19,3 +19,3 @@ "use strict";
		function match(set) {
		return (typeGuard_1.typeGuard.dry(set) &&
		return (typeGuard_1.typeGuard(set) &&
		typeof set.values === "function" &&
		@@ -29,3 +29,3 @@ /Set/.test(Object.getPrototypeOf(set).constructor.name));
		function match(map) {
		return (typeGuard_1.typeGuard.dry(map) &&
		return (typeGuard_1.typeGuard(map) &&
		typeof map.keys === "function" &&
		@@ -32,0 +32,0 @@ typeof map.get === "function" &&

2

dist/tools/reducers/partition.js

		@@ -12,3 +12,3 @@ "use strict";
		//NOTE: Should be deduced by the compiler
		typeSafety_1.assert(typeSafety_1.typeGuard.dry(currentValue));
		typeSafety_1.assert(typeSafety_1.typeGuard(currentValue));
		previousValue[1].push(currentValue);
		@@ -15,0 +15,0 @@ }

2

dist/tools/typeSafety/matchVoid.js

		@@ -21,5 +21,5 @@ "use strict";
		function matchVoid(o) {
		return typeGuard_1.typeGuard(o, function (o) { return o === undefined \|\| o === null; });
		return typeGuard_1.typeGuard(o, o === undefined \|\| o === null);
		}
		exports.matchVoid = matchVoid;
		//# sourceMappingURL=matchVoid.js.map

67

dist/tools/typeSafety/typeGuard.d.ts

		@@ -1,18 +0,49 @@
		/** Invoke a test function as if it was a typeGuard for a given type */
		export declare function typeGuard<T>(o: any, matcher: (o: any) => boolean): boolean;
		export declare namespace typeGuard {
		/**
		* type guard that always returns true for a given type.
		*
		* Use case:
		* declare const x: "FOO" \| "BAR";
		* assert(typeGuard.dry<"BAR">(x));
		* x; <== x is of type "BAR"
		*
		* OR
		*
		* assert(!typeGuard.dry<"BAR">(x,false));
		* x; <== x is of type "FOO"
		*/
		function dry<T>(o: any, isMatched?: boolean): o is T;
		}
		/**
		* Use cases:
		*
		* 1) When we know the subtype of a variable but the compiler is unaware.
		*
		* declare const x: "FOO" \| "BAR";
		*
		* 1.1) If we want to tel the compile that we know x is of type "BAR"
		*
		* assert(typeGuard<"BAR">(x));
		* x; <== x is of type "BAR"
		*
		* 1.2) If we want to tell the compiler that x is NOT of type "BAR"
		*
		* assert(!typeGuard<"BAR">(x,false));
		* x; <== x is of type "FOO"
		*
		* 2) Tell the compiler what assertion can be made on a given variable
		* if a given test return true.
		*
		* type Circle = { type: "CIRCLE"; radius: number; };
		* type Square = { type: "SQUARE"; sideLength: number; };
		* type Shape = Circle \| Square;
		*
		* declare const shape: Shape;
		*
		* if( typeGuard<Circle>(shape, shape.type === "CIRCLE") ){
		* [ shape is Circle ]
		* }else{
		* [ shape is not Circle ]
		* }
		*
		*
		* export function matchVoid(o: any): o is void {
		* return typeGuard<void>(o, o === undefined \|\| o === null );
		* }
		*
		* 3) Helper for safely build other type guards
		*
		* export function match<T>(set: Object): set is SetLike<T> {
		* return (
		* typeGuard<SetLike<T>>(set) &&
		* typeof set.values === "function" &&
		* /Set/.test(Object.getPrototypeOf(set).constructor.name)
		* );
		* }
		*
		*/
		export declare function typeGuard<T>(o: any, isMatched?: boolean): o is T;

74

dist/tools/typeSafety/typeGuard.js

		"use strict";
		exports.__esModule = true;
		/** Invoke a test function as if it was a typeGuard for a given type */
		function typeGuard(o, matcher) {
		return matcher(o);
		/**
		* Use cases:
		*
		* 1) When we know the subtype of a variable but the compiler is unaware.
		*
		* declare const x: "FOO" \| "BAR";
		*
		* 1.1) If we want to tel the compile that we know x is of type "BAR"
		*
		* assert(typeGuard<"BAR">(x));
		* x; <== x is of type "BAR"
		*
		* 1.2) If we want to tell the compiler that x is NOT of type "BAR"
		*
		* assert(!typeGuard<"BAR">(x,false));
		* x; <== x is of type "FOO"
		*
		* 2) Tell the compiler what assertion can be made on a given variable
		* if a given test return true.
		*
		* type Circle = { type: "CIRCLE"; radius: number; };
		* type Square = { type: "SQUARE"; sideLength: number; };
		* type Shape = Circle \| Square;
		*
		* declare const shape: Shape;
		*
		* if( typeGuard<Circle>(shape, shape.type === "CIRCLE") ){
		* [ shape is Circle ]
		* }else{
		* [ shape is not Circle ]
		* }
		*
		*
		* export function matchVoid(o: any): o is void {
		* return typeGuard<void>(o, o === undefined \|\| o === null );
		* }
		*
		* 3) Helper for safely build other type guards
		*
		* export function match<T>(set: Object): set is SetLike<T> {
		* return (
		* typeGuard<SetLike<T>>(set) &&
		* typeof set.values === "function" &&
		* /Set/.test(Object.getPrototypeOf(set).constructor.name)
		* );
		* }
		*
		*/
		function typeGuard(o, isMatched) {
		if (isMatched === void 0) { isMatched = true; }
		return isMatched;
		}
		exports.typeGuard = typeGuard;
		(function (typeGuard) {
		/**
		* type guard that always returns true for a given type.
		*
		* Use case:
		* declare const x: "FOO" \| "BAR";
		* assert(typeGuard.dry<"BAR">(x));
		* x; <== x is of type "BAR"
		*
		* OR
		*
		* assert(!typeGuard.dry<"BAR">(x,false));
		* x; <== x is of type "FOO"
		*/
		function dry(o, isMatched) {
		if (isMatched === void 0) { isMatched = true; }
		return typeGuard(o, function () { return isMatched; });
		}
		typeGuard.dry = dry;
		})(typeGuard = exports.typeGuard \|\| (exports.typeGuard = {}));
		//# sourceMappingURL=typeGuard.js.map

2

package.json

		{
		"name": "evt",
		"version": "1.0.15",
		"version": "1.0.16",
		"description": "Type safe replacement for node's EventEmitter",
		@@ -5,0 +5,0 @@ "repository": {

98

src/lib/Ctx.ts

		@@ -6,9 +6,18 @@ import { Handler } from "./types/Handler";
		import { getLazyEvtFactory } from "./util/getLazyEvtFactory";
		import { UnpackEvt } from "./types/helper/UnpackEvt";
		type EvtCore<T> = import("./EvtCore").EvtCore<T>;
		import { assert } from "../tools/typeSafety/assert";
		import { typeGuard } from "../tools/typeSafety/typeGuard";
		type EvtLike<T> = import("./Evt").EvtLike<T>;

		type Done<T> = [Error \| null, T, Handler.WithEvt<any>[]];
		export type CtxEvtDoneData<Result> = [Error \| null, Result, Handler.WithEvt<any, Result>[]];

		export interface CtxLike<Result = any> {
		done(result: Result): void;
		abort(error: Error): void;
		zz__addHandler<T>(handler: Handler<T, any, CtxLike<Result>>, evt: EvtLike<T>): void;
		zz__removeHandler<T>(handler: Handler<T, any, CtxLike<Result>>): void;
		}


		/** https://docs.evt.land/api/ctx */
		export class Ctx<T = any> {
		export class Ctx<Result> implements CtxLike<Result>{

		@@ -20,3 +29,3 @@ /**
		*/
		public readonly getEvtDone: () => Evt<Done<T>>;
		public readonly getEvtDone: () => Evt<CtxEvtDoneData<Result>>;

		@@ -33,3 +42,3 @@ /**
		*/
		public getPrDone(timeout?: number): Promise<T> {
		public getPrDone(timeout?: number): Promise<Result> {
		return this.getEvtDone()
		@@ -57,3 +66,3 @@ .waitFor(timeout)
		* */
		public readonly getEvtAttach: () => Evt<Handler.WithEvt<any>>;
		public readonly getEvtAttach: () => Evt<Handler.WithEvt<any, Result>>;

		@@ -65,7 +74,7 @@ /**
		* */
		public readonly getEvtDetach: () => Evt<Handler.WithEvt<any>>;
		public readonly getEvtDetach: () => Evt<Handler.WithEvt<any, Result>>;

		private readonly onDone: ([error, result, handlers]: Done<T>) => void;
		private readonly onAttach: (handler: UnpackEvt<ReturnType<typeof Ctx.prototype.getEvtAttach>>) => void;
		private readonly onDetach: (handler: UnpackEvt<ReturnType<typeof Ctx.prototype.getEvtDetach>>) => void;
		private readonly onDone: ([error, result, handlers]: CtxEvtDoneData<Result>) => void;
		private readonly onAttach: (handler: Handler.WithEvt<any, Result>) => void;
		private readonly onDetach: (handler: Handler.WithEvt<any, Result>) => void;

		@@ -76,3 +85,3 @@ constructor() {

		const { getEvt, post } = getLazyEvtFactory<Done<T>>();
		const { getEvt, post } = getLazyEvtFactory<CtxEvtDoneData<Result>>();

		@@ -86,5 +95,3 @@ this.onDone = post;

		const { getEvt, post } = getLazyEvtFactory<
		UnpackEvt<ReturnType<typeof Ctx.prototype.getEvtAttach>>
		>();
		const { getEvt, post } = getLazyEvtFactory<Handler.WithEvt<any, Result>>();

		@@ -98,5 +105,3 @@ this.getEvtAttach = getEvt;

		const { getEvt, post } = getLazyEvtFactory<
		UnpackEvt<ReturnType<typeof Ctx.prototype.getEvtDetach>>
		>();
		const { getEvt, post } = getLazyEvtFactory<Handler.WithEvt<any, Result>>();

		@@ -129,3 +134,3 @@ this.getEvtDetach = getEvt;
		*/
		public done(result: T) {
		public done(result: Result) {
		return this.__done(undefined, result);
		@@ -135,5 +140,5 @@ }
		/** Detach all handler bound to this context from theirs respective Evt and post getEvtDone() */
		private __done(error: Error \| undefined, result?: T): Handler.WithEvt<any>[] {
		private __done(error: Error \| undefined, result?: Result): Handler.WithEvt<any, Result>[] {

		const handlers: Handler.WithEvt<any>[] = [];
		const handlers: Handler.WithEvt<any, Result>[] = [];

		@@ -165,11 +170,11 @@ for (const handler of this.handlers.values()) {
		private handlers = new Set<
		Handler<any, any, Ctx>
		Handler<any, any, Ctx<Result>>
		>();
		private evtByHandler = new WeakMap<
		Handler<any, any, Ctx>,
		EvtCore<any>
		Handler<any, any, Ctx<Result>>,
		EvtLike<any>
		>();

		/** https://docs.evt.land/api/ctx#ctx-gethandlers */
		public getHandlers(): Handler.WithEvt<any>[] {
		public getHandlers(): Handler.WithEvt<any, Result>[] {
		return Array.from(this.handlers.values())
		@@ -180,33 +185,34 @@ .map(handler => ({ handler, "evt": this.evtByHandler.get(handler)! }))

		public static __addHandlerToCtxCore<T>(
		handler: Handler<T, any, Ctx<T>>,
		evt: EvtCore<T>

		/** Exposed only to enable safe interoperability between mismatching EVT versions, do not use */
		public zz__addHandler<T>(
		handler: Handler<T, any, CtxLike<Result>>,
		evt: EvtLike<T>
		) {
		const { ctx } = handler;
		ctx.handlers.add(handler);
		ctx.evtByHandler.set(handler, evt);
		ctx.onAttach({ handler, evt });
		assert(handler.ctx === this);
		assert(typeGuard<Handler<T, any, Ctx<Result>>>(handler));
		this.handlers.add(handler);
		this.evtByHandler.set(handler, evt);
		this.onAttach({ handler, evt });
		}

		public static __removeHandlerFromCtxCore(
		handler: Handler<any, any, Ctx>
		/** Exposed only to enable safe interoperability between EVT versions, do not use */
		public zz__removeHandler<T>(
		handler: Handler<T, any, CtxLike<Result>>,
		) {
		const { ctx } = handler;
		ctx.onDetach({ handler, "evt": ctx.evtByHandler.get(handler)! });
		ctx.handlers.delete(handler);
		}
		assert(handler.ctx === this);
		assert(typeGuard<Handler<T, any, Ctx<Result>>>(handler));

		public static __matchHandlerBoundToCtx<T>(
		handler: Handler<T, any>
		): handler is Handler<T, any, Ctx> {
		return handler.ctx !== undefined;
		this.onDetach({ handler, "evt": this.evtByHandler.get(handler)! });
		this.handlers.delete(handler);
		}

		}


		export interface VoidCtxLike extends CtxLike<void> {
		done(): void;
		}

		//NOTE: Could be declared only, but in case someone import it, to avoid runtime error we declare it.
		/** https://docs.evt.land/api/ctx */
		export class VoidCtx extends Ctx<undefined> {
		export class VoidCtx extends Ctx<void> implements VoidCtxLike {

		@@ -218,3 +224,3 @@ /**
		*/
		public done(): ReturnType<typeof Ctx.prototype.done> {
		public done(): Handler.WithEvt<any, void>[] {
		return super.done(undefined);
		@@ -221,0 +227,0 @@ }

1089

src/lib/Evt.ts

		@@ -1,2 +0,9 @@
		import { EvtCore } from "./EvtCore";
		import "minimal-polyfills/dist/lib/Array.prototype.find";
		import { Polyfill as Map, LightMap } from "minimal-polyfills/dist/lib/Map";
		import { Polyfill as WeakMap } from "minimal-polyfills/dist/lib/WeakMap";
		import * as runExclusive from "run-exclusive";
		import { EvtError } from "./types/EvtError";
		import { overwriteReadonlyProp } from "../tools/overwriteReadonlyProp";
		import { encapsulateOpState } from "./util/encapsulateOpState";
		import { typeGuard } from "../tools/typeSafety/typeGuard";
		import { Handler } from "./types/Handler";
		@@ -12,5 +19,14 @@ import { Operator } from "./types/Operator";
		type VoidCtx = import("./Ctx").VoidCtx;
		type CtxLike<Result> = import("./Ctx").CtxLike<Result>;

		export const setPostCount = (evt: Evt<any>, value: number) =>
		overwriteReadonlyProp(evt, "postCount", value);

		export interface EvtLike<T> {
		isHandled(data?: T): void;
		}


		/** https://docs.evt.land/api/evt */
		export class Evt<T> extends EvtCore<T> {
		export class Evt<T> implements EvtLike<any/We can't use T, TypeScript bug ?/>{

		@@ -24,3 +40,3 @@ /**
		public static newCtx<T>(): Ctx<T>;
		public static newCtx<T = void>(): T extends void ? VoidCtx : Ctx<T>{
		public static newCtx<T = void>(): T extends void ? VoidCtx : Ctx<T> {
		return new Ctx() as any;
		@@ -50,4 +66,5 @@ }

		private readonly onHandler: (isAttach: boolean, handler: Handler<T, any>) => void;

		constructor() {
		super();

		@@ -86,2 +103,727 @@ const { getEvt: getEvtAttach, post: postEvtAttach } = getLazyEvtFactory<Handler<T, any>>();







		private __maxHandlers = 25;

		/**
		*
		* By default EventEmitters will print a warning if more than 25 handlers are added for
		* a particular event. This is a useful default that helps finding memory leaks.
		* Not all events should be limited to 25 handlers. The evt.setMaxHandlers() method allows the limit to be
		* modified for this specific EventEmitter instance.
		* The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.
		* Returns a reference to the EventEmitter, so that calls can be chained.
		*
		*/
		public setMaxHandlers(n: number): this {
		this.__maxHandlers = isFinite(n) ? n : 0;
		return this;
		}

		//NOTE: Not really readonly but we want to prevent user from setting the value
		//manually and we cant user accessor because we target es3.
		/**
		* https://docs.evt.land/api/evt/post
		*
		* Number of times .post(data) have been called.
		*/
		public readonly postCount: number = 0;

		private traceId: string \| null = null;
		private traceFormatter!: (data: T) => string;
		private log!: NonNullable<Parameters<typeof Evt.prototype.enableTrace>[2]>;

		/** https://docs.evt.land/api/evt/enabletrace */
		public enableTrace(
		id: string,
		formatter?: (data: T) => string,
		log?: (message?: any, ...optionalParams: any[]) => void
		//NOTE: Not typeof console.log as we don't want to expose types from node
		) {
		this.traceId = id;

		this.traceFormatter = formatter ?? (
		data => {
		try {
		return JSON.stringify(data, null, 2);
		} catch{
		return `${data}`;
		}
		}
		);

		this.log = log ?? ((...inputs) => console.log(...inputs));

		}
		/** https://docs.evt.land/api/evt/enabletrace */
		public disableTrace() {
		this.traceId = null;
		}


		private readonly handlers: Handler<T, any>[] = [];

		private readonly handlerTriggers: LightMap<
		Handler<T, any>,
		(opResult: Operator.fλ.Result.Matched<any, any>) => void
		> = new Map();

		//NOTE: An async handler ( attached with waitFor ) is only eligible to handle a post if the post
		//occurred after the handler was set. We don't want to waitFor event from the past.
		//private readonly asyncHandlerChronologyMark = new WeakMap<ImplicitParams.Async, number>();
		private readonly asyncHandlerChronologyMark = new WeakMap<Handler.PropsFromMethodName.Async, number>();

		//NOTE: There is an exception to the above rule, we want to allow async waitFor loop
		//do so we have to handle the case where multiple event would be posted synchronously.
		private readonly asyncHandlerChronologyExceptionRange = new WeakMap<
		Handler.PropsFromMethodName.Async,
		{
		lowerMark: number;
		upperMark: number;
		}
		>();

		/*
		NOTE: Used as Date.now() would be used to compare if an event is anterior
		or posterior to an other. We don't use Date.now() because two call within
		less than a ms will return the same value unlike this function.
		*/
		private readonly getChronologyMark = (() => {

		let currentChronologyMark = 0;

		return () => currentChronologyMark++;

		})();

		private readonly statelessByStatefulOp = new WeakMap<
		Operator.fλ.Stateful<T, any, any>,
		Operator.fλ.Stateless<T, any, any>
		>();



		private detachHandler(
		handler: Handler<T, any>,
		wTimer: [NodeJS.Timer \| undefined],
		rejectPr: (error: EvtError.Detached) => void
		) {

		const index = this.handlers.indexOf(handler);

		if (index < 0) {
		return false;
		}

		if (typeGuard<Handler<T, any, CtxLike<any>>>(handler, !!handler.ctx)) {
		handler.ctx.zz__removeHandler(handler);
		}


		this.handlers.splice(index, 1);

		this.handlerTriggers.delete(handler);

		if (wTimer[0] !== undefined) {

		clearTimeout(wTimer[0]);

		rejectPr(new EvtError.Detached());

		}

		this.onHandler?.(false, handler);

		return true;

		}

		private static doDetachIfNeeded<U = any>(
		handler: Handler<any, U>,
		opResult: Operator.fλ.Result.Matched<U, any>,
		once: boolean
		): void;
		private static doDetachIfNeeded(
		handler: Handler<any, any>,
		opResult: Operator.fλ.Result.NotMatched<any>,
		): void;
		private static doDetachIfNeeded<U = any>(
		handler: Handler<any, U>,
		opResult: Operator.fλ.Result<U, any>,
		once?: boolean
		): void {

		const detach = Operator.fλ.Result.getDetachArg(opResult);

		if (typeof detach !== "boolean") {
		const [ctx, error, res] = detach;

		if (!!error) {
		ctx.abort(error);
		} else {
		ctx.done(res);
		}
		} else if (detach \|\| !!once) {
		handler.detach();
		}

		}

		private triggerHandler<U>(
		handler: Handler<T, U>,
		wTimer: [NodeJS.Timer \| undefined],
		resolvePr: (transformedData: any) => void,
		opResult: Operator.fλ.Result.Matched<any, any>
		): void {

		const { callback, once } = handler;

		if (wTimer[0] !== undefined) {
		clearTimeout(wTimer[0]);
		wTimer[0] = undefined;
		}

		Evt.doDetachIfNeeded(handler, opResult, once);

		const [transformedData] = opResult;

		callback?.call(
		this,
		transformedData
		);

		resolvePr(transformedData);

		}

		private addHandler<U>(
		propsFromArgs: Handler.PropsFromArgs<T, U>,
		propsFromMethodName: Handler.PropsFromMethodName
		): Handler<T, U> {

		if (Operator.fλ.Stateful.match<T, any, any>(propsFromArgs.op)) {

		this.statelessByStatefulOp.set(
		propsFromArgs.op,
		encapsulateOpState(propsFromArgs.op)
		);

		}

		const handler: Handler<T, U> = {
		...propsFromArgs,
		...propsFromMethodName,
		"detach": null as any,
		"promise": null as any
		};

		if (handler.async) {

		this.asyncHandlerChronologyMark.set(
		handler,
		this.getChronologyMark()
		);

		}

		(handler.promise as (typeof handler)["promise"]) = new Promise<U>(
		(resolve, reject) => {

		const wTimer: [NodeJS.Timer \| undefined] = [undefined];

		if (typeof handler.timeout === "number") {

		wTimer[0] = setTimeout(() => {

		wTimer[0] = undefined;

		handler.detach();

		reject(new EvtError.Timeout(handler.timeout!));

		}, handler.timeout);

		}

		(handler.detach as (typeof handler)["detach"]) =
		() => this.detachHandler(handler, wTimer, reject)
		;

		this.handlerTriggers.set(
		handler,
		opResult => this.triggerHandler(
		handler,
		wTimer,
		resolve,
		opResult
		)
		);

		}
		);


		if (handler.prepend) {

		let i: number;

		for (i = 0; i < this.handlers.length; i++) {

		if (this.handlers[i].extract) {
		continue;
		}

		break;

		}

		this.handlers.splice(i, 0, handler);

		} else {

		this.handlers.push(handler);

		}

		if (
		this.__maxHandlers !== 0 &&
		this.handlers.length % (this.__maxHandlers + 1) === 0
		) {
		const message = [
		`MaxHandlersExceededWarning: Possible Evt memory leak detected.`,
		`${this.handlers.length} handlers attached${this.traceId ? ` to ${this.traceId}` : ""}.`,
		`Use evt.setMaxHandlers() to increase limit.`
		].join(" ");

		try {
		console.warn(message);
		} catch{
		}

		}

		if (typeGuard<Handler<T, U, CtxLike<any>>>(handler, !!handler.ctx)) {
		handler.ctx.zz__addHandler(handler, this);
		}

		this.onHandler?.(true, handler);

		return handler;

		}

		/** https://docs.evt.land/api/evt/getstatelessop */
		public getStatelessOp<U, CtxResult>(op: Operator<T, U, CtxResult>): Operator.Stateless<T, U, CtxResult> {
		return Operator.fλ.Stateful.match(op) ?
		this.statelessByStatefulOp.get(op)! :
		op
		}

		private trace(data: T) {

		if (this.traceId === null) {
		return;
		}

		let message = `(${this.traceId}) `;

		const isExtracted = !!this.handlers.find(
		({ extract, op }) => (
		extract &&
		!!this.getStatelessOp(op)(data)
		)
		);

		if (isExtracted) {

		message += "extracted ";

		} else {

		const handlerCount = this.handlers
		.filter(
		({ extract, op }) => !extract &&
		!!this.getStatelessOp(op)(data)
		)
		.length;

		message += `${handlerCount} handler${(handlerCount > 1) ? "s" : ""} => `;

		}

		this.log(message + this.traceFormatter(data));

		}


		/**
		* https://garronej.github.io/ts-evt/#evtattach-evtattachonce-and-evtpost
		*
		* Returns post count
		* */
		public post(data: T): number {

		this.trace(data);

		setPostCount(this, this.postCount + 1);

		//NOTE: Must be before postSync.
		const postChronologyMark = this.getChronologyMark();

		const isExtracted = this.postSync(data);

		if (!isExtracted) {
		this.postAsync(
		data,
		postChronologyMark
		);
		}

		return this.postCount;

		}



		/** Return isExtracted */
		private postSync(data: T): boolean {

		for (const handler of [...this.handlers]) {

		const { async, op, extract } = handler;

		if (async) {
		continue;
		}

		const opResult = invokeOperator(
		this.getStatelessOp(op),
		data,
		true
		);

		if (Operator.fλ.Result.NotMatched.match(opResult)) {

		Evt.doDetachIfNeeded(handler, opResult);

		continue;

		}

		const handlerTrigger = this.handlerTriggers.get(handler);

		//NOTE: Possible if detached while in the loop.
		if (!handlerTrigger) {
		continue;
		}

		handlerTrigger(opResult);

		if (extract) {
		return true;
		}

		}

		return false;

		}

		private readonly postAsync = runExclusive.buildMethodCb(
		(data: T, postChronologyMark: number, releaseLock?) => {

		const promises: Promise<void>[] = [];

		let chronologyMarkStartResolveTick: number;

		//NOTE: Must be before handlerTrigger call.
		Promise.resolve().then(
		() => chronologyMarkStartResolveTick = this.getChronologyMark()
		);

		for (const handler of [...this.handlers]) {

		if (!handler.async) {
		continue;
		}

		const opResult = invokeOperator(
		this.getStatelessOp(handler.op),
		data,
		true
		);

		if (Operator.fλ.Result.NotMatched.match(opResult)) {

		Evt.doDetachIfNeeded(handler, opResult);

		continue;

		}

		const handlerTrigger = this.handlerTriggers.get(handler);

		if (!handlerTrigger) {
		continue;
		}

		const shouldCallHandlerTrigger = (() => {

		const handlerMark = this.asyncHandlerChronologyMark.get(handler)!;

		if (postChronologyMark > handlerMark) {
		return true;
		}

		const exceptionRange = this.asyncHandlerChronologyExceptionRange.get(handler);

		return (
		exceptionRange !== undefined &&
		exceptionRange.lowerMark < postChronologyMark &&
		postChronologyMark < exceptionRange.upperMark &&
		handlerMark > exceptionRange.upperMark
		);

		})();

		if (!shouldCallHandlerTrigger) {
		continue;
		}

		promises.push(
		new Promise<void>(
		resolve => handler.promise
		.then(() => resolve())
		.catch(() => resolve())
		)
		);

		handlerTrigger(opResult);

		}

		if (promises.length === 0) {
		releaseLock();
		return;
		}

		const handlersDump = [...this.handlers];

		Promise.all(promises).then(() => {

		for (const handler of this.handlers) {

		if (!handler.async) {
		continue;
		}

		if (handlersDump.indexOf(handler) >= 0) {
		continue;
		}

		this.asyncHandlerChronologyExceptionRange.set(
		handler,
		{
		"lowerMark": postChronologyMark,
		"upperMark": chronologyMarkStartResolveTick
		}
		);

		}

		releaseLock();

		});

		}
		);

		private __waitFor<U>(attachParams: Handler.PropsFromArgs<T, U>): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": true,
		"extract": false,
		"once": true,
		"prepend": false
		}
		).promise;

		}

		private __attach<U>(
		attachParams: Handler.PropsFromArgs<T, U>
		): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": false,
		"extract": false,
		"once": false,
		"prepend": false
		}
		).promise;

		}

		private __attachExtract<U>(
		attachParams: Handler.PropsFromArgs<T, U>
		): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": false,
		"extract": true,
		"once": false,
		"prepend": true
		}
		).promise;

		}

		private __attachPrepend<U>(
		attachParams: Handler.PropsFromArgs<T, U>
		): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": false,
		"extract": false,
		"once": false,
		"prepend": true
		}
		).promise;

		}

		private __attachOnce<U>(
		attachParams: Handler.PropsFromArgs<T, U>
		): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": false,
		"extract": false,
		"once": true,
		"prepend": false
		}
		).promise;

		}

		private __attachOncePrepend<U>(
		attachParams: Handler.PropsFromArgs<T, U>
		): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": false,
		"extract": false,
		"once": true,
		"prepend": true
		}
		).promise;

		}

		private __attachOnceExtract<U>(
		attachParams: Handler.PropsFromArgs<T, U>
		): Promise<U> {

		return this.addHandler(
		attachParams,
		{
		"async": false,
		"extract": true,
		"once": true,
		"prepend": true
		}
		).promise;

		}

		/**
		* https://docs.evt.land/api/evt/ishandled
		*
		* Test if posting a given event data will have an effect.
		*
		* Return true if:
		* -There is at least one handler matching
		* this event data ( at least one handler's callback function
		* will be invoked if the data is posted. )
		* -Handlers could be will be detached
		* if the event data is posted.
		*
		*/
		public isHandled(data: T): boolean {
		return !!this.getHandlers()
		.find(
		({ op }) => !!this.getStatelessOp(op)(data)
		)
		;
		}

		/** https://docs.evt.land/api/evt/gethandler */
		public getHandlers(): Handler<T, any>[] {
		return [...this.handlers];
		}

		/**
		* https://docs.evt.land/api/evt/detach
		*
		* Detach every handlers of the Evt that are bound to the provided context
		* */
		public detach<CtxResult>(ctx: CtxLike<CtxResult>): Handler<T, any, CtxLike<CtxResult>>[];
		/**
		* https://docs.evt.land/api/evt/detach
		*
		* (unsafe) Detach every handlers from the Evt
		* */
		public detach(): Handler<T, any>[];
		public detach(ctx?: CtxLike<any>): Handler<T, any>[] {

		const detachedHandlers: Handler<T, any>[] = [];

		for (const handler of this.getHandlers()) {

		if (ctx !== undefined && handler.ctx !== ctx) {
		continue;
		}

		const wasStillAttached = handler.detach();

		//NOTE: It should not be possible.
		if (!wasStillAttached) {
		continue;
		}

		detachedHandlers.push(handler);

		}

		return detachedHandlers;

		}












		private __parseOverloadParams = parseOverloadParamsFactory<T>();
		@@ -92,4 +834,4 @@

		public pipe<U>(
		op: Operator.fλ<T, U>
		public pipe<U, CtxResult>(
		op: Operator.fλ<T, U, CtxResult>
		): Evt<U>;
		@@ -103,36 +845,36 @@ public pipe<U extends T>(

		public pipe(ctx: Ctx): Evt<T>;
		public pipe(ctx: CtxLike<any>): Evt<T>;

		public pipe<U>(
		ctx: Ctx,
		op: Operator.fλ<T, U>
		public pipe<U, CtxResult>(
		ctx: CtxLike<any>,
		op: Operator.fλ<T, U, CtxResult>
		): Evt<U>;
		public pipe<U extends T>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		op: (data: T) => data is U
		): Evt<U>;
		public pipe(
		ctx: Ctx,
		ctx: CtxLike<any>,
		op: (data: T) => boolean
		): Evt<T>;

		public pipe<B, C>(
		op1: Operator.fλ<T, B>,
		op2: Operator.fλ<B, C>
		public pipe<B, C, CtxResultOp1, CtxResultOp2>(
		op1: Operator.fλ<T, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>
		): Evt<C>;
		public pipe<B, C extends B>(
		op1: Operator.fλ<T, B>,
		public pipe<B, C extends B, CtxResult>(
		op1: Operator.fλ<T, B, CtxResult>,
		op2: (data: B) => data is C
		): Evt<C>;
		public pipe<B>(
		op1: Operator.fλ<T, B>,
		public pipe<B, CtxResult>(
		op1: Operator.fλ<T, B, CtxResult>,
		op2: (data: B) => boolean
		): Evt<B>;
		public pipe<B extends T, C>(
		public pipe<B extends T, C, CtxResult>(
		op1: (data: T) => data is B,
		op2: Operator.fλ<B, C>
		op2: Operator.fλ<B, C, CtxResult>
		): Evt<B>;
		public pipe<B>(
		public pipe<B, CtxResult>(
		op1: (data: T) => boolean,
		op2: Operator.fλ<T, B>
		op2: Operator.fλ<T, B, CtxResult>
		): Evt<B>;
		@@ -157,55 +899,55 @@ public pipe<B extends T, C extends B>(

		public pipe<B, C, D>(
		op1: Operator.fλ<T, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>
		public pipe<B, C, D, CtxResultOp1, CtxResultOp2, CtxResultOp3>(
		op1: Operator.fλ<T, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>
		): Evt<D>;

		public pipe<B, C, D, E>(
		op1: Operator.fλ<T, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>,
		op4: Operator.fλ<D, E>
		public pipe<B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(
		op1: Operator.fλ<T, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>,
		op4: Operator.fλ<D, E, CtxResultOp4>
		): Evt<E>;

		public pipe<B, C, D, E>(
		op1: Operator.fλ<T, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>,
		op4: Operator.fλ<D, E>
		public pipe<B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(
		op1: Operator.fλ<T, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>,
		op4: Operator.fλ<D, E, CtxResultOp4>
		): Evt<E>;

		public pipe<B, C, D, E, F>(
		op1: Operator.fλ<T, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>,
		op4: Operator.fλ<D, E>,
		op5: Operator.fλ<E, F>
		public pipe<B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(
		op1: Operator.fλ<T, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>,
		op4: Operator.fλ<D, E, CtxResultOp4>,
		op5: Operator.fλ<E, F, CtxResultOp5>
		): Evt<F>;


		public pipe<B, C>(
		op1: Operator<T, B>,
		op2: Operator<B, C>
		public pipe<B, C, CtxResultOp1 = any, CtxResultOp2 = any>(
		op1: Operator<T, B, CtxResultOp2>,
		op2: Operator<B, C, CtxResultOp2>
		): Evt<C>;

		public pipe<B, C, D>(
		op1: Operator<T, B>,
		op2: Operator<B, C>,
		op3: Operator<C, D>
		public pipe<B, C, D, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any>(
		op1: Operator<T, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>,
		op3: Operator<C, D, CtxResultOp3>
		): Evt<D>;

		public pipe<B, C, D, E>(
		op1: Operator<T, B>,
		op2: Operator<B, C>,
		op3: Operator<C, D>,
		op4: Operator<D, E>
		public pipe<B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(
		op1: Operator<T, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>,
		op3: Operator<C, D, CtxResultOp3>,
		op4: Operator<D, E, CtxResultOp4>
		): Evt<E>;

		public pipe<B, C, D, E, F>(
		op1: Operator<T, B>,
		op2: Operator<B, C>,
		op3: Operator<C, D>,
		op4: Operator<D, E>,
		op5: Operator<E, F>
		public pipe<B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(
		op1: Operator<T, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>,
		op3: Operator<C, D, CtxResultOp3>,
		op4: Operator<D, E, CtxResultOp4>,
		op5: Operator<E, F, CtxResultOp5>
		): Evt<F>;
		@@ -215,4 +957,4 @@
		...ops: [
		Operator<T, any>,
		...Operator<any, any>[]
		Operator<T, any, any>,
		...Operator<any, any, any>[]
		]
		@@ -223,4 +965,4 @@ ): Evt<any>;
		...ops: [
		Operator<T, any>,
		...Operator<any, any>[]
		Operator<T, any, any>,
		...Operator<any, any, any>[]
		]
		@@ -254,5 +996,5 @@ ): Evt<any>;
		*/
		public waitFor<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public waitFor<U, CtxResult>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout?: number
		@@ -271,3 +1013,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout?: number
		@@ -286,3 +1028,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout?: number
		@@ -297,4 +1039,4 @@ ): Promise<T>;
		*/
		public waitFor<U>(
		op: Operator.fλ.Stateless<T, U>,
		public waitFor<U, CtxResult>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		timeout?: number
		@@ -332,3 +1074,3 @@ ): Promise<U>;
		public waitFor(
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout?: number
		@@ -345,3 +1087,3 @@ ): Promise<T>;
		public waitFor(...inputs: any[]) {
		return super.__waitFor(this.__parseOverloadParams(inputs, "waitFor"));
		return this.__waitFor(this.__parseOverloadParams(inputs, "waitFor"));
		}
		@@ -366,5 +1108,5 @@
		*/
		public $attach<U>(
		op: Operator.fλ<T, U>,
		ctx: Ctx,
		public $attach<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -382,5 +1124,5 @@ callback: (transformedData: U) => void
		*/
		public $attach<U>(
		op: Operator.fλ<T, U>,
		ctx: Ctx,
		public $attach<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		ctx: CtxLike<CtxResult>,
		callback: (transformedData: U) => void
		@@ -397,4 +1139,4 @@ ): Promise<U>;
		*/
		public $attach<U>(
		op: Operator.fλ<T, U>,
		public $attach<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		timeout: number,
		@@ -410,4 +1152,4 @@ callback: (transformedData: U) => void
		*/
		public $attach<U>(
		op: Operator.fλ<T, U>,
		public $attach<U, R>(
		op: Operator.fλ<T, U, R>,
		callback: (transformedData: U) => void
		@@ -438,3 +1180,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -456,3 +1198,3 @@ callback: (data: Q) => void
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -472,3 +1214,3 @@ callback: (data: T) => void
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: Q) => void
		@@ -487,3 +1229,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -529,3 +1271,3 @@ ): Promise<T>;
		public attach(
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -564,3 +1306,3 @@ callback: (data: T) => void
		public attach(
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -605,5 +1347,5 @@ ): Promise<T>;
		*/
		public $attachOnce<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public $attachOnce<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -621,5 +1363,5 @@ callback: (transformedData: U) => void
		*/
		public $attachOnce<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public $attachOnce<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		callback: (transformedData: U) => void
		@@ -636,4 +1378,4 @@ ): Promise<U>;
		*/
		public $attachOnce<U>(
		op: Operator.fλ.Stateless<T, U>,
		public $attachOnce<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		timeout: number,
		@@ -649,4 +1391,4 @@ callback: (transformedData: U) => void
		*/
		public $attachOnce<U>(
		op: Operator.fλ.Stateless<T, U>,
		public $attachOnce<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		callback: (transformedData: U) => void
		@@ -676,3 +1418,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -694,3 +1436,3 @@ callback: (data: Q) => void
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -710,3 +1452,3 @@ callback: (data: T) => void
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: Q) => void
		@@ -725,3 +1467,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -767,3 +1509,3 @@ ): Promise<T>;
		public attachOnce(
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -802,3 +1544,3 @@ callback: (data: T) => void
		public attachOnce(
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -844,5 +1586,5 @@ ): Promise<T>;
		*/
		public $attachExtract<U>(
		op: Operator.fλ<T, U>,
		ctx: Ctx,
		public $attachExtract<U, CtxResult>(
		op: Operator.fλ<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -860,5 +1602,5 @@ callback: (transformedData: U) => void
		*/
		public $attachExtract<U>(
		op: Operator.fλ<T, U>,
		ctx: Ctx,
		public $attachExtract<U, CtxResult>(
		op: Operator.fλ<T, U, CtxResult>,
		ctx: CtxLike<any>,
		callback: (transformedData: U) => void
		@@ -875,4 +1617,4 @@ ): Promise<U>;
		*/
		public $attachExtract<U>(
		op: Operator.fλ<T, U>,
		public $attachExtract<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		timeout: number,
		@@ -888,4 +1630,4 @@ callback: (transformedData: U) => void
		*/
		public $attachExtract<U>(
		op: Operator.fλ<T, U>,
		public $attachExtract<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		callback: (transformedData: U) => void
		@@ -917,3 +1659,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -935,3 +1677,3 @@ callback: (data: Q) => void
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -951,3 +1693,3 @@ callback: (data: T) => void
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: Q) => void
		@@ -966,3 +1708,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1045,5 +1787,5 @@ ): Promise<T>;
		*/
		public $attachPrepend<U>(
		op: Operator.fλ<T, U>,
		ctx: Ctx,
		public $attachPrepend<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1061,5 +1803,5 @@ callback: (transformedData: U) => void
		*/
		public $attachPrepend<U>(
		op: Operator.fλ<T, U>,
		ctx: Ctx,
		public $attachPrepend<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		ctx: CtxLike<any>,
		callback: (transformedData: U) => void
		@@ -1076,4 +1818,4 @@ ): Promise<U>;
		*/
		public $attachPrepend<U>(
		op: Operator.fλ<T, U>,
		public $attachPrepend<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		timeout: number,
		@@ -1089,4 +1831,4 @@ callback: (transformedData: U) => void
		*/
		public $attachPrepend<U>(
		op: Operator.fλ<T, U>,
		public $attachPrepend<U, CtxResult = any>(
		op: Operator.fλ<T, U, CtxResult>,
		callback: (transformedData: U) => void
		@@ -1119,3 +1861,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1138,3 +1880,3 @@ callback: (data: Q) => void
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1155,3 +1897,3 @@ callback: (data: T) => void
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: Q) => void
		@@ -1170,3 +1912,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1212,3 +1954,3 @@ ): Promise<T>;
		public attachPrepend(
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1247,3 +1989,3 @@ callback: (data: T) => void
		public attachPrepend(
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1291,5 +2033,5 @@ ): Promise<T>;
		*/
		public $attachOncePrepend<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public $attachOncePrepend<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1307,5 +2049,5 @@ callback: (transformedData: U) => void
		*/
		public $attachOncePrepend<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public $attachOncePrepend<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		callback: (transformedData: U) => void
		@@ -1322,4 +2064,4 @@ ): Promise<U>;
		*/
		public $attachOncePrepend<U>(
		op: Operator.fλ.Stateless<T, U>,
		public $attachOncePrepend<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		timeout: number,
		@@ -1335,4 +2077,4 @@ callback: (transformedData: U) => void
		*/
		public $attachOncePrepend<U>(
		op: Operator.fλ.Stateless<T, U>,
		public $attachOncePrepend<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		callback: (transformedData: U) => void
		@@ -1365,3 +2107,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1383,3 +2125,3 @@ callback: (data: Q) => void
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1399,3 +2141,3 @@ callback: (data: T) => void
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: Q) => void
		@@ -1414,3 +2156,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1456,3 +2198,3 @@ ): Promise<T>;
		public attachOncePrepend(
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1491,3 +2233,3 @@ callback: (data: T) => void
		public attachOncePrepend(
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1536,5 +2278,5 @@ ): Promise<T>;
		*/
		public $attachOnceExtract<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public $attachOnceExtract<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1552,5 +2294,5 @@ callback: (transformedData: U) => void
		*/
		public $attachOnceExtract<U>(
		op: Operator.fλ.Stateless<T, U>,
		ctx: Ctx,
		public $attachOnceExtract<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		ctx: CtxLike<any>,
		callback: (transformedData: U) => void
		@@ -1567,4 +2309,4 @@ ): Promise<U>;
		*/
		public $attachOnceExtract<U>(
		op: Operator.fλ.Stateless<T, U>,
		public $attachOnceExtract<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		timeout: number,
		@@ -1580,4 +2322,4 @@ callback: (transformedData: U) => void
		*/
		public $attachOnceExtract<U>(
		op: Operator.fλ.Stateless<T, U>,
		public $attachOnceExtract<U, CtxResult = any>(
		op: Operator.fλ.Stateless<T, U, CtxResult>,
		callback: (transformedData: U) => void
		@@ -1609,3 +2351,3 @@ ): Promise<U>;
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1627,3 +2369,3 @@ callback: (data: Q) => void
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1643,3 +2385,3 @@ callback: (data: T) => void
		op: (data: T) => data is Q,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: Q) => void
		@@ -1658,3 +2400,3 @@ ): Promise<Q>;
		op: (data: T) => boolean,
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1698,3 +2440,3 @@ ): Promise<T>;
		public attachOnceExtract(
		ctx: Ctx,
		ctx: CtxLike<any>,
		timeout: number,
		@@ -1733,3 +2475,3 @@ callback: (data: T) => void
		public attachOnceExtract(
		ctx: Ctx,
		ctx: CtxLike<any>,
		callback: (data: T) => void
		@@ -1763,2 +2505,13 @@ ): Promise<T>;

		/** https://docs.evt.land/api/voidevt */
		export class VoidEvt extends Evt<void> {

		public post(): number {
		return super.post(undefined);
		}

		public async postAsyncOnceHandled() {
		return super.postAsyncOnceHandled(undefined);
		}

		}

5

src/lib/index.ts

		export * from "./Evt";
		export * from "./VoidEvt"
		export * from "./Ctx";
		export * from "./types";
		export * from "./Observable";
		export * from "./util";
		export * from "./Ctx";
		export * from "./util";

8

src/lib/types/EventTargetLike.ts

		@@ -37,3 +37,3 @@
		return (
		typeGuard.dry<RxJSSubject<T>>(eventTarget) &&
		typeGuard<RxJSSubject<T>>(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -69,3 +69,3 @@ typeof eventTarget.subscribe === "function"
		return (
		typeGuard.dry<NodeStyleEventEmitter>(eventTarget) &&
		typeGuard<NodeStyleEventEmitter>(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -88,3 +88,3 @@ typeof eventTarget.addListener === "function" &&
		return (
		typeGuard.dry<JQueryStyleEventEmitter>(eventTarget) &&
		typeGuard<JQueryStyleEventEmitter>(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -113,3 +113,3 @@ typeof eventTarget.on === "function" &&
		return (
		typeGuard.dry<HasEventTargetAddRemove<T>>(eventTarget) &&
		typeGuard<HasEventTargetAddRemove<T>>(eventTarget) &&
		eventTarget instanceof Object &&
		@@ -116,0 +116,0 @@ typeof eventTarget.addEventListener === "function" &&

16

src/lib/types/Handler.ts

		import { Operator } from "./Operator";
		type EvtCore<T> = import("../EvtCore").EvtCore<T>;
		type Ctx<T=any> = import("../Ctx").Ctx<T>;
		type EvtLike<T> = import("../Evt").EvtLike<T>;
		type CtxLike<T> = import("../Ctx").CtxLike<T>;


		/** https://docs.evt.land/api/handler */
		export type Handler<T, U, CtxProp extends Ctx<any> \| undefined = Ctx \| undefined> =
		export type Handler<T, U, CtxProp extends CtxLike<any> \| undefined = CtxLike<any> \| undefined> =
		Handler.PropsFromArgs<T, U, CtxProp> &
		@@ -18,6 +18,6 @@ Handler.PropsFromMethodName & Readonly<{
		/** Handlers params that come from the arguments passed to the method invoked */
		export type PropsFromArgs<T, U, CtxProp extends Ctx \| undefined = Ctx \| undefined> = {
		export type PropsFromArgs<T, U, CtxProp extends CtxLike<any> \| undefined = CtxLike<any> \| undefined> = {
		ctx: CtxProp;
		timeout: number \| undefined;
		op: Operator<T, U>;
		op: Operator<T, U, CtxProp extends CtxLike<infer CtxResult> ? CtxResult : undefined>;
		callback: ((transformedData: U) => void) \| undefined;
		@@ -56,7 +56,7 @@ };

		export type WithEvt<T> = {
		handler: Handler<T, any, Ctx>;
		evt: EvtCore<T>;
		export type WithEvt<T,CtxResult> = {
		handler: Handler<T, any, CtxLike<CtxResult>>;
		evt: EvtLike<T>;
		};

		}

2

src/lib/types/helper/index.ts

		@@ -5,4 +5,4 @@
		export * from "./UnpackEvt";
		export * from "./EvtLike";
		export * from "./UnpackCtx";

		//( 2.8 Introduce conditional types with infer keyword and Exclude )

4

src/lib/types/helper/NonPostable.ts


		//type EvtCore<T> = import("../../EvtCore").EvtCore<T>;

		import { EvtLike } from "./EvtLike";

		type EvtLike<T> = import("../../Evt").EvtLike<T>

		//NOTE: Omit only introduced in 3.5
		@@ -7,0 +7,0 @@ /**

2

src/lib/types/helper/UnpackEvt.ts


		import { EvtLike } from "./EvtLike";
		type EvtLike<T> = import("../../Evt").EvtLike<T>

		@@ -4,0 +4,0 @@ /** https://docs.evt.land/api/unpackevt */

83

src/lib/types/Operator.ts

		@@ -1,8 +0,8 @@
		type Ctx<T = any> = import("../Ctx").Ctx<T>;
		type VoidCtx= import("../Ctx").VoidCtx;
		type CtxLike<Result> = import("../Ctx").CtxLike<Result>;
		type VoidCtxLike = import("../Ctx").VoidCtxLike;
		import { typeGuard } from "../../tools/typeSafety";

		/** https://docs.evt.land/api/operator */
		export type Operator<T, U> =
		Operator.fλ<T, U> \|
		export type Operator<T, U, CtxResult> =
		Operator.fλ<T, U, CtxResult> \|
		((data: U) => boolean) \| //Filter
		@@ -14,5 +14,5 @@ (U extends T ? (data: T) => data is U : never) //Type guard

		export type fλ<T, U> =
		fλ.Stateless<T, U> \|
		fλ.Stateful<T, U>
		export type fλ<T, U, CtxResult> =
		fλ.Stateless<T, U, CtxResult> \|
		fλ.Stateful<T, U, CtxResult>
		;
		@@ -22,6 +22,6 @@

		export type Stateless<T, U> = (data: T, prev?: undefined, isPost?: true) => Result<U>;
		export type Stateless<T, U, CtxResult> = (data: T, prev?: undefined, isPost?: true) => Result<U, CtxResult>;

		export type Stateful<T, U> = [
		(data: T, prev: U, isPost?: true) => Result<U>,
		export type Stateful<T, U, CtxResult> = [
		(data: T, prev: U, isPost?: true) => Result<U, CtxResult>,
		U //Seed
		@@ -32,3 +32,3 @@ ];

		export function match<T, U>(op: Operator<T, U>): op is Stateful<T, U> {
		export function match<T, U, CtxResult>(op: Operator<T, U, CtxResult>): op is Stateful<T, U, CtxResult> {
		return typeof op !== "function";
		@@ -39,13 +39,13 @@ }

		export type Result<U> = Result.Matched<U> \| Result.NotMatched;
		export type Result<U, CtxResult> = Result.Matched<U, CtxResult> \| Result.NotMatched<CtxResult>;

		export namespace Result {

		export function match<U>(result: any): result is Result<U> {
		export function match<U, CtxResult>(result: any): result is Result<U, CtxResult> {
		return Matched.match(result) \|\| NotMatched.match(result);
		}

		export function getDetachArg(result: Result<any>): boolean \| [Ctx, undefined \| Error, any] {
		export function getDetachArg<CtxResult>(result: Result<any, CtxResult>): boolean \| [CtxLike<CtxResult>, undefined \| Error, CtxResult] {

		const detach = Matched.match(result) ? result[1] : result;
		const detach = Matched.match<any, CtxResult>(result) ? result[1] : result;

		@@ -56,7 +56,7 @@ if (Detach.FromEvt.match(detach)) {

		if (Detach.WithCtxArg.match(detach)) {
		if (Detach.WithCtxArg.match<CtxResult>(detach)) {
		return [
		detach.DETACH,
		(detach as Extract<Result<any>, { err: any }>).err,
		(detach as Extract<Result<any>, { res: any }>).res
		detach.DETACH as Exclude<typeof detach.DETACH, VoidCtxLike>,
		(detach as Extract<Result<any,CtxResult>, { err: any }>).err,
		(detach as Extract<Result<any, CtxResult>, { res: any }>).res
		];
		@@ -70,7 +70,7 @@ }

		export type NotMatched = Detach \| null;
		export type NotMatched<CtxResult> = Detach<CtxResult> \| null;

		export namespace NotMatched {

		export function match(result: any): result is NotMatched {
		export function match<CtxResult>(result: any): result is NotMatched<CtxResult> {
		return (
		@@ -84,3 +84,3 @@ result === null \|\|

		export type Matched<U> = Matched.NoDetachArg<U> \| Matched.WithDetachArg<U>;
		export type Matched<U, CtxResult> = Matched.NoDetachArg<U> \| Matched.WithDetachArg<U, CtxResult>;

		@@ -91,9 +91,9 @@ export namespace Matched {

		export type WithDetachArg<U> = readonly [U, Detach \| null];
		export type WithDetachArg<U, CtxResult> = readonly [U, Detach<CtxResult> \| null];

		export function match(
		export function match<U,CtxResult>(
		result: any,
		): result is Matched<any> {
		): result is Matched<U, CtxResult> {
		return (
		typeGuard.dry<Matched<any>>(result) &&
		typeGuard<Matched<U, CtxResult>>(result) &&
		result instanceof Object &&
		@@ -115,3 +115,3 @@ (

		export type Detach = Detach.FromEvt \| Detach.WithCtxArg;
		export type Detach<CtxResult> = Detach.FromEvt \| Detach.WithCtxArg<CtxResult>;

		@@ -130,13 +130,19 @@ export namespace Detach {

		export type WithCtxArg<T = any> =
		{ DETACH: Ctx<T>; err: Error; } \|
		{ DETACH: Ctx<T>; res: T; } \|
		{ DETACH: VoidCtx; err: Error; } \|
		{ DETACH: VoidCtx; }
		;
		export type WithCtxArg<CtxResult> = WithCtxArg.Void \| WithCtxArg.Arg<CtxResult>;

		export namespace WithCtxArg {
		export function match(detach: any): detach is WithCtxArg {

		export type Void =
		{ DETACH: VoidCtxLike; err: Error; } \|
		{ DETACH: VoidCtxLike; }
		;

		export type Arg<CtxResult> =
		{ DETACH: CtxLike<CtxResult>; err: Error; } \|
		{ DETACH: CtxLike<CtxResult>; res: CtxResult; }
		;

		export function match<CtxResult>(detach: any): detach is WithCtxArg<CtxResult> {
		return (
		typeGuard.dry<Detach>(detach) &&
		typeGuard<Detach<CtxResult>>(detach) &&
		detach instanceof Object &&
		@@ -146,5 +152,6 @@ detach.DETACH instanceof Object
		}

		}

		export function match(detach: any): detach is Detach {
		export function match<CtxResult>(detach: any): detach is Detach<CtxResult> {
		return FromEvt.match(detach) \|\| WithCtxArg.match(detach);
		@@ -159,4 +166,4 @@ }

		export type Stateless<T, U> =
		fλ.Stateless<T, U> \|
		export type Stateless<T, U, CtxResult> =
		fλ.Stateless<T, U, CtxResult> \|
		((data: U) => boolean) \|
		@@ -163,0 +170,0 @@ (U extends T ? (data: T) => data is U : never)

276

src/lib/util/compose.ts

		@@ -5,11 +5,13 @@ import { encapsulateOpState } from "./encapsulateOpState";
		import { id } from "../../tools/typeSafety/id";
		import { assert } from "../../tools/typeSafety/assert";
		import { typeGuard } from "../../tools/typeSafety/typeGuard";

		function f_o_g<A, B, C>(
		op1: Operator<A, B>,
		op2: Operator<B, C>
		): Operator.fλ.Stateless<A, C> {
		function f_o_g<A, B, C, CtxResultOp1 = any, CtxResultOp2 = any>(
		op1: Operator<A, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>
		): Operator.fλ.Stateless<A, C, CtxResultOp1 \| CtxResultOp2> {

		const opAtoB = Operator.fλ.Stateful.match(op1) ?
		encapsulateOpState(op1) :
		id<Operator.Stateless<A, B>>(op1)
		id<Operator.Stateless<A, B, CtxResultOp1>>(op1)
		;
		@@ -19,7 +21,7 @@
		encapsulateOpState(op2) :
		id<Operator.Stateless<B, C>>(op2)
		id<Operator.Stateless<B, C, CtxResultOp2>>(op2)
		;

		return id<Operator.fλ.Stateless<A, C>>(
		(...[dataA, , cbInvokedIfMatched]) => {
		return id<Operator.fλ.Stateless<A, C, CtxResultOp1 \| CtxResultOp2>>(
		(...[dataA, , isPost]) => {

		@@ -29,11 +31,17 @@ const resultB = invokeOperator(
		dataA,
		cbInvokedIfMatched
		isPost
		);

		if (Operator.fλ.Result.NotMatched.match(resultB)) {
		if (Operator.fλ.Result.NotMatched.match<CtxResultOp1>(resultB)) {
		//CtxResultOp1 assignable to CtxResultOp1 \| CtxResultOp2...
		assert(typeGuard<Operator.fλ.Result.NotMatched<CtxResultOp1 \| CtxResultOp2>>(resultB));
		return resultB;
		}


		const detachOp1 = resultB[1] ?? null;

		//...same...
		assert(typeGuard<Operator.fλ.Result.Detach<CtxResultOp1 \| CtxResultOp2>>(detachOp1));

		const [dataB] = resultB;
		@@ -44,14 +52,18 @@
		dataB,
		cbInvokedIfMatched
		isPost
		);

		if (Operator.fλ.Result.NotMatched.match(resultC)) {
		if (Operator.fλ.Result.NotMatched.match<CtxResultOp2>(resultC)) {
		//...same
		assert(typeGuard<Operator.fλ.Result.NotMatched<CtxResultOp1 \| CtxResultOp2>>(resultC));
		return detachOp1 ?? resultC;
		}

		return id<Operator.fλ.Result<C>>([
		return id<Operator.fλ.Result<C, CtxResultOp1 \| CtxResultOp2>>([
		resultC[0],
		detachOp1 ?? resultC[1] ?? null
		detachOp1 ?? resultC[1] ?? null
		]);



		}
		@@ -61,94 +73,94 @@ );

		export function compose<A, B, C>(
		op1: Operator.fλ<A, B>,
		op2: Operator.fλ<B, C>
		): Operator.fλ.Stateless<A, C>;
		export function compose<A, B, C extends B>(
		op1: Operator.fλ<A, B>,
		export function compose<A, B, C, CtxResultOp1 = any, CtxResultOp2 = any>(
		op1: Operator.fλ<A, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>
		): Operator.fλ.Stateless<A, C, CtxResultOp1 \| CtxResultOp2>;
		export function compose<A, B, C extends B, CtxResult = any>(
		op1: Operator.fλ<A, B, CtxResult>,
		op2: (data: B) => data is C,
		): Operator.fλ.Stateless<A, C>;
		export function compose<A, B>(
		op1: Operator.fλ<A, B>,
		): Operator.fλ.Stateless<A, C, CtxResult>;
		export function compose<A, B, CtxResult = any>(
		op1: Operator.fλ<A, B, CtxResult>,
		op2: (data: B) => boolean,
		): Operator.fλ.Stateless<A, B>;
		export function compose<A, B extends A, C>(
		): Operator.fλ.Stateless<A, B, CtxResult>;
		export function compose<A, B extends A, C, CtxResult = any>(
		op1: (data: A) => data is B,
		op2: Operator.fλ<B, C>
		): Operator.fλ.Stateless<A, B>;
		export function compose<A, B>(
		op2: Operator.fλ<B, C, CtxResult>
		): Operator.fλ.Stateless<A, B, CtxResult>;
		export function compose<A, B, CtxResult = any>(
		op1: (data: A) => boolean,
		op2: Operator.fλ<A, B>
		): Operator.fλ.Stateless<A, B>;
		op2: Operator.fλ<A, B, CtxResult>
		): Operator.fλ.Stateless<A, B, CtxResult>;
		export function compose<A, B extends A, C extends B>(
		op1: (data: A) => data is B,
		op2: (data: B) => data is C,
		): Operator.fλ.Stateless<A, C>;
		): Operator.fλ.Stateless<A, C, never>;
		export function compose<A, B extends A>(
		op1: (data: A) => data is B,
		op2: (data: B) => boolean,
		): Operator.fλ.Stateless<A, B>;
		): Operator.fλ.Stateless<A, B, never>;
		export function compose<A, B extends A>(
		op1: (data: A) => boolean,
		op2: (data: A) => data is B
		): Operator.fλ.Stateless<A, B>;
		): Operator.fλ.Stateless<A, B, never>;
		export function compose<A>(
		op1: (data: A) => boolean,
		op2: (data: A) => boolean,
		): Operator.fλ.Stateless<A, A>;
		): Operator.fλ.Stateless<A, A, never>;


		export function compose<A, B, C, D>(
		op1: Operator.fλ<A, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>
		): Operator.fλ.Stateless<A, D>;
		export function compose<A, B, C, D, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any>(
		op1: Operator.fλ<A, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>
		): Operator.fλ.Stateless<A, D, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3>;

		export function compose<A, B, C, D, E>(
		op1: Operator.fλ<A, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>,
		op4: Operator.fλ<D, E>
		): Operator.fλ.Stateless<A, E>;
		export function compose<A, B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(
		op1: Operator.fλ<A, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>,
		op4: Operator.fλ<D, E, CtxResultOp4>
		): Operator.fλ.Stateless<A, E, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4>;

		export function compose<A, B, C, D, E>(
		op1: Operator.fλ<A, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>,
		op4: Operator.fλ<D, E>
		): Operator.fλ.Stateless<A, E>;
		export function compose<A, B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any>(
		op1: Operator.fλ<A, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>,
		op4: Operator.fλ<D, E, CtxResultOp4>
		): Operator.fλ.Stateless<A, E, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4>;

		export function compose<A, B, C, D, E, F>(
		op1: Operator.fλ<A, B>,
		op2: Operator.fλ<B, C>,
		op3: Operator.fλ<C, D>,
		op4: Operator.fλ<D, E>,
		op5: Operator.fλ<E, F>,
		): Operator.fλ.Stateless<A, F>;
		export function compose<A, B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(
		op1: Operator.fλ<A, B, CtxResultOp1>,
		op2: Operator.fλ<B, C, CtxResultOp2>,
		op3: Operator.fλ<C, D, CtxResultOp3>,
		op4: Operator.fλ<D, E, CtxResultOp4>,
		op5: Operator.fλ<E, F, CtxResultOp5>
		): Operator.fλ.Stateless<A, F, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4 \| CtxResultOp5>;


		export function compose<A, B, C>(
		op1: Operator<A, B>,
		op2: Operator<B, C>
		): Operator.fλ.Stateless<A, C>;
		export function compose<A, B, C, CtxResultOp1 = any, CtxResultOp2 = any>(
		op1: Operator<A, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>
		): Operator.fλ.Stateless<A, C, CtxResultOp1 \| CtxResultOp2>;

		export function compose<A, B, C, D>(
		op1: Operator<A, B>,
		op2: Operator<B, C>,
		op3: Operator<C, D>
		): Operator.fλ.Stateless<A, D>;
		export function compose<A, B, C, D, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any>(
		op1: Operator<A, B, any>,
		op2: Operator<B, C, any>,
		op3: Operator<C, D, any>
		): Operator.fλ.Stateless<A, D, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3>;

		export function compose<A, B, C, D, E>(
		op1: Operator<A, B>,
		op2: Operator<B, C>,
		op3: Operator<C, D>,
		op4: Operator<D, E>,
		): Operator.fλ.Stateless<A, E>;
		export function compose<A, B, C, D, E, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 = any, CtxResultOp5 = any>(
		op1: Operator<A, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>,
		op3: Operator<C, D, CtxResultOp3>,
		op4: Operator<D, E, CtxResultOp4>,
		): Operator.fλ.Stateless<A, E, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4 \| CtxResultOp5>;

		export function compose<A, B, C, D, E, F>(
		op1: Operator<A, B>,
		op2: Operator<B, C>,
		op3: Operator<C, D>,
		op4: Operator<D, E>,
		op5: Operator<E, F>
		): Operator.fλ.Stateless<A, F>;
		export function compose<A, B, C, D, E, F, CtxResultOp1 = any, CtxResultOp2 = any, CtxResultOp3 = any, CtxResultOp4 =any, CtxResultOp5 = any>(
		op1: Operator<A, B, CtxResultOp1>,
		op2: Operator<B, C, CtxResultOp2>,
		op3: Operator<C, D, CtxResultOp3>,
		op4: Operator<D, E, CtxResultOp4>,
		op5: Operator<E, F, CtxResultOp5>
		): Operator.fλ.Stateless<A, F, CtxResultOp1 \| CtxResultOp2 \| CtxResultOp3 \| CtxResultOp4 \| CtxResultOp5>;

		@@ -158,13 +170,13 @@
		...ops: [
		Operator<T, any>,
		...Operator<any, any>[]
		Operator<T, any, any>,
		...Operator<any, any, any>[]
		]
		): Operator.Stateless<T, any>;
		): Operator.Stateless<T, any, any>;

		export function compose<T>(
		...ops: [
		Operator<T, any>,
		...Operator<any, any>[]
		Operator<T, any, any>,
		...Operator<any, any, any>[]
		]
		): Operator.Stateless<T, any> {
		): Operator.Stateless<T, any, any> \| Operator.Stateless<T, any, never> {

		@@ -175,3 +187,3 @@ if (ops.length === 1) {

		return Operator.fλ.Stateful.match<T, any>(op) ?
		return Operator.fλ.Stateful.match<T, any, any>(op) ?
		encapsulateOpState(op) :
		@@ -195,91 +207,1 @@ op
		}




		/*

		opCompose(
		(data: string)=> [ data.length ],
		data => [ `${data}` ]
		);

		opCompose(
		(data: string)=> true,
		(data)=> [ data.length ],
		);

		opCompose(
		(data: string)=> [ data.length ],
		(data)=> true,
		);
		opCompose(
		(data: string)=> true,
		data=> true,
		);

		opCompose(
		(data: string \| number): data is string => true,
		data=> [ data.length ]
		);

		opCompose(
		(data: string \| number \| Function ): data is (string \| Function) => true,
		(data): data is Function=> true
		);

		opCompose(
		(data: string \| number \| Function ): data is (string \| Function) => true,
		data => typeof data === "string" ? [ data ] : null
		);

		opCompose(
		(data: string \| number \| Function ): data is (string \| Function) => true,
		data => true
		);

		opCompose(
		(data: string \| number \| Function) => true,
		(data): data is (string \| Function) => true,
		);

		opCompose(
		(data: string) => [ data.length > 3 ? data.length : data ],
		(data): data is string => true,
		);


		opCompose(
		id<Operator<string,string>>((data: string) => true),
		id<Operator<string, number>>((data: string) => [data.length] as const)
		);



		opCompose(
		id<Operator<string, string>>(
		(data: string) => true
		),
		id<Operator.fλ<string, number>>(
		(data) => [data.length]
		),
		id<Operator.fλ<number, string>>(
		data => [`${data}`]
		)
		);

		opCompose(
		(data: string)=> [data],
		data => [data],
		data => [data]
		);

		opCompose(
		(data: string)=> [ data],
		data => [ data ],
		data => [ data ],
		data => [ data ],
		data => [ data ]
		);

		*/

8

src/lib/util/encapsulateOpState.ts

		import { id } from "../../tools/typeSafety/id";
		import { Operator } from "../types/Operator";

		export function encapsulateOpState<T, U>(
		statefulFλOp: Operator.fλ.Stateful<T, U>
		): Operator.fλ.Stateless<T, U> {
		export function encapsulateOpState<T, U, CtxOperator>(
		statefulFλOp: Operator.fλ.Stateful<T, U, CtxOperator>
		): Operator.fλ.Stateless<T, U, CtxOperator> {

		let state: U = statefulFλOp[1];

		return id<Operator.fλ.Stateless<T, U>>(
		return id<Operator.fλ.Stateless<T, U, CtxOperator>>(
		(...[data, , cbInvokedIfMatched]) => {
		@@ -12,0 +12,0 @@

33

src/lib/util/from.ts

		@@ -7,9 +7,10 @@
		import * as dom from "../types/lib.dom";
		type Ctx = import("../Ctx").Ctx;


		type OneOrMany<T> = T \| ArrayLike<T>;
		type EvtLike<T> = import("../Evt").EvtLike<T>;
		type CtxLike<Result> = import("../Ctx").CtxLike<Result> & {
		getEvtDone(): EvtLike<unknown> & { attachOnce(callback: ()=> void): void; };
		};

		function fromImpl<T>(
		ctx: Ctx \| undefined,
		ctx: CtxLike<any> \| undefined,
		target: OneOrMany<EventTargetLike<T>>,
		@@ -90,3 +91,3 @@ eventName?: string,
		export function from<K extends keyof dom.HTMLElementEventMap>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		target: EventTargetLike.HTMLElement,
		@@ -98,3 +99,3 @@ eventName: K,
		export function from <K extends keyof dom.WindowEventMap>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		target: EventTargetLike.Window,
		@@ -106,3 +107,3 @@ eventName: K,
		export function from<K extends keyof dom.DocumentEventMap>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		target: EventTargetLike.Document,
		@@ -114,3 +115,3 @@ eventName: K,
		export function from<T>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		target: OneOrMany<
		@@ -123,3 +124,3 @@ EventTargetLike.NodeStyleEventEmitter \|
		export function from<T>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		target: OneOrMany<
		@@ -132,3 +133,3 @@ EventTargetLike.HasEventTargetAddRemove<T>
		export function from<T>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		target: OneOrMany<EventTargetLike.RxJSSubject<T>>
		@@ -173,3 +174,3 @@ ): Evt<T>;
		export function from<T>(
		ctxOrTarget: Ctx \| OneOrMany<EventTargetLike<T>>,
		ctxOrTarget: CtxLike<any> \| OneOrMany<EventTargetLike<T>>,
		targetOrEventName?: OneOrMany<EventTargetLike<T>> \| string,
		@@ -183,5 +184,5 @@ eventNameOrOptions?: string \| EventTargetLike.HasEventTargetAddRemove.Options,
		assert(
		typeGuard.dry<OneOrMany<EventTargetLike<T>>>(targetOrEventName) &&
		typeGuard.dry<string \| undefined>(eventNameOrOptions) &&
		typeGuard.dry<EventTargetLike.HasEventTargetAddRemove.Options \| undefined>(options)
		typeGuard<OneOrMany<EventTargetLike<T>>>(targetOrEventName) &&
		typeGuard<string \| undefined>(eventNameOrOptions) &&
		typeGuard<EventTargetLike.HasEventTargetAddRemove.Options \| undefined>(options)
		);
		@@ -199,4 +200,4 @@
		assert(
		typeGuard.dry<string \| undefined>(targetOrEventName) &&
		typeGuard.dry<EventTargetLike.HasEventTargetAddRemove.Options \| undefined>(eventNameOrOptions)
		typeGuard<string \| undefined>(targetOrEventName) &&
		typeGuard<EventTargetLike.HasEventTargetAddRemove.Options \| undefined>(eventNameOrOptions)
		);
		@@ -203,0 +204,0 @@

2

src/lib/util/genericOperators/to.ts

		@@ -5,5 +5,5 @@ import { Operator } from "../../types/Operator";
		eventName: K
		): Operator.fλ.Stateless<T, Extract<T, [K, any]>[1]> =>
		): Operator.fλ.Stateless<T, Extract<T, [K, any]>[1], never> =>
		data => data[0] !== eventName ?
		null : [data[1]]
		;

11

src/lib/util/getCtxFactory.ts

		@@ -1,12 +0,9 @@
		import { Ctx } from "../Ctx";
		import { VoidCtx } from "../Ctx";
		import { Polyfill as WeakMap } from "minimal-polyfills/dist/lib/WeakMap";
		type VoidCtx = import("../Ctx").VoidCtx;

		export function getCtxFactory() {

		const ctxByObj = new WeakMap<object, Ctx>();
		const ctxByObj = new WeakMap<object, VoidCtx>();

		function getCtx(obj: object): VoidCtx;
		//function getCtx<T>(obj: object): Ctx<T>;
		function getCtx(obj: object): Ctx {
		function getCtx(obj: object): VoidCtx {

		@@ -17,3 +14,3 @@ let ctx = ctxByObj.get(obj);

		ctx = new Ctx();
		ctx = new VoidCtx();

		@@ -20,0 +17,0 @@ ctxByObj.set(obj, ctx);

2

src/lib/util/getLazyEvtFactory.ts

		import { Evt } from "../Evt";
		import { setPostCount } from "../EvtCore";
		import { setPostCount } from "../Evt";

		@@ -4,0 +4,0 @@ export function getLazyEvtFactory<T>(): { getEvt: () => Evt<T>; post: (data: T) => void; } {

10

src/lib/util/invokeOperator.ts

		@@ -5,7 +5,7 @@
		/** Invoke any type of stateless operator and return as if it was a fλ*/
		export function invokeOperator<T, U>(op: Operator.fλ.Stateless<T, U>, data: T, isPost?: true): Operator.fλ.Result<U>;
		export function invokeOperator<T, U extends T>(op: (data: T) => data is U, data: T): Operator.fλ.Result<U>;
		export function invokeOperator<T>(op: (data: T) => boolean, data: T): Operator.fλ.Result<T>;
		export function invokeOperator<T, U>(op: Operator.Stateless<T, U>, data: T, isPost?: true): Operator.fλ.Result<U>;
		export function invokeOperator<T>(op: Operator.Stateless<T, any>, data: T, isPost?: true): Operator.fλ.Result<any> {
		export function invokeOperator<T, U, CtxResult>(op: Operator.fλ.Stateless<T, U, CtxResult>, data: T, isPost?: true): Operator.fλ.Result<U, CtxResult>;
		export function invokeOperator<T, U extends T>(op: (data: T) => data is U, data: T): Operator.fλ.Result<U, never>;
		export function invokeOperator<T>(op: (data: T) => boolean, data: T): Operator.fλ.Result<T, never>;
		export function invokeOperator<T, U, CtxResult>(op: Operator.Stateless<T, U, CtxResult>, data: T, isPost?: true): Operator.fλ.Result<U, CtxResult>;
		export function invokeOperator<T>(op: Operator.Stateless<T, any, any>, data: T, isPost?: true): Operator.fλ.Result<any, any> \| Operator.fλ.Result<any, never> {

		@@ -12,0 +12,0 @@ const result = op(data, undefined, isPost);

36

src/lib/util/merge.ts

		@@ -6,6 +6,12 @@

		type Ctx = import("../Ctx").Ctx;
		type CtxLike<Result> = import("../Ctx").CtxLike<Result>;

		export function mergeImpl<EvtUnion extends NonPostable<Evt<any>>>(
		ctx: Ctx \| undefined,
		type EvtLike<T> = import("../Evt").EvtLike<T> & {
		attach<T>(callback: (data: T)=> void): void;
		attach<T>(ctx: CtxLike<any>, callback: (data: T)=> void): void;
		};

		//TODO: Fix interoperability between versions.
		export function mergeImpl<EvtUnion extends EvtLike<any>>(
		ctx: CtxLike<any> \| undefined,
		evts: readonly EvtUnion[]
		@@ -18,16 +24,14 @@ ): Evt<UnpackEvt<EvtUnion>> {

		evts
		.forEach(
		evt => {
		evts.forEach(
		evt => {

		if (ctx === undefined) {
		evt.attach(callback);
		} else {
		evt.attach(ctx, callback);
		}

		if (ctx === undefined) {
		evt.attach(callback);
		} else {
		evt.attach(ctx, callback);
		}
		)
		;

		}
		);

		return evtUnion;
		@@ -39,3 +43,3 @@
		export function merge<EvtUnion extends NonPostable<Evt<any>>>(
		ctx: Ctx,
		ctx: CtxLike<any>,
		evts: readonly EvtUnion[]
		@@ -47,3 +51,3 @@ ): Evt<UnpackEvt<EvtUnion>>;
		export function merge<EvtUnion extends NonPostable<Evt<any>>>(
		p1: Ctx \| readonly EvtUnion[],
		p1: CtxLike<any> \| readonly EvtUnion[],
		p2?: readonly EvtUnion[]
		@@ -50,0 +54,0 @@ ): Evt<UnpackEvt<EvtUnion>> {

8

src/lib/util/parseOverloadParams.ts

		@@ -7,10 +7,10 @@
		import { typeGuard } from "../../tools/typeSafety/typeGuard"
		type Ctx = import("../Ctx").Ctx;
		type CtxLike<Result> = import("../Ctx").CtxLike<Result>;

		function matchAll() { return true; }

		const canBeOperator = (p: undefined \| Ctx \| Operator<any, any>): boolean => {
		const canBeOperator = (p: undefined \| CtxLike<any> \| Operator<any, any, any>): boolean => {
		return (
		p !== undefined &&
		typeGuard.dry<Operator<any, any>>(p) &&
		typeGuard<Operator<any, any, any>>(p) &&
		(
		@@ -47,3 +47,3 @@ typeof p === "function" \|\|

		const getOpWrap = (ops: [Operator<T, any>, ...Operator<any, any>[]]) =>
		const getOpWrap = (ops: [Operator<T, any, any>, ...Operator<any, any, any>[]]) =>
		ops.length === 0 ?
		@@ -50,0 +50,0 @@ {}

4

src/tools/inDepthComparison/representsSameData.ts

		@@ -12,3 +12,3 @@ import { typeGuard } from "../typeSafety/typeGuard";
		return (
		typeGuard.dry<SetLike<T>>(set) &&
		typeGuard<SetLike<T>>(set) &&
		typeof set.values === "function" &&
		@@ -30,3 +30,3 @@ /Set/.test(Object.getPrototypeOf(set).constructor.name)
		return (
		typeGuard.dry<MapLike<T,U>>(map) &&
		typeGuard<MapLike<T,U>>(map) &&
		typeof map.keys === "function" &&
		@@ -33,0 +33,0 @@ typeof map.get === "function" &&

2

src/tools/reducers/partition.ts

		@@ -20,3 +20,3 @@
		//NOTE: Should be deduced by the compiler
		assert(typeGuard.dry<Exclude<ArrOf, U>>(currentValue));
		assert(typeGuard<Exclude<ArrOf, U>>(currentValue));

		@@ -23,0 +23,0 @@ previousValue[1].push(currentValue);

2

src/tools/typeSafety/matchVoid.ts

		@@ -21,3 +21,3 @@
		export function matchVoid(o: any): o is void {
		return typeGuard<void>(o, o => o === undefined \|\| o === null );
		return typeGuard<void>(o, o === undefined \|\| o === null );
		}

76

src/tools/typeSafety/typeGuard.ts

		@@ -1,31 +0,55 @@

		/** Invoke a test function as if it was a typeGuard for a given type */
		export function typeGuard<T>(o: any, matcher: (o: any) => boolean) {
		return matcher(o);
		/**
		* Use cases:
		*
		* 1) When we know the subtype of a variable but the compiler is unaware.
		*
		* declare const x: "FOO" \| "BAR";
		*
		* 1.1) If we want to tel the compile that we know x is of type "BAR"
		*
		* assert(typeGuard<"BAR">(x));
		* x; <== x is of type "BAR"
		*
		* 1.2) If we want to tell the compiler that x is NOT of type "BAR"
		*
		* assert(!typeGuard<"BAR">(x,false));
		* x; <== x is of type "FOO"
		*
		* 2) Tell the compiler what assertion can be made on a given variable
		* if a given test return true.
		*
		* type Circle = { type: "CIRCLE"; radius: number; };
		* type Square = { type: "SQUARE"; sideLength: number; };
		* type Shape = Circle \| Square;
		*
		* declare const shape: Shape;
		*
		* if( typeGuard<Circle>(shape, shape.type === "CIRCLE") ){
		* [ shape is Circle ]
		* }else{
		* [ shape is not Circle ]
		* }
		*
		*
		* export function matchVoid(o: any): o is void {
		* return typeGuard<void>(o, o === undefined \|\| o === null );
		* }
		*
		* 3) Helper for safely build other type guards
		*
		* export function match<T>(set: Object): set is SetLike<T> {
		* return (
		* typeGuard<SetLike<T>>(set) &&
		* typeof set.values === "function" &&
		* /Set/.test(Object.getPrototypeOf(set).constructor.name)
		* );
		* }
		*
		*/
		export function typeGuard<T>(o: any, isMatched: boolean = true): o is T {
		return isMatched;
		}

		export namespace typeGuard {

		/**
		* type guard that always returns true for a given type.
		*
		* Use case:
		* declare const x: "FOO" \| "BAR";
		* assert(typeGuard.dry<"BAR">(x));
		* x; <== x is of type "BAR"
		*
		* OR
		*
		* assert(!typeGuard.dry<"BAR">(x,false));
		* x; <== x is of type "FOO"
		*/
		export function dry<T>(o: any, isMatched: boolean = true): o is T {
		return typeGuard<T>(o, () => isMatched);
		}


		}

dist/lib/EvtCore.d.ts

dist/lib/EvtCore.js

dist/lib/EvtCore.js.map

dist/lib/types/helper/EvtLike.d.ts

dist/lib/types/helper/EvtLike.js

dist/lib/types/helper/EvtLike.js.map

dist/lib/VoidEvt.d.ts

dist/lib/VoidEvt.js

dist/lib/VoidEvt.js.map

src/lib/EvtCore.ts

src/lib/types/helper/EvtLike.ts

src/lib/VoidEvt.ts

dist/lib/Ctx.js.map