sygnal 4.5.0 → 4.6.0

package/dist/astro/client.cjs.js

@@ -1,8 +1,5 @@
 'use strict';
 
-var xs$1 = require('xstream');
-var dropRepeats$2 = require('xstream/extra/dropRepeats');
-var concat$1 = require('xstream/extra/concat');
 var h = require('snabbdom/build/h');
 var init = require('snabbdom/build/init');
 var tovnode = require('snabbdom/build/tovnode');
@@ -12,35 +9,2601 @@ var _class = require('snabbdom/build/modules/class');
 var props = require('snabbdom/build/modules/props');
 var attributes = require('snabbdom/build/modules/attributes');
 var dataset = require('snabbdom/build/modules/dataset');
-var sampleCombine = require('xstream/extra/sampleCombine');
-var delayModule = require('xstream/extra/delay.js');
-var concatModule = require('xstream/extra/concat.js');
-var debounceModule = require('xstream/extra/debounce.js');
-var dropRepeatsModule = require('xstream/extra/dropRepeats.js');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var xstream = {};
+
+var ponyfill$1 = {};
+
+(function (exports) {
+
+	Object.defineProperty(exports, "__esModule", {
+		value: true
+	});
+	exports['default'] = symbolObservablePonyfill;
+	function symbolObservablePonyfill(root) {
+		var result;
+		var _Symbol = root.Symbol;
+
+		if (typeof _Symbol === 'function') {
+			if (_Symbol.observable) {
+				result = _Symbol.observable;
+			} else {
+
+				// This just needs to be something that won't trample other user's Symbol.for use
+				// It also will guide people to the source of their issues, if this is problematic.
+				// META: It's a resource locator!
+				result = _Symbol['for']('https://github.com/benlesh/symbol-observable');
+				try {
+					_Symbol.observable = result;
+				} catch (err) {
+					// Do nothing. In some environments, users have frozen `Symbol` for security reasons,
+					// if it is frozen assigning to it will throw. In this case, we don't care, because
+					// they will need to use the returned value from the ponyfill.
+				}
+			}
+		} else {
+			result = '@@observable';
+		}
+
+		return result;
+	}} (ponyfill$1));
+
+var ponyfill = ponyfill$1;
+
+var toStr$2 = Object.prototype.toString;
+
+var isArguments = function isArguments(value) {
+	var str = toStr$2.call(value);
+	var isArgs = str === '[object Arguments]';
+	if (!isArgs) {
+		isArgs = str !== '[object Array]' &&
+			value !== null &&
+			typeof value === 'object' &&
+			typeof value.length === 'number' &&
+			value.length >= 0 &&
+			toStr$2.call(value.callee) === '[object Function]';
+	}
+	return isArgs;
+};
+
+var implementation$5;
+var hasRequiredImplementation;
+
+function requireImplementation () {
+	if (hasRequiredImplementation) return implementation$5;
+	hasRequiredImplementation = 1;
+
+	var keysShim;
+	if (!Object.keys) {
+		// modified from https://github.com/es-shims/es5-shim
+		var has = Object.prototype.hasOwnProperty;
+		var toStr = Object.prototype.toString;
+		var isArgs = isArguments; // eslint-disable-line global-require
+		var isEnumerable = Object.prototype.propertyIsEnumerable;
+		var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
+		var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
+		var dontEnums = [
+			'toString',
+			'toLocaleString',
+			'valueOf',
+			'hasOwnProperty',
+			'isPrototypeOf',
+			'propertyIsEnumerable',
+			'constructor'
+		];
+		var equalsConstructorPrototype = function (o) {
+			var ctor = o.constructor;
+			return ctor && ctor.prototype === o;
+		};
+		var excludedKeys = {
+			$applicationCache: true,
+			$console: true,
+			$external: true,
+			$frame: true,
+			$frameElement: true,
+			$frames: true,
+			$innerHeight: true,
+			$innerWidth: true,
+			$onmozfullscreenchange: true,
+			$onmozfullscreenerror: true,
+			$outerHeight: true,
+			$outerWidth: true,
+			$pageXOffset: true,
+			$pageYOffset: true,
+			$parent: true,
+			$scrollLeft: true,
+			$scrollTop: true,
+			$scrollX: true,
+			$scrollY: true,
+			$self: true,
+			$webkitIndexedDB: true,
+			$webkitStorageInfo: true,
+			$window: true
+		};
+		var hasAutomationEqualityBug = (function () {
+			/* global window */
+			if (typeof window === 'undefined') { return false; }
+			for (var k in window) {
+				try {
+					if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
+						try {
+							equalsConstructorPrototype(window[k]);
+						} catch (e) {
+							return true;
+						}
+					}
+				} catch (e) {
+					return true;
+				}
+			}
+			return false;
+		}());
+		var equalsConstructorPrototypeIfNotBuggy = function (o) {
+			/* global window */
+			if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
+				return equalsConstructorPrototype(o);
+			}
+			try {
+				return equalsConstructorPrototype(o);
+			} catch (e) {
+				return false;
+			}
+		};
+
+		keysShim = function keys(object) {
+			var isObject = object !== null && typeof object === 'object';
+			var isFunction = toStr.call(object) === '[object Function]';
+			var isArguments = isArgs(object);
+			var isString = isObject && toStr.call(object) === '[object String]';
+			var theKeys = [];
+
+			if (!isObject && !isFunction && !isArguments) {
+				throw new TypeError('Object.keys called on a non-object');
+			}
+
+			var skipProto = hasProtoEnumBug && isFunction;
+			if (isString && object.length > 0 && !has.call(object, 0)) {
+				for (var i = 0; i < object.length; ++i) {
+					theKeys.push(String(i));
+				}
+			}
+
+			if (isArguments && object.length > 0) {
+				for (var j = 0; j < object.length; ++j) {
+					theKeys.push(String(j));
+				}
+			} else {
+				for (var name in object) {
+					if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+						theKeys.push(String(name));
+					}
+				}
+			}
+
+			if (hasDontEnumBug) {
+				var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+
+				for (var k = 0; k < dontEnums.length; ++k) {
+					if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
+						theKeys.push(dontEnums[k]);
+					}
+				}
+			}
+			return theKeys;
+		};
+	}
+	implementation$5 = keysShim;
+	return implementation$5;
+}
+
+var slice$1 = Array.prototype.slice;
+var isArgs = isArguments;
+
+var origKeys = Object.keys;
+var keysShim = origKeys ? function keys(o) { return origKeys(o); } : requireImplementation();
+
+var originalKeys = Object.keys;
+
+keysShim.shim = function shimObjectKeys() {
+	if (Object.keys) {
+		var keysWorksWithArguments = (function () {
+			// Safari 5.0 bug
+			var args = Object.keys(arguments);
+			return args && args.length === arguments.length;
+		}(1, 2));
+		if (!keysWorksWithArguments) {
+			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
+				if (isArgs(object)) {
+					return originalKeys(slice$1.call(object));
+				}
+				return originalKeys(object);
+			};
+		}
+	} else {
+		Object.keys = keysShim;
+	}
+	return Object.keys || keysShim;
+};
+
+var objectKeys = keysShim;
+
+/* eslint complexity: [2, 18], max-statements: [2, 33] */
+var shams = function hasSymbols() {
+	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+	if (typeof Symbol.iterator === 'symbol') { return true; }
+
+	var obj = {};
+	var sym = Symbol('test');
+	var symObj = Object(sym);
+	if (typeof sym === 'string') { return false; }
+
+	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+	// temp disabled per https://github.com/ljharb/object.assign/issues/17
+	// if (sym instanceof Symbol) { return false; }
+	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+	// if (!(symObj instanceof Symbol)) { return false; }
+
+	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+	var symVal = 42;
+	obj[sym] = symVal;
+	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
+
+	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
+
+	var syms = Object.getOwnPropertySymbols(obj);
+	if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+	if (typeof Object.getOwnPropertyDescriptor === 'function') {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+	}
+
+	return true;
+};
+
+var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+var hasSymbolSham = shams;
+
+var hasSymbols$2 = function hasNativeSymbols() {
+	if (typeof origSymbol !== 'function') { return false; }
+	if (typeof Symbol !== 'function') { return false; }
+	if (typeof origSymbol('foo') !== 'symbol') { return false; }
+	if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+	return hasSymbolSham();
+};
+
+var test = {
+	foo: {}
+};
+
+var $Object = Object;
+
+var hasProto$1 = function hasProto() {
+	return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
+};
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var slice = Array.prototype.slice;
+var toStr$1 = Object.prototype.toString;
+var funcType = '[object Function]';
+
+var implementation$4 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr$1.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slice.call(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                args.concat(slice.call(arguments))
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        } else {
+            return target.apply(
+                that,
+                args.concat(slice.call(arguments))
+            );
+        }
+    };
+
+    var boundLength = Math.max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs.push('$' + i);
+    }
+
+    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};
+
+var implementation$3 = implementation$4;
+
+var functionBind = Function.prototype.bind || implementation$3;
+
+var bind$1 = functionBind;
+
+var src = bind$1.call(Function.call, Object.prototype.hasOwnProperty);
+
+var undefined$1;
+
+var $SyntaxError = SyntaxError;
+var $Function = Function;
+var $TypeError = TypeError;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+	try {
+		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+	} catch (e) {}
+};
+
+var $gOPD = Object.getOwnPropertyDescriptor;
+if ($gOPD) {
+	try {
+		$gOPD({}, '');
+	} catch (e) {
+		$gOPD = null; // this is IE 8, which has a broken gOPD
+	}
+}
+
+var throwTypeError = function () {
+	throw new $TypeError();
+};
+var ThrowTypeError = $gOPD
+	? (function () {
+		try {
+			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+			arguments.callee; // IE 8 does not throw here
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}())
+	: throwTypeError;
+
+var hasSymbols$1 = hasSymbols$2();
+var hasProto = hasProto$1();
+
+var getProto = Object.getPrototypeOf || (
+	hasProto
+		? function (x) { return x.__proto__; } // eslint-disable-line no-proto
+		: null
+);
+
+var needsEval = {};
+
+var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined$1 : getProto(Uint8Array);
+
+var INTRINSICS = {
+	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
+	'%Array%': Array,
+	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+	'%ArrayIteratorPrototype%': hasSymbols$1 && getProto ? getProto([][Symbol.iterator]()) : undefined$1,
+	'%AsyncFromSyncIteratorPrototype%': undefined$1,
+	'%AsyncFunction%': needsEval,
+	'%AsyncGenerator%': needsEval,
+	'%AsyncGeneratorFunction%': needsEval,
+	'%AsyncIteratorPrototype%': needsEval,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+	'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
+	'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
+	'%Boolean%': Boolean,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%Date%': Date,
+	'%decodeURI%': decodeURI,
+	'%decodeURIComponent%': decodeURIComponent,
+	'%encodeURI%': encodeURI,
+	'%encodeURIComponent%': encodeURIComponent,
+	'%Error%': Error,
+	'%eval%': eval, // eslint-disable-line no-eval
+	'%EvalError%': EvalError,
+	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols$1 && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$1 || !getProto ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+	'%Math%': Math,
+	'%Number%': Number,
+	'%Object%': Object,
+	'%parseFloat%': parseFloat,
+	'%parseInt%': parseInt,
+	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+	'%RangeError%': RangeError,
+	'%ReferenceError%': ReferenceError,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+	'%RegExp%': RegExp,
+	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$1 || !getProto ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols$1 && getProto ? getProto(''[Symbol.iterator]()) : undefined$1,
+	'%Symbol%': hasSymbols$1 ? Symbol : undefined$1,
+	'%SyntaxError%': $SyntaxError,
+	'%ThrowTypeError%': ThrowTypeError,
+	'%TypedArray%': TypedArray,
+	'%TypeError%': $TypeError,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%URIError%': URIError,
+	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
+	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
+};
+
+if (getProto) {
+	try {
+		null.error; // eslint-disable-line no-unused-expressions
+	} catch (e) {
+		// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+		var errorProto = getProto(getProto(e));
+		INTRINSICS['%Error.prototype%'] = errorProto;
+	}
+}
+
+var doEval = function doEval(name) {
+	var value;
+	if (name === '%AsyncFunction%') {
+		value = getEvalledConstructor('async function () {}');
+	} else if (name === '%GeneratorFunction%') {
+		value = getEvalledConstructor('function* () {}');
+	} else if (name === '%AsyncGeneratorFunction%') {
+		value = getEvalledConstructor('async function* () {}');
+	} else if (name === '%AsyncGenerator%') {
+		var fn = doEval('%AsyncGeneratorFunction%');
+		if (fn) {
+			value = fn.prototype;
+		}
+	} else if (name === '%AsyncIteratorPrototype%') {
+		var gen = doEval('%AsyncGenerator%');
+		if (gen && getProto) {
+			value = getProto(gen.prototype);
+		}
+	}
+
+	INTRINSICS[name] = value;
+
+	return value;
+};
+
+var LEGACY_ALIASES = {
+	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+	'%ArrayPrototype%': ['Array', 'prototype'],
+	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
+	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+	'%BooleanPrototype%': ['Boolean', 'prototype'],
+	'%DataViewPrototype%': ['DataView', 'prototype'],
+	'%DatePrototype%': ['Date', 'prototype'],
+	'%ErrorPrototype%': ['Error', 'prototype'],
+	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
+	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+	'%FunctionPrototype%': ['Function', 'prototype'],
+	'%Generator%': ['GeneratorFunction', 'prototype'],
+	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+	'%JSONParse%': ['JSON', 'parse'],
+	'%JSONStringify%': ['JSON', 'stringify'],
+	'%MapPrototype%': ['Map', 'prototype'],
+	'%NumberPrototype%': ['Number', 'prototype'],
+	'%ObjectPrototype%': ['Object', 'prototype'],
+	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+	'%PromisePrototype%': ['Promise', 'prototype'],
+	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+	'%Promise_all%': ['Promise', 'all'],
+	'%Promise_reject%': ['Promise', 'reject'],
+	'%Promise_resolve%': ['Promise', 'resolve'],
+	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
+	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+	'%RegExpPrototype%': ['RegExp', 'prototype'],
+	'%SetPrototype%': ['Set', 'prototype'],
+	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+	'%StringPrototype%': ['String', 'prototype'],
+	'%SymbolPrototype%': ['Symbol', 'prototype'],
+	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
+	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+	'%URIErrorPrototype%': ['URIError', 'prototype'],
+	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
+	'%WeakSetPrototype%': ['WeakSet', 'prototype']
+};
+
+var bind = functionBind;
+var hasOwn = src;
+var $concat = bind.call(Function.call, Array.prototype.concat);
+var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+var $replace = bind.call(Function.call, String.prototype.replace);
+var $strSlice = bind.call(Function.call, String.prototype.slice);
+var $exec = bind.call(Function.call, RegExp.prototype.exec);
+
+/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+var stringToPath = function stringToPath(string) {
+	var first = $strSlice(string, 0, 1);
+	var last = $strSlice(string, -1);
+	if (first === '%' && last !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
+	} else if (last === '%' && first !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
+	}
+	var result = [];
+	$replace(string, rePropName, function (match, number, quote, subString) {
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+	});
+	return result;
+};
+/* end adaptation */
+
+var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+	var intrinsicName = name;
+	var alias;
+	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+		alias = LEGACY_ALIASES[intrinsicName];
+		intrinsicName = '%' + alias[0] + '%';
+	}
+
+	if (hasOwn(INTRINSICS, intrinsicName)) {
+		var value = INTRINSICS[intrinsicName];
+		if (value === needsEval) {
+			value = doEval(intrinsicName);
+		}
+		if (typeof value === 'undefined' && !allowMissing) {
+			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		}
+
+		return {
+			alias: alias,
+			name: intrinsicName,
+			value: value
+		};
+	}
+
+	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
+};
+
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new $TypeError('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+		throw new $TypeError('"allowMissing" argument must be a boolean');
+	}
+
+	if ($exec(/^%?[^%]*%?$/, name) === null) {
+		throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+	}
+	var parts = stringToPath(name);
+	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
+
+	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
+	var intrinsicRealName = intrinsic.name;
+	var value = intrinsic.value;
+	var skipFurtherCaching = false;
+
+	var alias = intrinsic.alias;
+	if (alias) {
+		intrinsicBaseName = alias[0];
+		$spliceApply(parts, $concat([0, 1], alias));
+	}
+
+	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+		var part = parts[i];
+		var first = $strSlice(part, 0, 1);
+		var last = $strSlice(part, -1);
+		if (
+			(
+				(first === '"' || first === "'" || first === '`')
+				|| (last === '"' || last === "'" || last === '`')
+			)
+			&& first !== last
+		) {
+			throw new $SyntaxError('property names with quotes must have matching quotes');
+		}
+		if (part === 'constructor' || !isOwn) {
+			skipFurtherCaching = true;
+		}
+
+		intrinsicBaseName += '.' + part;
+		intrinsicRealName = '%' + intrinsicBaseName + '%';
+
+		if (hasOwn(INTRINSICS, intrinsicRealName)) {
+			value = INTRINSICS[intrinsicRealName];
+		} else if (value != null) {
+			if (!(part in value)) {
+				if (!allowMissing) {
+					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				return void undefined$1;
+			}
+			if ($gOPD && (i + 1) >= parts.length) {
+				var desc = $gOPD(value, part);
+				isOwn = !!desc;
+
+				// By convention, when a data property is converted to an accessor
+				// property to emulate a data property that does not suffer from
+				// the override mistake, that accessor's getter is marked with
+				// an `originalValue` property. Here, when we detect this, we
+				// uphold the illusion by pretending to see that original data
+				// property, i.e., returning the value rather than the getter
+				// itself.
+				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+					value = desc.get;
+				} else {
+					value = value[part];
+				}
+			} else {
+				isOwn = hasOwn(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+	}
+	return value;
+};
+
+var GetIntrinsic = getIntrinsic;
+
+var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+
+var hasPropertyDescriptors$1 = function hasPropertyDescriptors() {
+	if ($defineProperty) {
+		try {
+			$defineProperty({}, 'a', { value: 1 });
+			return true;
+		} catch (e) {
+			// IE 8 has a broken defineProperty
+			return false;
+		}
+	}
+	return false;
+};
+
+hasPropertyDescriptors$1.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+	// node v0.6 has a bug where array lengths can be Set but not Defined
+	if (!hasPropertyDescriptors$1()) {
+		return null;
+	}
+	try {
+		return $defineProperty([], 'length', { value: 1 }).length !== 1;
+	} catch (e) {
+		// In Firefox 4-22, defining length on an array throws an exception.
+		return true;
+	}
+};
+
+var hasPropertyDescriptors_1 = hasPropertyDescriptors$1;
+
+var keys = objectKeys;
+var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+
+var toStr = Object.prototype.toString;
+var concat$3 = Array.prototype.concat;
+var origDefineProperty = Object.defineProperty;
+
+var isFunction = function (fn) {
+	return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
+};
+
+var hasPropertyDescriptors = hasPropertyDescriptors_1();
+
+var supportsDescriptors = origDefineProperty && hasPropertyDescriptors;
+
+var defineProperty = function (object, name, value, predicate) {
+	if (name in object) {
+		if (predicate === true) {
+			if (object[name] === value) {
+				return;
+			}
+		} else if (!isFunction(predicate) || !predicate()) {
+			return;
+		}
+	}
+	if (supportsDescriptors) {
+		origDefineProperty(object, name, {
+			configurable: true,
+			enumerable: false,
+			value: value,
+			writable: true
+		});
+	} else {
+		object[name] = value; // eslint-disable-line no-param-reassign
+	}
+};
+
+var defineProperties$1 = function (object, map) {
+	var predicates = arguments.length > 2 ? arguments[2] : {};
+	var props = keys(map);
+	if (hasSymbols) {
+		props = concat$3.call(props, Object.getOwnPropertySymbols(map));
+	}
+	for (var i = 0; i < props.length; i += 1) {
+		defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+	}
+};
+
+defineProperties$1.supportsDescriptors = !!supportsDescriptors;
+
+var defineProperties_1 = defineProperties$1;
+
+var implementation$2 = commonjsGlobal;
+
+var implementation$1 = implementation$2;
+
+var polyfill$1 = function getPolyfill() {
+	if (typeof commonjsGlobal !== 'object' || !commonjsGlobal || commonjsGlobal.Math !== Math || commonjsGlobal.Array !== Array) {
+		return implementation$1;
+	}
+	return commonjsGlobal;
+};
+
+var define = defineProperties_1;
+var getPolyfill$1 = polyfill$1;
+
+var shim$1 = function shimGlobal() {
+	var polyfill = getPolyfill$1();
+	if (define.supportsDescriptors) {
+		var descriptor = Object.getOwnPropertyDescriptor(polyfill, 'globalThis');
+		if (!descriptor || (descriptor.configurable && (descriptor.enumerable || !descriptor.writable || globalThis !== polyfill))) { // eslint-disable-line max-len
+			Object.defineProperty(polyfill, 'globalThis', {
+				configurable: true,
+				enumerable: false,
+				value: polyfill,
+				writable: true
+			});
+		}
+	} else if (typeof globalThis !== 'object' || globalThis !== polyfill) {
+		polyfill.globalThis = polyfill;
+	}
+	return polyfill;
+};
+
+var defineProperties = defineProperties_1;
+
+var implementation = implementation$2;
+var getPolyfill = polyfill$1;
+var shim = shim$1;
+
+var polyfill = getPolyfill();
+
+var getGlobal$1 = function () { return polyfill; };
+
+defineProperties(getGlobal$1, {
+	getPolyfill: getPolyfill,
+	implementation: implementation,
+	shim: shim
+});
+
+var globalthis = getGlobal$1;
+
+var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(xstream, "__esModule", { value: true });
+var NO_IL_1 = xstream.NO_IL = NO_1 = xstream.NO = MemoryStream_1 = xstream.MemoryStream = Stream_1 = xstream.Stream = void 0;
+var ponyfill_1 = ponyfill;
+var globalthis_1 = globalthis;
+var $$observable = ponyfill_1.default(globalthis_1.getPolyfill());
+var NO$1 = {};
+var NO_1 = xstream.NO = NO$1;
+function noop() { }
+function cp(a) {
+    var l = a.length;
+    var b = Array(l);
+    for (var i = 0; i < l; ++i)
+        b[i] = a[i];
+    return b;
+}
+function and(f1, f2) {
+    return function andFn(t) {
+        return f1(t) && f2(t);
+    };
+}
+function _try(c, t, u) {
+    try {
+        return c.f(t);
+    }
+    catch (e) {
+        u._e(e);
+        return NO$1;
+    }
+}
+var NO_IL = {
+    _n: noop,
+    _e: noop,
+    _c: noop,
+};
+NO_IL_1 = xstream.NO_IL = NO_IL;
+// mutates the input
+function internalizeProducer(producer) {
+    producer._start = function _start(il) {
+        il.next = il._n;
+        il.error = il._e;
+        il.complete = il._c;
+        this.start(il);
+    };
+    producer._stop = producer.stop;
+}
+var StreamSub = /** @class */ (function () {
+    function StreamSub(_stream, _listener) {
+        this._stream = _stream;
+        this._listener = _listener;
+    }
+    StreamSub.prototype.unsubscribe = function () {
+        this._stream._remove(this._listener);
+    };
+    return StreamSub;
+}());
+var Observer = /** @class */ (function () {
+    function Observer(_listener) {
+        this._listener = _listener;
+    }
+    Observer.prototype.next = function (value) {
+        this._listener._n(value);
+    };
+    Observer.prototype.error = function (err) {
+        this._listener._e(err);
+    };
+    Observer.prototype.complete = function () {
+        this._listener._c();
+    };
+    return Observer;
+}());
+var FromObservable = /** @class */ (function () {
+    function FromObservable(observable) {
+        this.type = 'fromObservable';
+        this.ins = observable;
+        this.active = false;
+    }
+    FromObservable.prototype._start = function (out) {
+        this.out = out;
+        this.active = true;
+        this._sub = this.ins.subscribe(new Observer(out));
+        if (!this.active)
+            this._sub.unsubscribe();
+    };
+    FromObservable.prototype._stop = function () {
+        if (this._sub)
+            this._sub.unsubscribe();
+        this.active = false;
+    };
+    return FromObservable;
+}());
+var Merge = /** @class */ (function () {
+    function Merge(insArr) {
+        this.type = 'merge';
+        this.insArr = insArr;
+        this.out = NO$1;
+        this.ac = 0;
+    }
+    Merge.prototype._start = function (out) {
+        this.out = out;
+        var s = this.insArr;
+        var L = s.length;
+        this.ac = L;
+        for (var i = 0; i < L; i++)
+            s[i]._add(this);
+    };
+    Merge.prototype._stop = function () {
+        var s = this.insArr;
+        var L = s.length;
+        for (var i = 0; i < L; i++)
+            s[i]._remove(this);
+        this.out = NO$1;
+    };
+    Merge.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._n(t);
+    };
+    Merge.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Merge.prototype._c = function () {
+        if (--this.ac <= 0) {
+            var u = this.out;
+            if (u === NO$1)
+                return;
+            u._c();
+        }
+    };
+    return Merge;
+}());
+var CombineListener = /** @class */ (function () {
+    function CombineListener(i, out, p) {
+        this.i = i;
+        this.out = out;
+        this.p = p;
+        p.ils.push(this);
+    }
+    CombineListener.prototype._n = function (t) {
+        var p = this.p, out = this.out;
+        if (out === NO$1)
+            return;
+        if (p.up(t, this.i)) {
+            var b = cp(p.vals);
+            out._n(b);
+        }
+    };
+    CombineListener.prototype._e = function (err) {
+        var out = this.out;
+        if (out === NO$1)
+            return;
+        out._e(err);
+    };
+    CombineListener.prototype._c = function () {
+        var p = this.p;
+        if (p.out === NO$1)
+            return;
+        if (--p.Nc === 0)
+            p.out._c();
+    };
+    return CombineListener;
+}());
+var Combine = /** @class */ (function () {
+    function Combine(insArr) {
+        this.type = 'combine';
+        this.insArr = insArr;
+        this.out = NO$1;
+        this.ils = [];
+        this.Nc = this.Nn = 0;
+        this.vals = [];
+    }
+    Combine.prototype.up = function (t, i) {
+        var v = this.vals[i];
+        var Nn = !this.Nn ? 0 : v === NO$1 ? --this.Nn : this.Nn;
+        this.vals[i] = t;
+        return Nn === 0;
+    };
+    Combine.prototype._start = function (out) {
+        this.out = out;
+        var s = this.insArr;
+        var n = this.Nc = this.Nn = s.length;
+        var vals = this.vals = new Array(n);
+        if (n === 0) {
+            out._n([]);
+            out._c();
+        }
+        else {
+            for (var i = 0; i < n; i++) {
+                vals[i] = NO$1;
+                s[i]._add(new CombineListener(i, out, this));
+            }
+        }
+    };
+    Combine.prototype._stop = function () {
+        var s = this.insArr;
+        var n = s.length;
+        var ils = this.ils;
+        for (var i = 0; i < n; i++)
+            s[i]._remove(ils[i]);
+        this.out = NO$1;
+        this.ils = [];
+        this.vals = [];
+    };
+    return Combine;
+}());
+var FromArray = /** @class */ (function () {
+    function FromArray(a) {
+        this.type = 'fromArray';
+        this.a = a;
+    }
+    FromArray.prototype._start = function (out) {
+        var a = this.a;
+        for (var i = 0, n = a.length; i < n; i++)
+            out._n(a[i]);
+        out._c();
+    };
+    FromArray.prototype._stop = function () {
+    };
+    return FromArray;
+}());
+var FromPromise = /** @class */ (function () {
+    function FromPromise(p) {
+        this.type = 'fromPromise';
+        this.on = false;
+        this.p = p;
+    }
+    FromPromise.prototype._start = function (out) {
+        var prod = this;
+        this.on = true;
+        this.p.then(function (v) {
+            if (prod.on) {
+                out._n(v);
+                out._c();
+            }
+        }, function (e) {
+            out._e(e);
+        }).then(noop, function (err) {
+            setTimeout(function () { throw err; });
+        });
+    };
+    FromPromise.prototype._stop = function () {
+        this.on = false;
+    };
+    return FromPromise;
+}());
+var Periodic = /** @class */ (function () {
+    function Periodic(period) {
+        this.type = 'periodic';
+        this.period = period;
+        this.intervalID = -1;
+        this.i = 0;
+    }
+    Periodic.prototype._start = function (out) {
+        var self = this;
+        function intervalHandler() { out._n(self.i++); }
+        this.intervalID = setInterval(intervalHandler, this.period);
+    };
+    Periodic.prototype._stop = function () {
+        if (this.intervalID !== -1)
+            clearInterval(this.intervalID);
+        this.intervalID = -1;
+        this.i = 0;
+    };
+    return Periodic;
+}());
+var Debug = /** @class */ (function () {
+    function Debug(ins, arg) {
+        this.type = 'debug';
+        this.ins = ins;
+        this.out = NO$1;
+        this.s = noop;
+        this.l = '';
+        if (typeof arg === 'string')
+            this.l = arg;
+        else if (typeof arg === 'function')
+            this.s = arg;
+    }
+    Debug.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    Debug.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+    };
+    Debug.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        var s = this.s, l = this.l;
+        if (s !== noop) {
+            try {
+                s(t);
+            }
+            catch (e) {
+                u._e(e);
+            }
+        }
+        else if (l)
+            console.log(l + ':', t);
+        else
+            console.log(t);
+        u._n(t);
+    };
+    Debug.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Debug.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return Debug;
+}());
+var Drop = /** @class */ (function () {
+    function Drop(max, ins) {
+        this.type = 'drop';
+        this.ins = ins;
+        this.out = NO$1;
+        this.max = max;
+        this.dropped = 0;
+    }
+    Drop.prototype._start = function (out) {
+        this.out = out;
+        this.dropped = 0;
+        this.ins._add(this);
+    };
+    Drop.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+    };
+    Drop.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        if (this.dropped++ >= this.max)
+            u._n(t);
+    };
+    Drop.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Drop.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return Drop;
+}());
+var EndWhenListener = /** @class */ (function () {
+    function EndWhenListener(out, op) {
+        this.out = out;
+        this.op = op;
+    }
+    EndWhenListener.prototype._n = function () {
+        this.op.end();
+    };
+    EndWhenListener.prototype._e = function (err) {
+        this.out._e(err);
+    };
+    EndWhenListener.prototype._c = function () {
+        this.op.end();
+    };
+    return EndWhenListener;
+}());
+var EndWhen = /** @class */ (function () {
+    function EndWhen(o, ins) {
+        this.type = 'endWhen';
+        this.ins = ins;
+        this.out = NO$1;
+        this.o = o;
+        this.oil = NO_IL;
+    }
+    EndWhen.prototype._start = function (out) {
+        this.out = out;
+        this.o._add(this.oil = new EndWhenListener(out, this));
+        this.ins._add(this);
+    };
+    EndWhen.prototype._stop = function () {
+        this.ins._remove(this);
+        this.o._remove(this.oil);
+        this.out = NO$1;
+        this.oil = NO_IL;
+    };
+    EndWhen.prototype.end = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    EndWhen.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._n(t);
+    };
+    EndWhen.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    EndWhen.prototype._c = function () {
+        this.end();
+    };
+    return EndWhen;
+}());
+var Filter = /** @class */ (function () {
+    function Filter(passes, ins) {
+        this.type = 'filter';
+        this.ins = ins;
+        this.out = NO$1;
+        this.f = passes;
+    }
+    Filter.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    Filter.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+    };
+    Filter.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        var r = _try(this, t, u);
+        if (r === NO$1 || !r)
+            return;
+        u._n(t);
+    };
+    Filter.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Filter.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return Filter;
+}());
+var FlattenListener = /** @class */ (function () {
+    function FlattenListener(out, op) {
+        this.out = out;
+        this.op = op;
+    }
+    FlattenListener.prototype._n = function (t) {
+        this.out._n(t);
+    };
+    FlattenListener.prototype._e = function (err) {
+        this.out._e(err);
+    };
+    FlattenListener.prototype._c = function () {
+        this.op.inner = NO$1;
+        this.op.less();
+    };
+    return FlattenListener;
+}());
+var Flatten = /** @class */ (function () {
+    function Flatten(ins) {
+        this.type = 'flatten';
+        this.ins = ins;
+        this.out = NO$1;
+        this.open = true;
+        this.inner = NO$1;
+        this.il = NO_IL;
+    }
+    Flatten.prototype._start = function (out) {
+        this.out = out;
+        this.open = true;
+        this.inner = NO$1;
+        this.il = NO_IL;
+        this.ins._add(this);
+    };
+    Flatten.prototype._stop = function () {
+        this.ins._remove(this);
+        if (this.inner !== NO$1)
+            this.inner._remove(this.il);
+        this.out = NO$1;
+        this.open = true;
+        this.inner = NO$1;
+        this.il = NO_IL;
+    };
+    Flatten.prototype.less = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        if (!this.open && this.inner === NO$1)
+            u._c();
+    };
+    Flatten.prototype._n = function (s) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        var _a = this, inner = _a.inner, il = _a.il;
+        if (inner !== NO$1 && il !== NO_IL)
+            inner._remove(il);
+        (this.inner = s)._add(this.il = new FlattenListener(u, this));
+    };
+    Flatten.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Flatten.prototype._c = function () {
+        this.open = false;
+        this.less();
+    };
+    return Flatten;
+}());
+var Fold = /** @class */ (function () {
+    function Fold(f, seed, ins) {
+        var _this = this;
+        this.type = 'fold';
+        this.ins = ins;
+        this.out = NO$1;
+        this.f = function (t) { return f(_this.acc, t); };
+        this.acc = this.seed = seed;
+    }
+    Fold.prototype._start = function (out) {
+        this.out = out;
+        this.acc = this.seed;
+        out._n(this.acc);
+        this.ins._add(this);
+    };
+    Fold.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+        this.acc = this.seed;
+    };
+    Fold.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        var r = _try(this, t, u);
+        if (r === NO$1)
+            return;
+        u._n(this.acc = r);
+    };
+    Fold.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Fold.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return Fold;
+}());
+var Last = /** @class */ (function () {
+    function Last(ins) {
+        this.type = 'last';
+        this.ins = ins;
+        this.out = NO$1;
+        this.has = false;
+        this.val = NO$1;
+    }
+    Last.prototype._start = function (out) {
+        this.out = out;
+        this.has = false;
+        this.ins._add(this);
+    };
+    Last.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+        this.val = NO$1;
+    };
+    Last.prototype._n = function (t) {
+        this.has = true;
+        this.val = t;
+    };
+    Last.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Last.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        if (this.has) {
+            u._n(this.val);
+            u._c();
+        }
+        else
+            u._e(new Error('last() failed because input stream completed'));
+    };
+    return Last;
+}());
+var MapOp = /** @class */ (function () {
+    function MapOp(project, ins) {
+        this.type = 'map';
+        this.ins = ins;
+        this.out = NO$1;
+        this.f = project;
+    }
+    MapOp.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    MapOp.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+    };
+    MapOp.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        var r = _try(this, t, u);
+        if (r === NO$1)
+            return;
+        u._n(r);
+    };
+    MapOp.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    MapOp.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return MapOp;
+}());
+var Remember = /** @class */ (function () {
+    function Remember(ins) {
+        this.type = 'remember';
+        this.ins = ins;
+        this.out = NO$1;
+    }
+    Remember.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(out);
+    };
+    Remember.prototype._stop = function () {
+        this.ins._remove(this.out);
+        this.out = NO$1;
+    };
+    return Remember;
+}());
+var ReplaceError = /** @class */ (function () {
+    function ReplaceError(replacer, ins) {
+        this.type = 'replaceError';
+        this.ins = ins;
+        this.out = NO$1;
+        this.f = replacer;
+    }
+    ReplaceError.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    ReplaceError.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+    };
+    ReplaceError.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._n(t);
+    };
+    ReplaceError.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        try {
+            this.ins._remove(this);
+            (this.ins = this.f(err))._add(this);
+        }
+        catch (e) {
+            u._e(e);
+        }
+    };
+    ReplaceError.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return ReplaceError;
+}());
+var StartWith = /** @class */ (function () {
+    function StartWith(ins, val) {
+        this.type = 'startWith';
+        this.ins = ins;
+        this.out = NO$1;
+        this.val = val;
+    }
+    StartWith.prototype._start = function (out) {
+        this.out = out;
+        this.out._n(this.val);
+        this.ins._add(out);
+    };
+    StartWith.prototype._stop = function () {
+        this.ins._remove(this.out);
+        this.out = NO$1;
+    };
+    return StartWith;
+}());
+var Take = /** @class */ (function () {
+    function Take(max, ins) {
+        this.type = 'take';
+        this.ins = ins;
+        this.out = NO$1;
+        this.max = max;
+        this.taken = 0;
+    }
+    Take.prototype._start = function (out) {
+        this.out = out;
+        this.taken = 0;
+        if (this.max <= 0)
+            out._c();
+        else
+            this.ins._add(this);
+    };
+    Take.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = NO$1;
+    };
+    Take.prototype._n = function (t) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        var m = ++this.taken;
+        if (m < this.max)
+            u._n(t);
+        else if (m === this.max) {
+            u._n(t);
+            u._c();
+        }
+    };
+    Take.prototype._e = function (err) {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._e(err);
+    };
+    Take.prototype._c = function () {
+        var u = this.out;
+        if (u === NO$1)
+            return;
+        u._c();
+    };
+    return Take;
+}());
+var Stream$1 = /** @class */ (function () {
+    function Stream(producer) {
+        this._prod = producer || NO$1;
+        this._ils = [];
+        this._stopID = NO$1;
+        this._dl = NO$1;
+        this._d = false;
+        this._target = null;
+        this._err = NO$1;
+    }
+    Stream.prototype._n = function (t) {
+        var a = this._ils;
+        var L = a.length;
+        if (this._d)
+            this._dl._n(t);
+        if (L == 1)
+            a[0]._n(t);
+        else if (L == 0)
+            return;
+        else {
+            var b = cp(a);
+            for (var i = 0; i < L; i++)
+                b[i]._n(t);
+        }
+    };
+    Stream.prototype._e = function (err) {
+        if (this._err !== NO$1)
+            return;
+        this._err = err;
+        var a = this._ils;
+        var L = a.length;
+        this._x();
+        if (this._d)
+            this._dl._e(err);
+        if (L == 1)
+            a[0]._e(err);
+        else if (L == 0)
+            return;
+        else {
+            var b = cp(a);
+            for (var i = 0; i < L; i++)
+                b[i]._e(err);
+        }
+        if (!this._d && L == 0)
+            throw this._err;
+    };
+    Stream.prototype._c = function () {
+        var a = this._ils;
+        var L = a.length;
+        this._x();
+        if (this._d)
+            this._dl._c();
+        if (L == 1)
+            a[0]._c();
+        else if (L == 0)
+            return;
+        else {
+            var b = cp(a);
+            for (var i = 0; i < L; i++)
+                b[i]._c();
+        }
+    };
+    Stream.prototype._x = function () {
+        if (this._ils.length === 0)
+            return;
+        if (this._prod !== NO$1)
+            this._prod._stop();
+        this._err = NO$1;
+        this._ils = [];
+    };
+    Stream.prototype._stopNow = function () {
+        // WARNING: code that calls this method should
+        // first check if this._prod is valid (not `NO`)
+        this._prod._stop();
+        this._err = NO$1;
+        this._stopID = NO$1;
+    };
+    Stream.prototype._add = function (il) {
+        var ta = this._target;
+        if (ta)
+            return ta._add(il);
+        var a = this._ils;
+        a.push(il);
+        if (a.length > 1)
+            return;
+        if (this._stopID !== NO$1) {
+            clearTimeout(this._stopID);
+            this._stopID = NO$1;
+        }
+        else {
+            var p = this._prod;
+            if (p !== NO$1)
+                p._start(this);
+        }
+    };
+    Stream.prototype._remove = function (il) {
+        var _this = this;
+        var ta = this._target;
+        if (ta)
+            return ta._remove(il);
+        var a = this._ils;
+        var i = a.indexOf(il);
+        if (i > -1) {
+            a.splice(i, 1);
+            if (this._prod !== NO$1 && a.length <= 0) {
+                this._err = NO$1;
+                this._stopID = setTimeout(function () { return _this._stopNow(); });
+            }
+            else if (a.length === 1) {
+                this._pruneCycles();
             }
+        }
+    };
+    // If all paths stemming from `this` stream eventually end at `this`
+    // stream, then we remove the single listener of `this` stream, to
+    // force it to end its execution and dispose resources. This method
+    // assumes as a precondition that this._ils has just one listener.
+    Stream.prototype._pruneCycles = function () {
+        if (this._hasNoSinks(this, []))
+            this._remove(this._ils[0]);
+    };
+    // Checks whether *there is no* path starting from `x` that leads to an end
+    // listener (sink) in the stream graph, following edges A->B where B is a
+    // listener of A. This means these paths constitute a cycle somehow. Is given
+    // a trace of all visited nodes so far.
+    Stream.prototype._hasNoSinks = function (x, trace) {
+        if (trace.indexOf(x) !== -1)
+            return true;
+        else if (x.out === this)
+            return true;
+        else if (x.out && x.out !== NO$1)
+            return this._hasNoSinks(x.out, trace.concat(x));
+        else if (x._ils) {
+            for (var i = 0, N = x._ils.length; i < N; i++)
+                if (!this._hasNoSinks(x._ils[i], trace.concat(x)))
+                    return false;
+            return true;
+        }
+        else
+            return false;
+    };
+    Stream.prototype.ctor = function () {
+        return this instanceof MemoryStream ? MemoryStream : Stream;
+    };
+    /**
+     * Adds a Listener to the Stream.
+     *
+     * @param {Listener} listener
+     */
+    Stream.prototype.addListener = function (listener) {
+        listener._n = listener.next || noop;
+        listener._e = listener.error || noop;
+        listener._c = listener.complete || noop;
+        this._add(listener);
+    };
+    /**
+     * Removes a Listener from the Stream, assuming the Listener was added to it.
+     *
+     * @param {Listener<T>} listener
+     */
+    Stream.prototype.removeListener = function (listener) {
+        this._remove(listener);
+    };
+    /**
+     * Adds a Listener to the Stream returning a Subscription to remove that
+     * listener.
+     *
+     * @param {Listener} listener
+     * @returns {Subscription}
+     */
+    Stream.prototype.subscribe = function (listener) {
+        this.addListener(listener);
+        return new StreamSub(this, listener);
+    };
+    /**
+     * Add interop between most.js and RxJS 5
+     *
+     * @returns {Stream}
+     */
+    Stream.prototype[$$observable] = function () {
+        return this;
+    };
+    /**
+     * Creates a new Stream given a Producer.
+     *
+     * @factory true
+     * @param {Producer} producer An optional Producer that dictates how to
+     * start, generate events, and stop the Stream.
+     * @return {Stream}
+     */
+    Stream.create = function (producer) {
+        if (producer) {
+            if (typeof producer.start !== 'function'
+                || typeof producer.stop !== 'function')
+                throw new Error('producer requires both start and stop functions');
+            internalizeProducer(producer); // mutates the input
+        }
+        return new Stream(producer);
+    };
+    /**
+     * Creates a new MemoryStream given a Producer.
+     *
+     * @factory true
+     * @param {Producer} producer An optional Producer that dictates how to
+     * start, generate events, and stop the Stream.
+     * @return {MemoryStream}
+     */
+    Stream.createWithMemory = function (producer) {
+        if (producer)
+            internalizeProducer(producer); // mutates the input
+        return new MemoryStream(producer);
+    };
+    /**
+     * Creates a Stream that does nothing when started. It never emits any event.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     *          never
+     * -----------------------
+     * ```
+     *
+     * @factory true
+     * @return {Stream}
+     */
+    Stream.never = function () {
+        return new Stream({ _start: noop, _stop: noop });
+    };
+    /**
+     * Creates a Stream that immediately emits the "complete" notification when
+     * started, and that's it.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * empty
+     * -|
+     * ```
+     *
+     * @factory true
+     * @return {Stream}
+     */
+    Stream.empty = function () {
+        return new Stream({
+            _start: function (il) { il._c(); },
+            _stop: noop,
         });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
+    };
+    /**
+     * Creates a Stream that immediately emits an "error" notification with the
+     * value you passed as the `error` argument when the stream starts, and that's
+     * it.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * throw(X)
+     * -X
+     * ```
+     *
+     * @factory true
+     * @param error The error event to emit on the created stream.
+     * @return {Stream}
+     */
+    Stream.throw = function (error) {
+        return new Stream({
+            _start: function (il) { il._e(error); },
+            _stop: noop,
+        });
+    };
+    /**
+     * Creates a stream from an Array, Promise, or an Observable.
+     *
+     * @factory true
+     * @param {Array|PromiseLike|Observable} input The input to make a stream from.
+     * @return {Stream}
+     */
+    Stream.from = function (input) {
+        if (typeof input[$$observable] === 'function')
+            return Stream.fromObservable(input);
+        else if (typeof input.then === 'function')
+            return Stream.fromPromise(input);
+        else if (Array.isArray(input))
+            return Stream.fromArray(input);
+        throw new TypeError("Type of input to from() must be an Array, Promise, or Observable");
+    };
+    /**
+     * Creates a Stream that immediately emits the arguments that you give to
+     * *of*, then completes.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * of(1,2,3)
+     * 123|
+     * ```
+     *
+     * @factory true
+     * @param a The first value you want to emit as an event on the stream.
+     * @param b The second value you want to emit as an event on the stream. One
+     * or more of these values may be given as arguments.
+     * @return {Stream}
+     */
+    Stream.of = function () {
+        var items = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            items[_i] = arguments[_i];
+        }
+        return Stream.fromArray(items);
+    };
+    /**
+     * Converts an array to a stream. The returned stream will emit synchronously
+     * all the items in the array, and then complete.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * fromArray([1,2,3])
+     * 123|
+     * ```
+     *
+     * @factory true
+     * @param {Array} array The array to be converted as a stream.
+     * @return {Stream}
+     */
+    Stream.fromArray = function (array) {
+        return new Stream(new FromArray(array));
+    };
+    /**
+     * Converts a promise to a stream. The returned stream will emit the resolved
+     * value of the promise, and then complete. However, if the promise is
+     * rejected, the stream will emit the corresponding error.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * fromPromise( ----42 )
+     * -----------------42|
+     * ```
+     *
+     * @factory true
+     * @param {PromiseLike} promise The promise to be converted as a stream.
+     * @return {Stream}
+     */
+    Stream.fromPromise = function (promise) {
+        return new Stream(new FromPromise(promise));
+    };
+    /**
+     * Converts an Observable into a Stream.
+     *
+     * @factory true
+     * @param {any} observable The observable to be converted as a stream.
+     * @return {Stream}
+     */
+    Stream.fromObservable = function (obs) {
+        if (obs.endWhen !== undefined)
+            return obs;
+        var o = typeof obs[$$observable] === 'function' ? obs[$$observable]() : obs;
+        return new Stream(new FromObservable(o));
+    };
+    /**
+     * Creates a stream that periodically emits incremental numbers, every
+     * `period` milliseconds.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     *     periodic(1000)
+     * ---0---1---2---3---4---...
+     * ```
+     *
+     * @factory true
+     * @param {number} period The interval in milliseconds to use as a rate of
+     * emission.
+     * @return {Stream}
+     */
+    Stream.periodic = function (period) {
+        return new Stream(new Periodic(period));
+    };
+    Stream.prototype._map = function (project) {
+        return new (this.ctor())(new MapOp(project, this));
+    };
+    /**
+     * Transforms each event from the input Stream through a `project` function,
+     * to get a Stream that emits those transformed events.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1---3--5-----7------
+     *    map(i => i * 10)
+     * --10--30-50----70-----
+     * ```
+     *
+     * @param {Function} project A function of type `(t: T) => U` that takes event
+     * `t` of type `T` from the input Stream and produces an event of type `U`, to
+     * be emitted on the output Stream.
+     * @return {Stream}
+     */
+    Stream.prototype.map = function (project) {
+        return this._map(project);
+    };
+    /**
+     * It's like `map`, but transforms each input event to always the same
+     * constant value on the output Stream.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1---3--5-----7-----
+     *       mapTo(10)
+     * --10--10-10----10----
+     * ```
+     *
+     * @param projectedValue A value to emit on the output Stream whenever the
+     * input Stream emits any value.
+     * @return {Stream}
+     */
+    Stream.prototype.mapTo = function (projectedValue) {
+        var s = this.map(function () { return projectedValue; });
+        var op = s._prod;
+        op.type = 'mapTo';
+        return s;
+    };
+    /**
+     * Only allows events that pass the test given by the `passes` argument.
+     *
+     * Each event from the input stream is given to the `passes` function. If the
+     * function returns `true`, the event is forwarded to the output stream,
+     * otherwise it is ignored and not forwarded.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1---2--3-----4-----5---6--7-8--
+     *     filter(i => i % 2 === 0)
+     * ------2--------4---------6----8--
+     * ```
+     *
+     * @param {Function} passes A function of type `(t: T) => boolean` that takes
+     * an event from the input stream and checks if it passes, by returning a
+     * boolean.
+     * @return {Stream}
+     */
+    Stream.prototype.filter = function (passes) {
+        var p = this._prod;
+        if (p instanceof Filter)
+            return new Stream(new Filter(and(p.f, passes), p.ins));
+        return new Stream(new Filter(passes, this));
+    };
+    /**
+     * Lets the first `amount` many events from the input stream pass to the
+     * output stream, then makes the output stream complete.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --a---b--c----d---e--
+     *    take(3)
+     * --a---b--c|
+     * ```
+     *
+     * @param {number} amount How many events to allow from the input stream
+     * before completing the output stream.
+     * @return {Stream}
+     */
+    Stream.prototype.take = function (amount) {
+        return new (this.ctor())(new Take(amount, this));
+    };
+    /**
+     * Ignores the first `amount` many events from the input stream, and then
+     * after that starts forwarding events from the input stream to the output
+     * stream.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --a---b--c----d---e--
+     *       drop(3)
+     * --------------d---e--
+     * ```
+     *
+     * @param {number} amount How many events to ignore from the input stream
+     * before forwarding all events from the input stream to the output stream.
+     * @return {Stream}
+     */
+    Stream.prototype.drop = function (amount) {
+        return new Stream(new Drop(amount, this));
+    };
+    /**
+     * When the input stream completes, the output stream will emit the last event
+     * emitted by the input stream, and then will also complete.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --a---b--c--d----|
+     *       last()
+     * -----------------d|
+     * ```
+     *
+     * @return {Stream}
+     */
+    Stream.prototype.last = function () {
+        return new Stream(new Last(this));
+    };
+    /**
+     * Prepends the given `initial` value to the sequence of events emitted by the
+     * input stream. The returned stream is a MemoryStream, which means it is
+     * already `remember()`'d.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * ---1---2-----3---
+     *   startWith(0)
+     * 0--1---2-----3---
+     * ```
+     *
+     * @param initial The value or event to prepend.
+     * @return {MemoryStream}
+     */
+    Stream.prototype.startWith = function (initial) {
+        return new MemoryStream(new StartWith(this, initial));
+    };
+    /**
+     * Uses another stream to determine when to complete the current stream.
+     *
+     * When the given `other` stream emits an event or completes, the output
+     * stream will complete. Before that happens, the output stream will behaves
+     * like the input stream.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * ---1---2-----3--4----5----6---
+     *   endWhen( --------a--b--| )
+     * ---1---2-----3--4--|
+     * ```
+     *
+     * @param other Some other stream that is used to know when should the output
+     * stream of this operator complete.
+     * @return {Stream}
+     */
+    Stream.prototype.endWhen = function (other) {
+        return new (this.ctor())(new EndWhen(other, this));
+    };
+    /**
+     * "Folds" the stream onto itself.
+     *
+     * Combines events from the past throughout
+     * the entire execution of the input stream, allowing you to accumulate them
+     * together. It's essentially like `Array.prototype.reduce`. The returned
+     * stream is a MemoryStream, which means it is already `remember()`'d.
+     *
+     * The output stream starts by emitting the `seed` which you give as argument.
+     * Then, when an event happens on the input stream, it is combined with that
+     * seed value through the `accumulate` function, and the output value is
+     * emitted on the output stream. `fold` remembers that output value as `acc`
+     * ("accumulator"), and then when a new input event `t` happens, `acc` will be
+     * combined with that to produce the new `acc` and so forth.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * ------1-----1--2----1----1------
+     *   fold((acc, x) => acc + x, 3)
+     * 3-----4-----5--7----8----9------
+     * ```
+     *
+     * @param {Function} accumulate A function of type `(acc: R, t: T) => R` that
+     * takes the previous accumulated value `acc` and the incoming event from the
+     * input stream and produces the new accumulated value.
+     * @param seed The initial accumulated value, of type `R`.
+     * @return {MemoryStream}
+     */
+    Stream.prototype.fold = function (accumulate, seed) {
+        return new MemoryStream(new Fold(accumulate, seed, this));
+    };
+    /**
+     * Replaces an error with another stream.
+     *
+     * When (and if) an error happens on the input stream, instead of forwarding
+     * that error to the output stream, *replaceError* will call the `replace`
+     * function which returns the stream that the output stream will replicate.
+     * And, in case that new stream also emits an error, `replace` will be called
+     * again to get another stream to start replicating.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1---2-----3--4-----X
+     *   replaceError( () => --10--| )
+     * --1---2-----3--4--------10--|
+     * ```
+     *
+     * @param {Function} replace A function of type `(err) => Stream` that takes
+     * the error that occurred on the input stream or on the previous replacement
+     * stream and returns a new stream. The output stream will behave like the
+     * stream that this function returns.
+     * @return {Stream}
+     */
+    Stream.prototype.replaceError = function (replace) {
+        return new (this.ctor())(new ReplaceError(replace, this));
+    };
+    /**
+     * Flattens a "stream of streams", handling only one nested stream at a time
+     * (no concurrency).
+     *
+     * If the input stream is a stream that emits streams, then this operator will
+     * return an output stream which is a flat stream: emits regular events. The
+     * flattening happens without concurrency. It works like this: when the input
+     * stream emits a nested stream, *flatten* will start imitating that nested
+     * one. However, as soon as the next nested stream is emitted on the input
+     * stream, *flatten* will forget the previous nested one it was imitating, and
+     * will start imitating the new nested one.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --+--------+---------------
+     *   \        \
+     *    \       ----1----2---3--
+     *    --a--b----c----d--------
+     *           flatten
+     * -----a--b------1----2---3--
+     * ```
+     *
+     * @return {Stream}
+     */
+    Stream.prototype.flatten = function () {
+        return new Stream(new Flatten(this));
+    };
+    /**
+     * Passes the input stream to a custom operator, to produce an output stream.
+     *
+     * *compose* is a handy way of using an existing function in a chained style.
+     * Instead of writing `outStream = f(inStream)` you can write
+     * `outStream = inStream.compose(f)`.
+     *
+     * @param {function} operator A function that takes a stream as input and
+     * returns a stream as well.
+     * @return {Stream}
+     */
+    Stream.prototype.compose = function (operator) {
+        return operator(this);
+    };
+    /**
+     * Returns an output stream that behaves like the input stream, but also
+     * remembers the most recent event that happens on the input stream, so that a
+     * newly added listener will immediately receive that memorised event.
+     *
+     * @return {MemoryStream}
+     */
+    Stream.prototype.remember = function () {
+        return new MemoryStream(new Remember(this));
+    };
+    /**
+     * Returns an output stream that identically behaves like the input stream,
+     * but also runs a `spy` function for each event, to help you debug your app.
+     *
+     * *debug* takes a `spy` function as argument, and runs that for each event
+     * happening on the input stream. If you don't provide the `spy` argument,
+     * then *debug* will just `console.log` each event. This helps you to
+     * understand the flow of events through some operator chain.
+     *
+     * Please note that if the output stream has no listeners, then it will not
+     * start, which means `spy` will never run because no actual event happens in
+     * that case.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1----2-----3-----4--
+     *         debug
+     * --1----2-----3-----4--
+     * ```
+     *
+     * @param {function} labelOrSpy A string to use as the label when printing
+     * debug information on the console, or a 'spy' function that takes an event
+     * as argument, and does not need to return anything.
+     * @return {Stream}
+     */
+    Stream.prototype.debug = function (labelOrSpy) {
+        return new (this.ctor())(new Debug(this, labelOrSpy));
+    };
+    /**
+     * *imitate* changes this current Stream to emit the same events that the
+     * `other` given Stream does. This method returns nothing.
+     *
+     * This method exists to allow one thing: **circular dependency of streams**.
+     * For instance, let's imagine that for some reason you need to create a
+     * circular dependency where stream `first$` depends on stream `second$`
+     * which in turn depends on `first$`:
+     *
+     * <!-- skip-example -->
+     * ```js
+     * import delay from 'xstream/extra/delay'
+     *
+     * var first$ = second$.map(x => x * 10).take(3);
+     * var second$ = first$.map(x => x + 1).startWith(1).compose(delay(100));
+     * ```
+     *
+     * However, that is invalid JavaScript, because `second$` is undefined
+     * on the first line. This is how *imitate* can help solve it:
+     *
+     * ```js
+     * import delay from 'xstream/extra/delay'
+     *
+     * var secondProxy$ = xs.create();
+     * var first$ = secondProxy$.map(x => x * 10).take(3);
+     * var second$ = first$.map(x => x + 1).startWith(1).compose(delay(100));
+     * secondProxy$.imitate(second$);
+     * ```
+     *
+     * We create `secondProxy$` before the others, so it can be used in the
+     * declaration of `first$`. Then, after both `first$` and `second$` are
+     * defined, we hook `secondProxy$` with `second$` with `imitate()` to tell
+     * that they are "the same". `imitate` will not trigger the start of any
+     * stream, it just binds `secondProxy$` and `second$` together.
+     *
+     * The following is an example where `imitate()` is important in Cycle.js
+     * applications. A parent component contains some child components. A child
+     * has an action stream which is given to the parent to define its state:
+     *
+     * <!-- skip-example -->
+     * ```js
+     * const childActionProxy$ = xs.create();
+     * const parent = Parent({...sources, childAction$: childActionProxy$});
+     * const childAction$ = parent.state$.map(s => s.child.action$).flatten();
+     * childActionProxy$.imitate(childAction$);
+     * ```
+     *
+     * Note, though, that **`imitate()` does not support MemoryStreams**. If we
+     * would attempt to imitate a MemoryStream in a circular dependency, we would
+     * either get a race condition (where the symptom would be "nothing happens")
+     * or an infinite cyclic emission of values. It's useful to think about
+     * MemoryStreams as cells in a spreadsheet. It doesn't make any sense to
+     * define a spreadsheet cell `A1` with a formula that depends on `B1` and
+     * cell `B1` defined with a formula that depends on `A1`.
+     *
+     * If you find yourself wanting to use `imitate()` with a
+     * MemoryStream, you should rework your code around `imitate()` to use a
+     * Stream instead. Look for the stream in the circular dependency that
+     * represents an event stream, and that would be a candidate for creating a
+     * proxy Stream which then imitates the target Stream.
+     *
+     * @param {Stream} target The other stream to imitate on the current one. Must
+     * not be a MemoryStream.
+     */
+    Stream.prototype.imitate = function (target) {
+        if (target instanceof MemoryStream)
+            throw new Error('A MemoryStream was given to imitate(), but it only ' +
+                'supports a Stream. Read more about this restriction here: ' +
+                'https://github.com/staltz/xstream#faq');
+        this._target = target;
+        for (var ils = this._ils, N = ils.length, i = 0; i < N; i++)
+            target._add(ils[i]);
+        this._ils = [];
+    };
+    /**
+     * Forces the Stream to emit the given value to its listeners.
+     *
+     * As the name indicates, if you use this, you are most likely doing something
+     * The Wrong Way. Please try to understand the reactive way before using this
+     * method. Use it only when you know what you are doing.
+     *
+     * @param value The "next" value you want to broadcast to all listeners of
+     * this Stream.
+     */
+    Stream.prototype.shamefullySendNext = function (value) {
+        this._n(value);
+    };
+    /**
+     * Forces the Stream to emit the given error to its listeners.
+     *
+     * As the name indicates, if you use this, you are most likely doing something
+     * The Wrong Way. Please try to understand the reactive way before using this
+     * method. Use it only when you know what you are doing.
+     *
+     * @param {any} error The error you want to broadcast to all the listeners of
+     * this Stream.
+     */
+    Stream.prototype.shamefullySendError = function (error) {
+        this._e(error);
+    };
+    /**
+     * Forces the Stream to emit the "completed" event to its listeners.
+     *
+     * As the name indicates, if you use this, you are most likely doing something
+     * The Wrong Way. Please try to understand the reactive way before using this
+     * method. Use it only when you know what you are doing.
+     */
+    Stream.prototype.shamefullySendComplete = function () {
+        this._c();
+    };
+    /**
+     * Adds a "debug" listener to the stream. There can only be one debug
+     * listener, that's why this is 'setDebugListener'. To remove the debug
+     * listener, just call setDebugListener(null).
+     *
+     * A debug listener is like any other listener. The only difference is that a
+     * debug listener is "stealthy": its presence/absence does not trigger the
+     * start/stop of the stream (or the producer inside the stream). This is
+     * useful so you can inspect what is going on without changing the behavior
+     * of the program. If you have an idle stream and you add a normal listener to
+     * it, the stream will start executing. But if you set a debug listener on an
+     * idle stream, it won't start executing (not until the first normal listener
+     * is added).
+     *
+     * As the name indicates, we don't recommend using this method to build app
+     * logic. In fact, in most cases the debug operator works just fine. Only use
+     * this one if you know what you're doing.
+     *
+     * @param {Listener<T>} listener
+     */
+    Stream.prototype.setDebugListener = function (listener) {
+        if (!listener) {
+            this._d = false;
+            this._dl = NO$1;
+        }
+        else {
+            this._d = true;
+            listener._n = listener.next || noop;
+            listener._e = listener.error || noop;
+            listener._c = listener.complete || noop;
+            this._dl = listener;
+        }
+    };
+    /**
+     * Blends multiple streams together, emitting events from all of them
+     * concurrently.
+     *
+     * *merge* takes multiple streams as arguments, and creates a stream that
+     * behaves like each of the argument streams, in parallel.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1----2-----3--------4---
+     * ----a-----b----c---d------
+     *            merge
+     * --1-a--2--b--3-c---d--4---
+     * ```
+     *
+     * @factory true
+     * @param {Stream} stream1 A stream to merge together with other streams.
+     * @param {Stream} stream2 A stream to merge together with other streams. Two
+     * or more streams may be given as arguments.
+     * @return {Stream}
+     */
+    Stream.merge = function merge() {
+        var streams = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            streams[_i] = arguments[_i];
+        }
+        return new Stream(new Merge(streams));
+    };
+    /**
+     * Combines multiple input streams together to return a stream whose events
+     * are arrays that collect the latest events from each input stream.
+     *
+     * *combine* internally remembers the most recent event from each of the input
+     * streams. When any of the input streams emits an event, that event together
+     * with all the other saved events are combined into an array. That array will
+     * be emitted on the output stream. It's essentially a way of joining together
+     * the events from multiple streams.
+     *
+     * Marble diagram:
+     *
+     * ```text
+     * --1----2-----3--------4---
+     * ----a-----b-----c--d------
+     *          combine
+     * ----1a-2a-2b-3b-3c-3d-4d--
+     * ```
+     *
+     * @factory true
+     * @param {Stream} stream1 A stream to combine together with other streams.
+     * @param {Stream} stream2 A stream to combine together with other streams.
+     * Multiple streams, not just two, may be given as arguments.
+     * @return {Stream}
+     */
+    Stream.combine = function combine() {
+        var streams = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            streams[_i] = arguments[_i];
+        }
+        return new Stream(new Combine(streams));
+    };
+    return Stream;
+}());
+var Stream_1 = xstream.Stream = Stream$1;
+var MemoryStream = /** @class */ (function (_super) {
+    __extends(MemoryStream, _super);
+    function MemoryStream(producer) {
+        var _this = _super.call(this, producer) || this;
+        _this._has = false;
+        return _this;
+    }
+    MemoryStream.prototype._n = function (x) {
+        this._v = x;
+        this._has = true;
+        _super.prototype._n.call(this, x);
+    };
+    MemoryStream.prototype._add = function (il) {
+        var ta = this._target;
+        if (ta)
+            return ta._add(il);
+        var a = this._ils;
+        a.push(il);
+        if (a.length > 1) {
+            if (this._has)
+                il._n(this._v);
+            return;
+        }
+        if (this._stopID !== NO$1) {
+            if (this._has)
+                il._n(this._v);
+            clearTimeout(this._stopID);
+            this._stopID = NO$1;
+        }
+        else if (this._has)
+            il._n(this._v);
+        else {
+            var p = this._prod;
+            if (p !== NO$1)
+                p._start(this);
+        }
+    };
+    MemoryStream.prototype._stopNow = function () {
+        this._has = false;
+        _super.prototype._stopNow.call(this);
+    };
+    MemoryStream.prototype._x = function () {
+        this._has = false;
+        _super.prototype._x.call(this);
+    };
+    MemoryStream.prototype.map = function (project) {
+        return this._map(project);
+    };
+    MemoryStream.prototype.mapTo = function (projectedValue) {
+        return _super.prototype.mapTo.call(this, projectedValue);
+    };
+    MemoryStream.prototype.take = function (amount) {
+        return _super.prototype.take.call(this, amount);
+    };
+    MemoryStream.prototype.endWhen = function (other) {
+        return _super.prototype.endWhen.call(this, other);
+    };
+    MemoryStream.prototype.replaceError = function (replace) {
+        return _super.prototype.replaceError.call(this, replace);
+    };
+    MemoryStream.prototype.remember = function () {
+        return this;
+    };
+    MemoryStream.prototype.debug = function (labelOrSpy) {
+        return _super.prototype.debug.call(this, labelOrSpy);
+    };
+    return MemoryStream;
+}(Stream$1));
+var MemoryStream_1 = xstream.MemoryStream = MemoryStream;
+var xs$1 = Stream$1;
+var _default$5 = xstream.default = xs$1;
 
-var xs__namespace = /*#__PURE__*/_interopNamespaceDefault(xs$1);
-var dropRepeats__namespace = /*#__PURE__*/_interopNamespaceDefault(dropRepeats$2);
-var delayModule__namespace = /*#__PURE__*/_interopNamespaceDefault(delayModule);
-var concatModule__namespace = /*#__PURE__*/_interopNamespaceDefault(concatModule);
-var debounceModule__namespace = /*#__PURE__*/_interopNamespaceDefault(debounceModule);
-var dropRepeatsModule__namespace = /*#__PURE__*/_interopNamespaceDefault(dropRepeatsModule);
+var xstreamNamespace = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	get MemoryStream () { return MemoryStream_1; },
+	get NO () { return NO_1; },
+	get NO_IL () { return NO_IL_1; },
+	get Stream () { return Stream_1; },
+	default: _default$5
+}, [xstream]);
 
 function getGlobal() {
     let globalObj;
@@ -66,7 +2629,7 @@ function makeSinkProxies(drivers) {
     const sinkProxies = {};
     for (const name in drivers) {
         if (Object.prototype.hasOwnProperty.call(drivers, name)) {
-            sinkProxies[name] = xs$1.create();
+            sinkProxies[name] = _default$5.create();
         }
     }
     return sinkProxies;
@@ -107,7 +2670,7 @@ function replicateMany(sinks, sinkProxies) {
             complete: () => { },
         };
     });
-    const subscriptions = sinkNames.map(name => xs$1.fromObservable(sinks[name]).subscribe(replicators[name]));
+    const subscriptions = sinkNames.map(name => _default$5.fromObservable(sinks[name]).subscribe(replicators[name]));
     sinkNames.forEach(name => {
         const listener = sinkProxies[name];
         const next = (x) => {
@@ -219,6 +2782,133 @@ function setupReusable(drivers) {
     return { sources, run: _run, dispose: disposeEngine };
 }
 
+var dropRepeats$3 = {};
+
+Object.defineProperty(dropRepeats$3, "__esModule", { value: true });
+var DropRepeatsOperator_1 = dropRepeats$3.DropRepeatsOperator = void 0;
+var index_1$4 = xstream;
+var empty = {};
+var DropRepeatsOperator = /** @class */ (function () {
+    function DropRepeatsOperator(ins, fn) {
+        this.ins = ins;
+        this.type = 'dropRepeats';
+        this.out = null;
+        this.v = empty;
+        this.isEq = fn ? fn : function (x, y) { return x === y; };
+    }
+    DropRepeatsOperator.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    DropRepeatsOperator.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = null;
+        this.v = empty;
+    };
+    DropRepeatsOperator.prototype._n = function (t) {
+        var u = this.out;
+        if (!u)
+            return;
+        var v = this.v;
+        if (v !== empty && this.isEq(t, v))
+            return;
+        this.v = t;
+        u._n(t);
+    };
+    DropRepeatsOperator.prototype._e = function (err) {
+        var u = this.out;
+        if (!u)
+            return;
+        u._e(err);
+    };
+    DropRepeatsOperator.prototype._c = function () {
+        var u = this.out;
+        if (!u)
+            return;
+        u._c();
+    };
+    return DropRepeatsOperator;
+}());
+DropRepeatsOperator_1 = dropRepeats$3.DropRepeatsOperator = DropRepeatsOperator;
+/**
+ * Drops consecutive duplicate values in a stream.
+ *
+ * Marble diagram:
+ *
+ * ```text
+ * --1--2--1--1--1--2--3--4--3--3|
+ *     dropRepeats
+ * --1--2--1--------2--3--4--3---|
+ * ```
+ *
+ * Example:
+ *
+ * ```js
+ * import dropRepeats from 'xstream/extra/dropRepeats'
+ *
+ * const stream = xs.of(1, 2, 1, 1, 1, 2, 3, 4, 3, 3)
+ *   .compose(dropRepeats())
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > 1
+ * > 2
+ * > 1
+ * > 2
+ * > 3
+ * > 4
+ * > 3
+ * > completed
+ * ```
+ *
+ * Example with a custom isEqual function:
+ *
+ * ```js
+ * import dropRepeats from 'xstream/extra/dropRepeats'
+ *
+ * const stream = xs.of('a', 'b', 'a', 'A', 'B', 'b')
+ *   .compose(dropRepeats((x, y) => x.toLowerCase() === y.toLowerCase()))
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > a
+ * > b
+ * > a
+ * > B
+ * > completed
+ * ```
+ *
+ * @param {Function} isEqual An optional function of type
+ * `(x: T, y: T) => boolean` that takes an event from the input stream and
+ * checks if it is equal to previous event, by returning a boolean.
+ * @return {Stream}
+ */
+function dropRepeats$2(isEqual) {
+    if (isEqual === void 0) { isEqual = void 0; }
+    return function dropRepeatsOperator(ins) {
+        return new index_1$4.Stream(new DropRepeatsOperator(ins, isEqual));
+    };
+}
+var _default$4 = dropRepeats$3.default = dropRepeats$2;
+
+var dropRepeatsModule = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	get DropRepeatsOperator () { return DropRepeatsOperator_1; },
+	default: _default$4
+}, [dropRepeats$3]);
+
 function updateArrayEntry(array, scope, newVal) {
     if (newVal === array[scope]) {
         return array;
@@ -288,7 +2978,7 @@ class StateSource {
         this.isolateSink = isolateSink;
         this._stream = stream
             .filter(s => typeof s !== 'undefined')
-            .compose(dropRepeats$2())
+            .compose(_default$4())
             .remember();
         this._name = name;
         this.stream = adapt(this._stream);
@@ -359,7 +3049,7 @@ function isolateAllSinks(sources, innerSinks, scopes) {
             source &&
             scopes[channel] !== null &&
             typeof source.isolateSink === 'function') {
-            outerSinks[channel] = adapt(source.isolateSink(xs$1.fromObservable(innerSink), scopes[channel]));
+            outerSinks[channel] = adapt(source.isolateSink(_default$5.fromObservable(innerSink), scopes[channel]));
         }
         else if (Object.prototype.hasOwnProperty.call(innerSinks, channel)) {
             outerSinks[channel] = innerSinks[channel];
@@ -461,7 +3151,7 @@ class PickMerge {
         for (let i = 0; i < n; ++i) {
             const sinks = arrSinks[i];
             const key = sinks._key;
-            const sink = xs$1.fromObservable(sinks[sel] || xs$1.never());
+            const sink = _default$5.fromObservable(sinks[sel] || _default$5.never());
             if (!ils.has(key)) {
                 ils.set(key, new PickMergeListener(out, this, sink));
                 sink._add(ils.get(key));
@@ -494,7 +3184,7 @@ class PickMerge {
 }
 function pickMerge(selector) {
     return function pickMergeOperator(inst$) {
-        return new xs$1.Stream(new PickMerge(selector, inst$));
+        return new Stream_1(new PickMerge(selector, inst$));
     };
 }
 
@@ -503,7 +3193,7 @@ class PickCombineListener {
         this.key = key;
         this.out = out;
         this.p = p;
-        this.val = xs$1.NO;
+        this.val = NO_1;
         this.ins = ins;
     }
     _n(t) {
@@ -562,7 +3252,7 @@ class PickCombine {
                 return;
             }
             const val = ils.get(key).val;
-            if (val === xs$1.NO) {
+            if (val === NO_1) {
                 return;
             }
             outArr[i] = val;
@@ -600,7 +3290,7 @@ class PickCombine {
             if (!sinks[sel]) {
                 throw new Error('pickCombine found an undefined child sink stream');
             }
-            const sink = xs$1.fromObservable(sinks[sel]);
+            const sink = _default$5.fromObservable(sinks[sel]);
             if (!ils.has(key)) {
                 ils.set(key, new PickCombineListener(key, out, this, sink));
                 sink._add(ils.get(key));
@@ -627,7 +3317,7 @@ class PickCombine {
 }
 function pickCombine(selector) {
     return function pickCombineOperator(inst$) {
-        return new xs$1.Stream(new PickCombine(selector, inst$));
+        return new Stream_1(new PickCombine(selector, inst$));
     };
 }
 
@@ -693,7 +3383,7 @@ function makeCollection(opts) {
         const name = opts.channel || 'state';
         const itemKey = opts.itemKey;
         const itemScope = opts.itemScope || defaultItemScope;
-        const state$ = xs$1.fromObservable(sources[name].stream);
+        const state$ = _default$5.fromObservable(sources[name].stream);
         const instances$ = state$.fold((acc, nextState) => {
             const dict = acc.dict;
             if (Array.isArray(nextState)) {
@@ -722,8 +3412,11 @@ function makeCollection(opts) {
                     nextInstArray[i]._key = key;
                 }
                 // remove
-                dict.forEach((_, key) => {
+                dict.forEach((sinks, key) => {
                     if (!nextKeys.has(key)) {
+                        if (sinks && typeof sinks.__dispose === 'function') {
+                            sinks.__dispose();
+                        }
                         dict.delete(key);
                     }
                 });
@@ -731,6 +3424,10 @@ function makeCollection(opts) {
                 return { dict: dict, arr: nextInstArray };
             }
             else {
+                dict.forEach((sinks) => {
+                    if (sinks && typeof sinks.__dispose === 'function')
+                        sinks.__dispose();
+                });
                 dict.clear();
                 const key = `${itemKey ? itemKey(nextState, 0) : 'this'}`;
                 const stateScope = identityLens;
@@ -750,9 +3447,111 @@ function makeCollection(opts) {
     };
 }
 
+var concat$2 = {};
+
+Object.defineProperty(concat$2, "__esModule", { value: true });
+var index_1$3 = xstream;
+var ConcatProducer = /** @class */ (function () {
+    function ConcatProducer(streams) {
+        this.streams = streams;
+        this.type = 'concat';
+        this.out = null;
+        this.i = 0;
+    }
+    ConcatProducer.prototype._start = function (out) {
+        this.out = out;
+        this.streams[this.i]._add(this);
+    };
+    ConcatProducer.prototype._stop = function () {
+        var streams = this.streams;
+        if (this.i < streams.length) {
+            streams[this.i]._remove(this);
+        }
+        this.i = 0;
+        this.out = null;
+    };
+    ConcatProducer.prototype._n = function (t) {
+        var u = this.out;
+        if (!u)
+            return;
+        u._n(t);
+    };
+    ConcatProducer.prototype._e = function (err) {
+        var u = this.out;
+        if (!u)
+            return;
+        u._e(err);
+    };
+    ConcatProducer.prototype._c = function () {
+        var u = this.out;
+        if (!u)
+            return;
+        var streams = this.streams;
+        streams[this.i]._remove(this);
+        if (++this.i < streams.length) {
+            streams[this.i]._add(this);
+        }
+        else {
+            u._c();
+        }
+    };
+    return ConcatProducer;
+}());
+/**
+ * Puts one stream after the other. *concat* is a factory that takes multiple
+ * streams as arguments, and starts the `n+1`-th stream only when the `n`-th
+ * stream has completed. It concatenates those streams together.
+ *
+ * Marble diagram:
+ *
+ * ```text
+ * --1--2---3---4-|
+ * ...............--a-b-c--d-|
+ *           concat
+ * --1--2---3---4---a-b-c--d-|
+ * ```
+ *
+ * Example:
+ *
+ * ```js
+ * import concat from 'xstream/extra/concat'
+ *
+ * const streamA = xs.of('a', 'b', 'c')
+ * const streamB = xs.of(10, 20, 30)
+ * const streamC = xs.of('X', 'Y', 'Z')
+ *
+ * const outputStream = concat(streamA, streamB, streamC)
+ *
+ * outputStream.addListener({
+ *   next: (x) => console.log(x),
+ *   error: (err) => console.error(err),
+ *   complete: () => console.log('concat completed'),
+ * })
+ * ```
+ *
+ * @factory true
+ * @param {Stream} stream1 A stream to concatenate together with other streams.
+ * @param {Stream} stream2 A stream to concatenate together with other streams. Two
+ * or more streams may be given as arguments.
+ * @return {Stream}
+ */
+function concat$1() {
+    var streams = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        streams[_i] = arguments[_i];
+    }
+    return new index_1$3.Stream(new ConcatProducer(streams));
+}
+var _default$3 = concat$2.default = concat$1;
+
+var concatModule = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	default: _default$3
+}, [concat$2]);
+
 function withState(main, name = 'state') {
     return function mainWithState(sources) {
-        const reducerMimic$ = xs$1.create();
+        const reducerMimic$ = _default$5.create();
         const state$ = reducerMimic$
             .fold((state, reducer) => reducer(state), void 0)
             .drop(1);
@@ -760,7 +3559,7 @@ function withState(main, name = 'state') {
         innerSources[name] = new StateSource(state$, name);
         const sinks = main(innerSources);
         if (sinks[name]) {
-            const stream$ = concat$1(xs$1.fromObservable(sinks[name]), xs$1.never());
+            const stream$ = _default$3(_default$5.fromObservable(sinks[name]), _default$5.never());
             stream$.subscribe({
                 next: i => queueMicrotask(() => reducerMimic$._n(i)),
                 error: err => queueMicrotask(() => reducerMimic$._e(err)),
@@ -773,7 +3572,7 @@ function withState(main, name = 'state') {
 
 function fromEvent(element, eventName, useCapture = false, preventDefault = false, passive = false) {
     let next = null;
-    return xs$1.Stream.create({
+    return Stream_1.create({
         start: function start(listener) {
             if (preventDefault) {
                 next = function _next(event) {
@@ -838,25 +3637,45 @@ function isPredicate(fn) {
 }
 
 class DocumentDOMSource {
-    constructor(_name) {
+    constructor(_name, selector) {
         this._name = _name;
+        this._selector = selector || null;
     }
     select(selector) {
-        return this;
+        return new DocumentDOMSource(this._name, selector);
     }
     elements() {
-        const out = adapt(xs$1.of([document]));
+        if (this._selector) {
+            const out = adapt(_default$5.of(Array.from(document.querySelectorAll(this._selector))));
+            out._isCycleSource = this._name;
+            return out;
+        }
+        const out = adapt(_default$5.of([document]));
         out._isCycleSource = this._name;
         return out;
     }
     element() {
-        const out = adapt(xs$1.of(document));
+        if (this._selector) {
+            const out = adapt(_default$5.of(document.querySelector(this._selector)));
+            out._isCycleSource = this._name;
+            return out;
+        }
+        const out = adapt(_default$5.of(document));
         out._isCycleSource = this._name;
         return out;
     }
     events(eventType, options = {}, bubbles) {
         let stream;
         stream = fromEvent(document, eventType, options.useCapture, options.preventDefault);
+        if (this._selector) {
+            const selector = this._selector;
+            stream = stream.filter((ev) => {
+                const target = ev.target;
+                if (!(target instanceof Element))
+                    return false;
+                return target.matches(selector) || target.closest(selector) !== null;
+            });
+        }
         const out = adapt(stream);
         out._isCycleSource = this._name;
         return out;
@@ -871,12 +3690,12 @@ class BodyDOMSource {
         return this;
     }
     elements() {
-        const out = adapt(xs$1.of([document.body]));
+        const out = adapt(_default$5.of([document.body]));
         out._isCycleSource = this._name;
         return out;
     }
     element() {
-        const out = adapt(xs$1.of(document.body));
+        const out = adapt(_default$5.of(document.body));
         out._isCycleSource = this._name;
         return out;
     }
@@ -1093,6 +3912,190 @@ class MainDOMSource {
     }
 }
 
+var sampleCombine$1 = {};
+
+var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(sampleCombine$1, "__esModule", { value: true });
+sampleCombine$1.SampleCombineOperator = sampleCombine$1.SampleCombineListener = void 0;
+var index_1$2 = xstream;
+var NO = {};
+var SampleCombineListener = /** @class */ (function () {
+    function SampleCombineListener(i, p) {
+        this.i = i;
+        this.p = p;
+        p.ils[i] = this;
+    }
+    SampleCombineListener.prototype._n = function (t) {
+        var p = this.p;
+        if (p.out === NO)
+            return;
+        p.up(t, this.i);
+    };
+    SampleCombineListener.prototype._e = function (err) {
+        this.p._e(err);
+    };
+    SampleCombineListener.prototype._c = function () {
+        this.p.down(this.i, this);
+    };
+    return SampleCombineListener;
+}());
+sampleCombine$1.SampleCombineListener = SampleCombineListener;
+var SampleCombineOperator = /** @class */ (function () {
+    function SampleCombineOperator(ins, streams) {
+        this.type = 'sampleCombine';
+        this.ins = ins;
+        this.others = streams;
+        this.out = NO;
+        this.ils = [];
+        this.Nn = 0;
+        this.vals = [];
+    }
+    SampleCombineOperator.prototype._start = function (out) {
+        this.out = out;
+        var s = this.others;
+        var n = this.Nn = s.length;
+        var vals = this.vals = new Array(n);
+        for (var i = 0; i < n; i++) {
+            vals[i] = NO;
+            s[i]._add(new SampleCombineListener(i, this));
+        }
+        this.ins._add(this);
+    };
+    SampleCombineOperator.prototype._stop = function () {
+        var s = this.others;
+        var n = s.length;
+        var ils = this.ils;
+        this.ins._remove(this);
+        for (var i = 0; i < n; i++) {
+            s[i]._remove(ils[i]);
+        }
+        this.out = NO;
+        this.vals = [];
+        this.ils = [];
+    };
+    SampleCombineOperator.prototype._n = function (t) {
+        var out = this.out;
+        if (out === NO)
+            return;
+        if (this.Nn > 0)
+            return;
+        out._n(__spreadArrays([t], this.vals));
+    };
+    SampleCombineOperator.prototype._e = function (err) {
+        var out = this.out;
+        if (out === NO)
+            return;
+        out._e(err);
+    };
+    SampleCombineOperator.prototype._c = function () {
+        var out = this.out;
+        if (out === NO)
+            return;
+        out._c();
+    };
+    SampleCombineOperator.prototype.up = function (t, i) {
+        var v = this.vals[i];
+        if (this.Nn > 0 && v === NO) {
+            this.Nn--;
+        }
+        this.vals[i] = t;
+    };
+    SampleCombineOperator.prototype.down = function (i, l) {
+        this.others[i]._remove(l);
+    };
+    return SampleCombineOperator;
+}());
+sampleCombine$1.SampleCombineOperator = SampleCombineOperator;
+var sampleCombine;
+/**
+ *
+ * Combines a source stream with multiple other streams. The result stream
+ * will emit the latest events from all input streams, but only when the
+ * source stream emits.
+ *
+ * If the source, or any input stream, throws an error, the result stream
+ * will propagate the error. If any input streams end, their final emitted
+ * value will remain in the array of any subsequent events from the result
+ * stream.
+ *
+ * The result stream will only complete upon completion of the source stream.
+ *
+ * Marble diagram:
+ *
+ * ```text
+ * --1----2-----3--------4--- (source)
+ * ----a-----b-----c--d------ (other)
+ *      sampleCombine
+ * -------2a----3b-------4d--
+ * ```
+ *
+ * Examples:
+ *
+ * ```js
+ * import sampleCombine from 'xstream/extra/sampleCombine'
+ * import xs from 'xstream'
+ *
+ * const sampler = xs.periodic(1000).take(3)
+ * const other = xs.periodic(100)
+ *
+ * const stream = sampler.compose(sampleCombine(other))
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > [0, 8]
+ * > [1, 18]
+ * > [2, 28]
+ * ```
+ *
+ * ```js
+ * import sampleCombine from 'xstream/extra/sampleCombine'
+ * import xs from 'xstream'
+ *
+ * const sampler = xs.periodic(1000).take(3)
+ * const other = xs.periodic(100).take(2)
+ *
+ * const stream = sampler.compose(sampleCombine(other))
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > [0, 1]
+ * > [1, 1]
+ * > [2, 1]
+ * ```
+ *
+ * @param {...Stream} streams One or more streams to combine with the sampler
+ * stream.
+ * @return {Stream}
+ */
+sampleCombine = function sampleCombine() {
+    var streams = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        streams[_i] = arguments[_i];
+    }
+    return function sampleCombineOperator(sampler) {
+        return new index_1$2.Stream(new SampleCombineOperator(sampler, streams));
+    };
+};
+var _default$2 = sampleCombine$1.default = sampleCombine;
+
 function selectorParser(node) {
     if (!node.sel) {
         return { tagName: '', id: '', className: '' };
@@ -1559,7 +4562,7 @@ class EventDelegator {
         });
     }
     addEventListener(eventType, namespace, options, bubbles) {
-        const subject = xs$1.never();
+        const subject = _default$5.never();
         let dest;
         const scopeChecker = new ScopeChecker(namespace, this.isolateModule);
         const shouldBubble = bubbles === undefined
@@ -1602,7 +4605,7 @@ class EventDelegator {
             }
             const self = this;
             let subscription = null;
-            return xs$1.create({
+            return _default$5.create({
                 start: listener => {
                     subscription = nonBubbleSubject.subscribe(listener);
                 },
@@ -1856,7 +4859,7 @@ function domDriverInputGuard(view$) {
     }
 }
 function dropCompletion(input) {
-    return xs$1.merge(input, xs$1.never());
+    return _default$5.merge(input, _default$5.never());
 }
 function unwrapElementFromVNode(vnode) {
     return vnode.elm;
@@ -1865,7 +4868,7 @@ function defaultReportSnabbdomError(err) {
     (console.error || console.log)(err);
 }
 function makeDOMReady$() {
-    return xs$1.create({
+    return _default$5.create({
         start(lis) {
             if (document.readyState === 'loading') {
                 document.addEventListener('readystatechange', () => {
@@ -1899,7 +4902,7 @@ function makeDOMDriver(container, options = {}) {
     const domReady$ = makeDOMReady$();
     let vnodeWrapper;
     let mutationObserver;
-    const mutationConfirmed$ = xs$1.create({
+    const mutationConfirmed$ = _default$5.create({
         start(listener) {
             mutationObserver = new MutationObserver(() => listener.next(null));
         },
@@ -1909,7 +4912,7 @@ function makeDOMDriver(container, options = {}) {
     });
     function DOMDriver(vnode$, name = 'DOM') {
         domDriverInputGuard(vnode$);
-        const sanitation$ = xs$1.create();
+        const sanitation$ = _default$5.create();
         const firstRoot$ = domReady$.map(() => {
             const firstRoot = getValidNode(container) || document.body;
             vnodeWrapper = new VNodeWrapper(firstRoot);
@@ -1919,7 +4922,7 @@ function makeDOMDriver(container, options = {}) {
         rememberedVNode$.addListener({});
         mutationConfirmed$.addListener({});
         const elementAfterPatch$ = firstRoot$
-            .map(firstRoot => xs$1
+            .map(firstRoot => _default$5
             .merge(rememberedVNode$.endWhen(sanitation$), sanitation$)
             .map(vnode => vnodeWrapper.call(vnode))
             .startWith(addRootScope(tovnode.toVNode(firstRoot)))
@@ -1940,9 +4943,9 @@ function makeDOMDriver(container, options = {}) {
         })
             .compose(dropCompletion))
             .flatten();
-        const rootElement$ = concat$1(domReady$, mutationConfirmed$)
+        const rootElement$ = _default$3(domReady$, mutationConfirmed$)
             .endWhen(sanitation$)
-            .compose(sampleCombine(elementAfterPatch$))
+            .compose(_default$2(elementAfterPatch$))
             .map(arr => arr[1])
             .remember();
         rootElement$.addListener({
@@ -1965,7 +4968,7 @@ function eventBusDriver(out$) {
             const all = !type;
             const _type = Array.isArray(type) ? type : [type];
             let cb;
-            const in$ = xs$1.create({
+            const in$ = _default$5.create({
                 start: (listener) => {
                     cb = ({ detail: event }) => {
                         const data = (event && event.data) || null;
@@ -2069,12 +5072,12 @@ function getXs(namespaceValue) {
     }
     return value;
 }
-const xs = getXs(xs__namespace);
-const Stream = xs__namespace.Stream ||
-    (xs__namespace.default && xs__namespace.default.Stream) ||
+const xs = getXs(xstreamNamespace);
+const Stream = Stream_1 ||
+    (_default$5 && _default$5.Stream) ||
     (xs && xs.Stream);
 
-const dropRepeats$1 = resolveInteropDefault(dropRepeats__namespace);
+const dropRepeats$1 = resolveInteropDefault(dropRepeatsModule);
 function switchable(factories, name$, initial, opts = {}) {
     const { switched = ['DOM'], stateSourceName = 'STATE' } = opts;
     const nameType = typeof name$;
@@ -2150,16 +5153,226 @@ function _switchable(factories, sources, name$, switched = ['DOM'], stateSourceN
     return switchedSinks;
 }
 
-const delay = resolveInteropDefault(delayModule__namespace);
-const concat = resolveInteropDefault(concatModule__namespace);
-const debounce = resolveInteropDefault(debounceModule__namespace);
-const dropRepeats = resolveInteropDefault(dropRepeatsModule__namespace);
+var delay$2 = {};
+
+Object.defineProperty(delay$2, "__esModule", { value: true });
+var index_1$1 = xstream;
+var DelayOperator = /** @class */ (function () {
+    function DelayOperator(dt, ins) {
+        this.dt = dt;
+        this.ins = ins;
+        this.type = 'delay';
+        this.out = null;
+    }
+    DelayOperator.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    DelayOperator.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = null;
+    };
+    DelayOperator.prototype._n = function (t) {
+        var u = this.out;
+        if (!u)
+            return;
+        var id = setInterval(function () {
+            u._n(t);
+            clearInterval(id);
+        }, this.dt);
+    };
+    DelayOperator.prototype._e = function (err) {
+        var u = this.out;
+        if (!u)
+            return;
+        var id = setInterval(function () {
+            u._e(err);
+            clearInterval(id);
+        }, this.dt);
+    };
+    DelayOperator.prototype._c = function () {
+        var u = this.out;
+        if (!u)
+            return;
+        var id = setInterval(function () {
+            u._c();
+            clearInterval(id);
+        }, this.dt);
+    };
+    return DelayOperator;
+}());
+/**
+ * Delays periodic events by a given time period.
+ *
+ * Marble diagram:
+ *
+ * ```text
+ * 1----2--3--4----5|
+ *     delay(60)
+ * ---1----2--3--4----5|
+ * ```
+ *
+ * Example:
+ *
+ * ```js
+ * import fromDiagram from 'xstream/extra/fromDiagram'
+ * import delay from 'xstream/extra/delay'
+ *
+ * const stream = fromDiagram('1----2--3--4----5|')
+ *  .compose(delay(60))
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > 1  (after 60 ms)
+ * > 2  (after 160 ms)
+ * > 3  (after 220 ms)
+ * > 4  (after 280 ms)
+ * > 5  (after 380 ms)
+ * > completed
+ * ```
+ *
+ * @param {number} period The amount of silence required in milliseconds.
+ * @return {Stream}
+ */
+function delay$1(period) {
+    return function delayOperator(ins) {
+        return new index_1$1.Stream(new DelayOperator(period, ins));
+    };
+}
+var _default$1 = delay$2.default = delay$1;
+
+var delayModule = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	default: _default$1
+}, [delay$2]);
+
+var debounce$2 = {};
+
+Object.defineProperty(debounce$2, "__esModule", { value: true });
+var index_1 = xstream;
+var DebounceOperator = /** @class */ (function () {
+    function DebounceOperator(dt, ins) {
+        this.dt = dt;
+        this.ins = ins;
+        this.type = 'debounce';
+        this.out = null;
+        this.id = null;
+        this.t = index_1.NO;
+    }
+    DebounceOperator.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    DebounceOperator.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = null;
+        this.clearInterval();
+    };
+    DebounceOperator.prototype.clearInterval = function () {
+        var id = this.id;
+        if (id !== null) {
+            clearInterval(id);
+        }
+        this.id = null;
+    };
+    DebounceOperator.prototype._n = function (t) {
+        var _this = this;
+        var u = this.out;
+        if (!u)
+            return;
+        this.clearInterval();
+        this.t = t;
+        this.id = setInterval(function () {
+            _this.clearInterval();
+            u._n(t);
+            _this.t = index_1.NO;
+        }, this.dt);
+    };
+    DebounceOperator.prototype._e = function (err) {
+        var u = this.out;
+        if (!u)
+            return;
+        this.clearInterval();
+        u._e(err);
+    };
+    DebounceOperator.prototype._c = function () {
+        var u = this.out;
+        if (!u)
+            return;
+        this.clearInterval();
+        if (this.t != index_1.NO)
+            u._n(this.t);
+        this.t = index_1.NO;
+        u._c();
+    };
+    return DebounceOperator;
+}());
+/**
+ * Delays events until a certain amount of silence has passed. If that timespan
+ * of silence is not met the event is dropped.
+ *
+ * Marble diagram:
+ *
+ * ```text
+ * --1----2--3--4----5|
+ *     debounce(60)
+ * -----1----------4--|
+ * ```
+ *
+ * Example:
+ *
+ * ```js
+ * import fromDiagram from 'xstream/extra/fromDiagram'
+ * import debounce from 'xstream/extra/debounce'
+ *
+ * const stream = fromDiagram('--1----2--3--4----5|')
+ *  .compose(debounce(60))
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > 1
+ * > 4
+ * > completed
+ * ```
+ *
+ * @param {number} period The amount of silence required in milliseconds.
+ * @return {Stream}
+ */
+function debounce$1(period) {
+    return function debounceOperator(ins) {
+        return new index_1.Stream(new DebounceOperator(period, ins));
+    };
+}
+var _default = debounce$2.default = debounce$1;
+
+var debounceModule = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	default: _default
+}, [debounce$2]);
+
+const delay = resolveInteropDefault(delayModule);
+const concat = resolveInteropDefault(concatModule);
+const debounce = resolveInteropDefault(debounceModule);
+const dropRepeats = resolveInteropDefault(dropRepeatsModule);
 const ENVIRONMENT = (typeof window != 'undefined' && window) || (typeof process !== 'undefined' && process.env) || {};
 const BOOTSTRAP_ACTION = 'BOOTSTRAP';
 const INITIALIZE_ACTION = 'INITIALIZE';
 const HYDRATE_ACTION = 'HYDRATE';
 const PARENT_SINK_NAME = 'PARENT';
 const CHILD_SOURCE_NAME = 'CHILD';
+const READY_SINK_NAME = 'READY';
 let COMPONENT_COUNT = 0;
 function wrapDOMSource(domSource) {
     return new Proxy(domSource, {
@@ -2204,19 +5417,32 @@ function component(opts) {
     if (isObj(fixedIsolateOpts)) {
         const wrapped = (sources) => {
             const fixedOpts = { ...opts, sources };
-            return (new Component(fixedOpts)).sinks;
+            const instance = new Component(fixedOpts);
+            instance.sinks.__dispose = () => instance.dispose();
+            return instance.sinks;
         };
         returnFunction = currySources ? isolate(wrapped, fixedIsolateOpts) : isolate(wrapped, fixedIsolateOpts)(sources);
     }
     else {
-        returnFunction = currySources ? (sources) => (new Component({ ...opts, sources })).sinks : (new Component(opts)).sinks;
+        if (currySources) {
+            returnFunction = (sources) => {
+                const instance = new Component({ ...opts, sources });
+                instance.sinks.__dispose = () => instance.dispose();
+                return instance.sinks;
+            };
+        }
+        else {
+            const instance = new Component(opts);
+            instance.sinks.__dispose = () => instance.dispose();
+            returnFunction = instance.sinks;
+        }
     }
     returnFunction.componentName = name;
     returnFunction.isSygnalComponent = true;
     return returnFunction;
 }
 class Component {
-    constructor({ name = 'NO NAME', sources, intent, model, hmrActions, context, response, view, peers = {}, components = {}, initialState, calculated, storeCalculatedInState = true, DOMSourceName = 'DOM', stateSourceName = 'STATE', requestSourceName = 'HTTP', debug = false }) {
+    constructor({ name = 'NO NAME', sources, intent, model, hmrActions, context, response, view, peers = {}, components = {}, initialState, calculated, storeCalculatedInState = true, DOMSourceName = 'DOM', stateSourceName = 'STATE', requestSourceName = 'HTTP', onError, debug = false }) {
         if (!sources || !isObj(sources))
             throw new Error(`[${name}] Missing or invalid sources`);
         this._componentNumber = COMPONENT_COUNT++;
@@ -2237,6 +5463,7 @@ class Component {
         this.stateSourceName = stateSourceName;
         this.requestSourceName = requestSourceName;
         this.sourceNames = Object.keys(sources);
+        this.onError = onError;
         this._debug = debug;
         // Warn if calculated fields shadow base state keys
         if (this.calculated && this.initialState
@@ -2386,6 +5613,20 @@ class Component {
                 __NOOP_ACTION__: (state) => state
             };
         }
+        this._subscriptions = [];
+        this._activeSubComponents = new Map();
+        this._childReadyState = {};
+        this._readyChangedListener = null;
+        this._readyChanged$ = xs.create({
+            start: (listener) => { this._readyChangedListener = listener; },
+            stop: () => { },
+        });
+        this._disposeListener = null;
+        this._dispose$ = xs.create({
+            start: (listener) => { this._disposeListener = listener; },
+            stop: () => { },
+        });
+        this.sources.dispose$ = this._dispose$;
         this.addCalculated = this.createMemoizedAddCalculated();
         this.log = makeLog(`${this._componentNumber} | ${name}`);
         this.initChildSources$();
@@ -2412,6 +5653,51 @@ class Component {
             }
         }
     }
+    dispose() {
+        // Signal disposal to the component via dispose$ stream
+        // This fires FIRST so CLEANUP actions in the model can process
+        if (this._disposeListener) {
+            try {
+                this._disposeListener.next(true);
+                this._disposeListener.complete();
+            }
+            catch (_) { }
+            this._disposeListener = null;
+        }
+        // Tear down streams on next microtask to allow CLEANUP actions to process
+        setTimeout(() => {
+            // Complete the action$ stream to stop the entire component cycle
+            if (this.action$ && typeof this.action$.shamefullySendComplete === 'function') {
+                try {
+                    this.action$.shamefullySendComplete();
+                }
+                catch (_) { }
+            }
+            // Complete the vdom$ stream to stop rendering
+            if (this.vdom$ && typeof this.vdom$.shamefullySendComplete === 'function') {
+                try {
+                    this.vdom$.shamefullySendComplete();
+                }
+                catch (_) { }
+            }
+            // Unsubscribe tracked internal subscriptions
+            for (const sub of this._subscriptions) {
+                if (sub && typeof sub.unsubscribe === 'function') {
+                    try {
+                        sub.unsubscribe();
+                    }
+                    catch (_) { }
+                }
+            }
+            this._subscriptions = [];
+            // Dispose any active sub-components
+            this._activeSubComponents.forEach((entry) => {
+                if (entry?.sink$?.__dispose)
+                    entry.sink$.__dispose();
+            });
+            this._activeSubComponents.clear();
+        }, 0);
+    }
     get debug() {
         return this._debug || (ENVIRONMENT.SYGNAL_DEBUG === 'true' || ENVIRONMENT.SYGNAL_DEBUG === true);
     }
@@ -2542,7 +5828,7 @@ class Component {
         })
             .compose(dropRepeats(objIsEqual))
             .startWith({});
-        this.context$.subscribe({ next: (_) => _, error: (err) => console.error(`[${this.name}] Error in context stream:`, err) });
+        this._subscriptions.push(this.context$.subscribe({ next: (_) => _, error: (err) => console.error(`[${this.name}] Error in context stream:`, err) }));
     }
     initModel$() {
         if (typeof this.model == 'undefined') {
@@ -2665,7 +5951,7 @@ class Component {
             stop: (_) => {
             }
         });
-        subComponentSink$.subscribe({ next: (_) => _, error: (err) => console.error(`[${this.name}] Error in sub-component sink stream:`, err) });
+        this._subscriptions.push(subComponentSink$.subscribe({ next: (_) => _, error: (err) => console.error(`[${this.name}] Error in sub-component sink stream:`, err) }));
         this.subComponentSink$ = subComponentSink$.filter((sinks) => Object.keys(sinks).length > 0);
     }
     initSubComponentsRendered$() {
@@ -2688,10 +5974,27 @@ class Component {
             .map((params) => {
             const { props, state, children, context, ...peers } = params;
             const { sygnalFactory, sygnalOptions, ...sanitizedProps } = props || {};
-            return this.view({ ...sanitizedProps, state, children, context, peers }, state, context, peers);
+            try {
+                return this.view({ ...sanitizedProps, state, children, context, peers }, state, context, peers);
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                console.error(`[${this.name}] Error in view:`, error);
+                if (typeof this.onError === 'function') {
+                    try {
+                        return this.onError(error, { componentName: this.name });
+                    }
+                    catch (fallbackErr) {
+                        console.error(`[${this.name}] Error in onError handler:`, fallbackErr);
+                    }
+                }
+                return { sel: 'div', data: { attrs: { 'data-sygnal-error': this.name } }, children: [] };
+            }
         })
             .compose(this.log('View rendered'))
             .map((vDom) => vDom || { sel: 'div', data: {}, children: [] })
+            .map(processPortals)
+            .map(processTransitions)
             .compose(this.instantiateSubComponents.bind(this))
             .filter((val) => val !== undefined)
             .compose(this.renderVdom.bind(this));
@@ -2711,6 +6014,20 @@ class Component {
         }, {});
         this.sinks[this.DOMSourceName] = this.vdom$;
         this.sinks[PARENT_SINK_NAME] = this.model$[PARENT_SINK_NAME] || xs.never();
+        // READY sink: if the component explicitly defined READY model entries, use them;
+        // otherwise auto-emit true. Check the raw model object, not model$ (which always has keys for all sources).
+        const hasExplicitReady = this.model && isObj(this.model) && Object.values(this.model).some((sinks) => {
+            if (isObj(sinks) && READY_SINK_NAME in sinks)
+                return true;
+            return false;
+        });
+        if (hasExplicitReady) {
+            this.sinks[READY_SINK_NAME] = this.model$[READY_SINK_NAME];
+            this.sinks[READY_SINK_NAME].__explicitReady = true;
+        }
+        else {
+            this.sinks[READY_SINK_NAME] = xs.of(true);
+        }
     }
     makeOnAction(action$, isStateSink = true, rootAction$) {
         rootAction$ = rootAction$ || action$;
@@ -2734,26 +6051,38 @@ class Component {
                     if (isStateSink) {
                         return (state) => {
                             const _state = this.isSubComponent ? this.currentState : state;
-                            const enhancedState = this.addCalculated(_state);
-                            props.state = enhancedState;
-                            const newState = reducer(enhancedState, data, next, props);
-                            if (newState === ABORT)
+                            try {
+                                const enhancedState = this.addCalculated(_state);
+                                props.state = enhancedState;
+                                const newState = reducer(enhancedState, data, next, props);
+                                if (newState === ABORT)
+                                    return _state;
+                                return this.cleanupCalculated(newState);
+                            }
+                            catch (err) {
+                                console.error(`[${this.name}] Error in model reducer '${name}':`, err);
                                 return _state;
-                            return this.cleanupCalculated(newState);
+                            }
                         };
                     }
                     else {
-                        const enhancedState = this.addCalculated(this.currentState);
-                        props.state = enhancedState;
-                        const reduced = reducer(enhancedState, data, next, props);
-                        const type = typeof reduced;
-                        if (isObj(reduced) || ['string', 'number', 'boolean', 'function'].includes(type))
-                            return reduced;
-                        if (type === 'undefined') {
-                            console.warn(`[${this.name}] 'undefined' value sent to ${name}`);
-                            return reduced;
+                        try {
+                            const enhancedState = this.addCalculated(this.currentState);
+                            props.state = enhancedState;
+                            const reduced = reducer(enhancedState, data, next, props);
+                            const type = typeof reduced;
+                            if (isObj(reduced) || ['string', 'number', 'boolean', 'function'].includes(type))
+                                return reduced;
+                            if (type === 'undefined') {
+                                console.warn(`[${this.name}] 'undefined' value sent to ${name}`);
+                                return reduced;
+                            }
+                            throw new Error(`[${this.name}] Invalid reducer type for action '${name}': ${type}`);
+                        }
+                        catch (err) {
+                            console.error(`[${this.name}] Error in model reducer '${name}':`, err);
+                            return ABORT;
                         }
-                        throw new Error(`[${this.name}] Invalid reducer type for action '${name}': ${type}`);
                     }
                 }).filter((result) => result !== ABORT);
             }
@@ -2901,6 +6230,12 @@ class Component {
             const entries = Object.entries(foundComponents);
             const rootEntry = { '::ROOT::': vDom };
             if (entries.length === 0) {
+                // Dispose any previously active sub-components
+                this._activeSubComponents.forEach((entry) => {
+                    if (entry?.sink$?.__dispose)
+                        entry.sink$.__dispose();
+                });
+                this._activeSubComponents.clear();
                 return rootEntry;
             }
             const sinkArrsByType = {};
@@ -2918,7 +6253,7 @@ class Component {
                         if (name === PARENT_SINK_NAME) {
                             childSources.push(stream);
                         }
-                        else if (name !== this.DOMSourceName) {
+                        else if (name !== this.DOMSourceName && name !== READY_SINK_NAME) {
                             sinkArrsByType[name].push(stream);
                         }
                     });
@@ -2944,9 +6279,27 @@ class Component {
                     instantiator = this.instantiateCustomComponent.bind(this);
                 }
                 newInstanceCount++;
-                const sink$ = instantiator(el, props$, children$);
+                let sink$;
+                try {
+                    sink$ = instantiator(el, props$, children$);
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    console.error(`[${this.name}] Error instantiating sub-component:`, error);
+                    let fallbackVNode = { sel: 'div', data: { attrs: { 'data-sygnal-error': this.name } }, children: [] };
+                    if (typeof this.onError === 'function') {
+                        try {
+                            fallbackVNode = this.onError(error, { componentName: this.name }) || fallbackVNode;
+                        }
+                        catch (fallbackErr) {
+                            console.error(`[${this.name}] Error in onError handler:`, fallbackErr);
+                        }
+                    }
+                    sink$ = { [this.DOMSourceName]: xs.of(fallbackVNode) };
+                }
                 sink$[this.DOMSourceName] = sink$[this.DOMSourceName] ? this.makeCoordinatedSubComponentDomSink(sink$[this.DOMSourceName]) : xs.never();
                 acc[id] = { sink$, props$, children$ };
+                this._activeSubComponents.set(id, acc[id]);
                 addSinks(sink$);
                 return acc;
             }, rootEntry);
@@ -2956,6 +6309,16 @@ class Component {
                 acc[name] = streamArr.length === 1 ? streamArr[0] : xs.merge(...streamArr);
                 return acc;
             }, {});
+            // Dispose removed sub-components
+            const currentIds = new Set(Object.keys(newComponents));
+            this._activeSubComponents.forEach((entry, id) => {
+                if (!currentIds.has(id)) {
+                    if (entry?.sink$?.__dispose)
+                        entry.sink$.__dispose();
+                    this._activeSubComponents.delete(id);
+                    delete this._childReadyState[id];
+                }
+            });
             this.newSubComponentSinks(mergedSinksByType);
             this.newChildSources(childSources);
             if (newInstanceCount > 0)
@@ -3008,8 +6371,8 @@ class Component {
             else {
                 const name = collectionOf.componentName || collectionOf.label || collectionOf.name || 'FUNCTION_COMPONENT';
                 const view = collectionOf;
-                const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug } = collectionOf;
-                const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug };
+                const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, onError, debug } = collectionOf;
+                const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, onError, debug };
                 factory = component(options);
             }
         }
@@ -3168,8 +6531,8 @@ class Component {
             if (!current.isSygnalComponent) {
                 const name = current.componentName || current.label || current.name || 'FUNCTION_COMPONENT';
                 const view = current;
-                const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug } = current;
-                const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug };
+                const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, onError, debug } = current;
+                const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, onError, debug };
                 switchableComponents[key] = component(options);
             }
         });
@@ -3242,14 +6605,14 @@ class Component {
         return sink$;
     }
     renderVdom(componentInstances$) {
-        return xs.combine(this.subComponentsRendered$, componentInstances$)
+        return xs.combine(this.subComponentsRendered$, componentInstances$, this._readyChanged$.startWith(null))
             .compose(debounce(1))
             .map(([_, components]) => {
             const componentNames = Object.keys(this.components);
             const root = components['::ROOT::'];
             const entries = Object.entries(components).filter(([id]) => id !== '::ROOT::');
             if (entries.length === 0) {
-                return xs.of(root);
+                return xs.of(processSuspensePost(root));
             }
             const ids = [];
             const vdom$ = entries
@@ -3259,6 +6622,33 @@ class Component {
             });
             if (vdom$.length === 0)
                 return xs.of(root);
+            // Track READY state on the component instance (persists across folds)
+            for (const [id, val] of entries) {
+                if (this._childReadyState[id] !== undefined)
+                    continue; // already tracking
+                const readySink = val.sink$[READY_SINK_NAME];
+                if (readySink) {
+                    const isExplicit = readySink.__explicitReady;
+                    this._childReadyState[id] = isExplicit ? false : true;
+                    readySink.addListener({
+                        next: (ready) => {
+                            const wasReady = this._childReadyState[id];
+                            this._childReadyState[id] = !!ready;
+                            // When READY state changes, trigger a re-render
+                            if (wasReady !== !!ready && this._readyChangedListener) {
+                                setTimeout(() => {
+                                    this._readyChangedListener?.next(null);
+                                }, 0);
+                            }
+                        },
+                        error: () => { },
+                        complete: () => { },
+                    });
+                }
+                else {
+                    this._childReadyState[id] = true;
+                }
+            }
             return xs.combine(...vdom$)
                 .compose(debounce(1))
                 .map((vdoms) => {
@@ -3267,8 +6657,8 @@ class Component {
                     return acc;
                 }, {});
                 const rootCopy = deepCopyVdom(root);
-                const injected = injectComponents(rootCopy, withIds, componentNames);
-                return injected;
+                const injected = injectComponents(rootCopy, withIds, componentNames, 'r', undefined, this._childReadyState);
+                return processSuspensePost(injected);
             });
         })
             .flatten()
@@ -3375,7 +6765,7 @@ function getComponents(currentElement, componentNames, path = 'r', parentId) {
     }
     return found;
 }
-function injectComponents(currentElement, components, componentNames, path = 'r', parentId) {
+function injectComponents(currentElement, components, componentNames, path = 'r', parentId, readyMap) {
     if (!currentElement)
         return;
     if (currentElement.data?.componentsInjected)
@@ -3391,7 +6781,13 @@ function injectComponents(currentElement, components, componentNames, path = 'r'
     let id = parentId;
     if (isComponent) {
         id = getComponentIdFromElement(currentElement, path, parentId);
-        const component = components[id];
+        let component = components[id];
+        // Annotate the injected VNode with its READY state
+        if (readyMap && id && component && typeof component === 'object' && component.sel) {
+            component.data = component.data || {};
+            component.data.attrs = component.data.attrs || {};
+            component.data.attrs['data-sygnal-ready'] = readyMap[id] !== false ? 'true' : 'false';
+        }
         if (isCollection) {
             currentElement.sel = 'div';
             currentElement.children = Array.isArray(component) ? component : [component];
@@ -3405,7 +6801,7 @@ function injectComponents(currentElement, components, componentNames, path = 'r'
         }
     }
     else if (children.length > 0) {
-        currentElement.children = children.map((child, i) => injectComponents(child, components, componentNames, `${path}.${i}`, id)).flat();
+        currentElement.children = children.map((child, i) => injectComponents(child, components, componentNames, `${path}.${i}`, id, readyMap)).flat();
         return currentElement;
     }
     else {
@@ -3421,6 +6817,189 @@ function getComponentIdFromElement(el, path, parentId) {
     const fullId = `${parentString}${name}::${id}`;
     return fullId;
 }
+function hasNotReadyChild(vnode) {
+    if (!vnode || !vnode.sel)
+        return false;
+    // Check for data-sygnal-ready="false" on injected sub-components
+    if (vnode.data?.attrs?.['data-sygnal-ready'] === 'false')
+        return true;
+    // Check for lazy-loading placeholder (not yet instantiated as a component)
+    if (vnode.data?.attrs?.['data-sygnal-lazy'] === 'loading')
+        return true;
+    // Stop at inner Suspense boundaries — they handle their own children
+    if (vnode.sel === 'suspense')
+        return false;
+    if (Array.isArray(vnode.children)) {
+        for (const child of vnode.children) {
+            if (hasNotReadyChild(child))
+                return true;
+        }
+    }
+    return false;
+}
+function processSuspensePost(vnode) {
+    if (!vnode || !vnode.sel)
+        return vnode;
+    if (vnode.sel === 'suspense') {
+        const props = vnode.data?.props || {};
+        const fallback = props.fallback;
+        const children = vnode.children || [];
+        // Check if any child within this boundary is not ready
+        const isPending = children.some(hasNotReadyChild);
+        if (isPending && fallback) {
+            // Render fallback
+            if (typeof fallback === 'string') {
+                return { sel: 'div', data: { attrs: { 'data-sygnal-suspense': 'pending' } }, children: [{ text: fallback }], text: undefined, elm: undefined, key: undefined };
+            }
+            return { sel: 'div', data: { attrs: { 'data-sygnal-suspense': 'pending' } }, children: [fallback], text: undefined, elm: undefined, key: undefined };
+        }
+        // All children ready or no fallback — render children directly
+        if (children.length === 1)
+            return processSuspensePost(children[0]);
+        return { sel: 'div', data: { attrs: { 'data-sygnal-suspense': 'resolved' } }, children: children.map((c) => processSuspensePost(c)), text: undefined, elm: undefined, key: undefined };
+    }
+    if (vnode.children && vnode.children.length > 0) {
+        vnode.children = vnode.children.map((c) => processSuspensePost(c));
+    }
+    return vnode;
+}
+const portalPatch = init.init(modules);
+function processPortals(vnode) {
+    if (!vnode || !vnode.sel)
+        return vnode;
+    if (vnode.sel === 'portal') {
+        const target = vnode.data?.props?.target;
+        const children = vnode.children || [];
+        return createPortalPlaceholder(target, children);
+    }
+    if (vnode.children && vnode.children.length > 0) {
+        vnode.children = vnode.children.map(processPortals);
+    }
+    return vnode;
+}
+function processTransitions(vnode) {
+    if (!vnode || !vnode.sel)
+        return vnode;
+    if (vnode.sel === 'transition') {
+        const props = vnode.data?.props || {};
+        const name = props.name || 'v';
+        const duration = props.duration;
+        const children = vnode.children || [];
+        const child = children[0];
+        if (!child || !child.sel)
+            return child || vnode;
+        return applyTransitionHooks(processTransitions(child), name, duration);
+    }
+    if (vnode.children && vnode.children.length > 0) {
+        vnode.children = vnode.children.map(processTransitions);
+    }
+    return vnode;
+}
+function applyTransitionHooks(vnode, name, duration) {
+    const existingInsert = vnode.data?.hook?.insert;
+    const existingRemove = vnode.data?.hook?.remove;
+    vnode.data = vnode.data || {};
+    vnode.data.hook = vnode.data.hook || {};
+    vnode.data.hook.insert = (vn) => {
+        if (existingInsert)
+            existingInsert(vn);
+        const el = vn.elm;
+        if (!el || !el.classList)
+            return;
+        el.classList.add(`${name}-enter-from`, `${name}-enter-active`);
+        requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+                el.classList.remove(`${name}-enter-from`);
+                el.classList.add(`${name}-enter-to`);
+                onTransitionEnd(el, duration, () => {
+                    el.classList.remove(`${name}-enter-active`, `${name}-enter-to`);
+                });
+            });
+        });
+    };
+    vnode.data.hook.remove = (vn, rm) => {
+        if (existingRemove)
+            existingRemove(vn, () => { });
+        const el = vn.elm;
+        if (!el || !el.classList) {
+            rm();
+            return;
+        }
+        el.classList.add(`${name}-leave-from`, `${name}-leave-active`);
+        requestAnimationFrame(() => {
+            requestAnimationFrame(() => {
+                el.classList.remove(`${name}-leave-from`);
+                el.classList.add(`${name}-leave-to`);
+                onTransitionEnd(el, duration, () => {
+                    el.classList.remove(`${name}-leave-active`, `${name}-leave-to`);
+                    rm();
+                });
+            });
+        });
+    };
+    return vnode;
+}
+function onTransitionEnd(el, duration, cb) {
+    if (typeof duration === 'number') {
+        setTimeout(cb, duration);
+    }
+    else {
+        const handler = () => {
+            el.removeEventListener('transitionend', handler);
+            cb();
+        };
+        el.addEventListener('transitionend', handler);
+    }
+}
+function createPortalPlaceholder(target, children) {
+    const portalChildren = children || [];
+    return {
+        sel: 'div',
+        data: {
+            style: { display: 'none' },
+            attrs: { 'data-sygnal-portal': target },
+            portalChildren,
+            hook: {
+                insert: (vnode) => {
+                    const container = document.querySelector(target);
+                    if (!container) {
+                        console.warn(`[Portal] Target "${target}" not found in DOM`);
+                        return;
+                    }
+                    const anchor = document.createElement('div');
+                    container.appendChild(anchor);
+                    vnode.data._portalVnode = portalPatch(anchor, {
+                        sel: 'div', data: {}, children: portalChildren,
+                        text: undefined, elm: undefined, key: undefined,
+                    });
+                    vnode.data._portalContainer = container;
+                },
+                postpatch: (oldVnode, newVnode) => {
+                    const prevPortalVnode = oldVnode.data?._portalVnode;
+                    const container = oldVnode.data?._portalContainer;
+                    if (!prevPortalVnode || !container)
+                        return;
+                    const newChildren = newVnode.data?.portalChildren || [];
+                    newVnode.data._portalVnode = portalPatch(prevPortalVnode, {
+                        sel: 'div', data: {}, children: newChildren,
+                        text: undefined, elm: undefined, key: undefined,
+                    });
+                    newVnode.data._portalContainer = container;
+                },
+                destroy: (vnode) => {
+                    const pv = vnode.data?._portalVnode;
+                    if (pv && pv.elm && pv.elm.parentNode) {
+                        pv.elm.parentNode.removeChild(pv.elm);
+                    }
+                },
+            },
+        },
+        children: [],
+        text: undefined,
+        elm: undefined,
+        key: undefined,
+    };
+}
 function deepCopyVdom(obj) {
     if (typeof obj === 'undefined')
         return obj;
@@ -3795,7 +7374,7 @@ function run(app, drivers = {}, options = {}) {
     if (!app.isSygnalComponent) {
         const name = app.name || app.componentName || app.label || 'FUNCTIONAL_COMPONENT';
         const view = app;
-        const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug, } = app;
+        const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, onError, debug, } = app;
         const componentOptions = {
             name,
             view,
@@ -3810,6 +7389,7 @@ function run(app, drivers = {}, options = {}) {
             storeCalculatedInState,
             DOMSourceName,
             stateSourceName,
+            onError,
             debug,
         };
         app = component(componentOptions);
@@ -3982,6 +7562,7 @@ var client = (element) => {
         Wrapped.storeCalculatedInState = Component.storeCalculatedInState;
         Wrapped.DOMSourceName = Component.DOMSourceName;
         Wrapped.stateSourceName = Component.stateSourceName;
+        Wrapped.onError = Component.onError;
         Wrapped.debug = Component.debug;
         Wrapped.componentName = Component.componentName || Component.name;
         const app = run(Wrapped, {}, { mountPoint });