sygnal 2.5.0 → 2.6.0

package/dist/index.cjs.js

@@ -4,33 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var isolate = require('@cycle/isolate');
 var state = require('@cycle/state');
-var xs = require('xstream');
-var dropRepeats = require('xstream/extra/dropRepeats');
-var delay$1 = require('xstream/extra/delay.js');
-var concat = require('xstream/extra/concat.js');
-var debounce$1 = require('xstream/extra/debounce.js');
-var dropRepeats$1 = require('xstream/extra/dropRepeats.js');
+var xs$1 = require('xstream');
 var run$1 = require('@cycle/run');
 var dom = require('@cycle/dom');
-var adapt = require('@cycle/run/lib/adapt');
-var debounce = require('xstream/extra/debounce');
-var throttle = require('xstream/extra/throttle');
-var delay = require('xstream/extra/delay');
-var sampleCombine = require('xstream/extra/sampleCombine');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var isolate__default = /*#__PURE__*/_interopDefaultLegacy(isolate);
-var xs__default = /*#__PURE__*/_interopDefaultLegacy(xs);
-var dropRepeats__default = /*#__PURE__*/_interopDefaultLegacy(dropRepeats);
-var delay__default$1 = /*#__PURE__*/_interopDefaultLegacy(delay$1);
-var concat__default = /*#__PURE__*/_interopDefaultLegacy(concat);
-var debounce__default$1 = /*#__PURE__*/_interopDefaultLegacy(debounce$1);
-var dropRepeats__default$1 = /*#__PURE__*/_interopDefaultLegacy(dropRepeats$1);
-var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
-var throttle__default = /*#__PURE__*/_interopDefaultLegacy(throttle);
-var delay__default = /*#__PURE__*/_interopDefaultLegacy(delay);
-var sampleCombine__default = /*#__PURE__*/_interopDefaultLegacy(sampleCombine);
+var xs__default = /*#__PURE__*/_interopDefaultLegacy(xs$1);
 
 function collection(component, stateLense, opts={}) {
   const {
@@ -54,12 +35,12 @@ function collection(component, stateLense, opts={}) {
           if (combineList.includes(name)) {
             const combined = instances.pickCombine(name);
             if (name === domSourceName && container) {
-              acc.DOM = combined.map(children => {
+              acc[domSourceName] = combined.map(children => {
                 const data = (containerClass) ? { props: { className: containerClass } } : {};
                 return { sel: container, data, children, key, text: undefined, elm: undefined}
               });
             } else {
-              console.warn('Collections without wrapping containers will fail in unpredictable ways when used inside JSX fragments');
+              // console.warn('Collections without wrapping containers will fail in unpredictable ways when used inside JSX fragments')
               acc[name] = combined;
             }
           } else {
@@ -92,6 +73,2665 @@ function collection(component, stateLense, opts={}) {
   return isolate__default["default"](state.makeCollection(collectionOpts), isolateOpts)(sources)
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var dropRepeats$1 = {};
+
+var xstream = {};
+
+var ponyfill$1 = {exports: {}};
+
+var ponyfill = {};
+
+(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));
+
+(function (module) {
+	module.exports = 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();
+};
+
+/* 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 getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
+
+var needsEval = {};
+
+var TypedArray = typeof Uint8Array === 'undefined' ? 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([][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,
+	'%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([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$1 ? 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 ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols$1 ? 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
+};
+
+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) {
+			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);
+
+/* 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');
+	}
+
+	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$2 = 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 && (!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$2.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 });
+xstream.NO_IL = xstream.NO = xstream.MemoryStream = xstream.Stream = void 0;
+var ponyfill_1 = ponyfill$1.exports;
+var globalthis_1 = globalthis;
+var $$observable = ponyfill_1.default(globalthis_1.getPolyfill());
+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,
+};
+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 = /** @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,
+        });
+    };
+    /**
+     * 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;
+}());
+xstream.Stream = Stream;
+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));
+xstream.MemoryStream = MemoryStream;
+var xs = Stream;
+xstream.default = xs;
+
+Object.defineProperty(dropRepeats$1, "__esModule", { value: true });
+dropRepeats$1.DropRepeatsOperator = void 0;
+var index_1$5 = 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;
+}());
+dropRepeats$1.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(isEqual) {
+    if (isEqual === void 0) { isEqual = void 0; }
+    return function dropRepeatsOperator(ins) {
+        return new index_1$5.Stream(new DropRepeatsOperator(ins, isEqual));
+    };
+}
+var _default$5 = dropRepeats$1.default = dropRepeats;
+
 function switchable(factories, name$, initial, opts={}) {
   const {
     switched=['DOM'],
@@ -100,13 +2740,13 @@ function switchable(factories, name$, initial, opts={}) {
   const nameType     = typeof name$;
 
   if (!name$) throw new Error(`Missing 'name$' parameter for switchable()`)
-  if (!(nameType === 'string' || nameType === 'function' || name$ instanceof xs.Stream)) {
+  if (!(nameType === 'string' || nameType === 'function' || name$ instanceof xs$1.Stream)) {
     throw new Error(`Invalid 'name$' parameter for switchable(): expects Stream, String, or Function`)
   }
 
-  if (name$ instanceof xs.Stream) {
+  if (name$ instanceof xs$1.Stream) {
     const withInitial$ = name$
-      .compose(dropRepeats__default["default"]())
+      .compose(_default$5())
       .startWith(initial)
       .remember();
     return sources => _switchable(factories, sources, withInitial$, switched)
@@ -114,11 +2754,11 @@ function switchable(factories, name$, initial, opts={}) {
     const mapFunction = (nameType === 'function' && name$) || (state => state[name$]);
     return sources => {
       const state$ = sources && ((typeof stateSourceName === 'string' && sources[stateSourceName]) || sources.STATE || sources.state).stream;
-      if (!state$ instanceof xs.Stream) throw new Error(`Could not find the state source: ${ stateSourceName }`)
+      if (!state$ instanceof xs$1.Stream) throw new Error(`Could not find the state source: ${ stateSourceName }`)
       const _name$ = state$
         .map(mapFunction)
         .filter(name => typeof name === 'string')
-        .compose(dropRepeats__default["default"]())
+        .compose(_default$5())
         .startWith(initial)
         .remember();
       return _switchable(factories, sources, _name$, switched, stateSourceName)
@@ -179,6 +2819,302 @@ function _switchable (factories, sources, name$, switched=['DOM'], stateSourceNa
   return switchedSinks
 }
 
+var delay$1 = {};
+
+Object.defineProperty(delay$1, "__esModule", { value: true });
+var index_1$4 = 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(period) {
+    return function delayOperator(ins) {
+        return new index_1$4.Stream(new DelayOperator(period, ins));
+    };
+}
+var _default$4 = delay$1.default = delay;
+
+var concat$1 = {};
+
+Object.defineProperty(concat$1, "__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() {
+    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$1.default = concat;
+
+var debounce$1 = {};
+
+Object.defineProperty(debounce$1, "__esModule", { value: true });
+var index_1$2 = 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$2.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$2.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$2.NO)
+            u._n(this.t);
+        this.t = index_1$2.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(period) {
+    return function debounceOperator(ins) {
+        return new index_1$2.Stream(new DebounceOperator(period, ins));
+    };
+}
+var _default$2 = debounce$1.default = debounce;
+
 // import syntax has bugs for xstream in Node context
 // this attempts to normalize to work in both Node and browser
 // if (!xs.never && xs.default && xs.default.never) {
@@ -324,6 +3260,7 @@ class Component {
     this.initSendResponse$();
     this.initChildren$();
     this.initSubComponentSink$();
+    this.initSubComponentsRendered$();
     this.initVdom$();
     this.initSinks();
   }
@@ -338,7 +3275,7 @@ class Component {
 
     this.intent$ = this.intent(this.sources);
 
-    if (!(this.intent$ instanceof xs.Stream) && (typeof this.intent$ != 'object')) {
+    if (!(this.intent$ instanceof xs$1.Stream) && (typeof this.intent$ != 'object')) {
       throw new Error('Intent must return either an action$ stream or map of event streams')
     }
   }
@@ -352,7 +3289,7 @@ class Component {
     }
 
     let runner;
-    if (this.intent$ instanceof xs.Stream) {
+    if (this.intent$ instanceof xs$1.Stream) {
       runner = this.intent$;
     } else {
       const mapped = Object.entries(this.intent$)
@@ -360,9 +3297,9 @@ class Component {
       runner = xs__default["default"].merge(xs__default["default"].never(), ...mapped);
     }
 
-    const action$  = ((runner instanceof xs.Stream) ? runner : (runner.apply && runner(this.sources) || xs__default["default"].never()));
-    const wrapped$ = concat__default["default"](xs__default["default"].of({ type: BOOTSTRAP_ACTION }), action$)
-      .compose(delay__default$1["default"](10));
+    const action$  = ((runner instanceof xs$1.Stream) ? runner : (runner.apply && runner(this.sources) || xs__default["default"].never()));
+    const wrapped$ = _default$3(xs__default["default"].of({ type: BOOTSTRAP_ACTION }), action$)
+      .compose(_default$4(10));
 
     let initialApiData;
     if (requestSource && typeof requestSource.select == 'function') {
@@ -405,7 +3342,7 @@ class Component {
         const actionString = (actionType === 'function') ? '[ FUNCTION ]' : `< ${ action } >`;
         console.log(`[${ this.name }] Adding ${ this.requestSourceName } route:`, _method.toUpperCase(), `'${ route }' <${ actionString }>`);
         const route$ = router$[_method](route)
-          .compose(dropRepeats__default$1["default"]((a, b) => a.id == b.id))
+          .compose(_default$5((a, b) => a.id == b.id))
           .map(req => {
             if (!req || !req.id) {
               throw new Error(`No id found in request: ${ routeString }`)
@@ -491,7 +3428,7 @@ class Component {
     }
 
     const initial  = { type: INITIALIZE_ACTION, data: this.initialState };
-    const shimmed$ = this.initialState ? concat__default["default"](xs__default["default"].of(initial), this.action$).compose(delay__default$1["default"](0)) : this.action$;
+    const shimmed$ = this.initialState ? _default$3(xs__default["default"].of(initial), this.action$).compose(_default$4(0)) : this.action$;
     const onState  = this.makeOnAction(shimmed$, true, this.action$);
     const onNormal = this.makeOnAction(this.action$, false, this.action$);
 
@@ -593,321 +3530,67 @@ class Component {
 
   initChildren$() {
     const initial = this.sourceNames.reduce((acc, name) => {
-      if (name == this.DOMSourceName) {
-        acc[name] = {};
-      } else {
-        acc[name] = [];
-      }
-      return acc
-    }, {});
-
-    this.children$ = Object.entries(this.children).reduce((acc, [childName, childFactory]) => {
-      const child$ = childFactory(this.sources);
-      this.sourceNames.forEach(source => {
-        if (source == this.DOMSourceName) {
-          acc[source][childName] = child$[source];
-        } else {
-          acc[source].push(child$[source]);
-        }
-      });
-      return acc
-    }, initial);
-  }
-
-  initSubComponentSink$() {
-    const subComponentSink$ = xs__default["default"].create({
-      start: listener => {
-        this.newSubComponentSinks = listener.next.bind(listener);
-      },
-      stop: _ => {
-
-      }
-    });
-    subComponentSink$.subscribe({ next: _ => _ });
-    this.subComponentSink$ = subComponentSink$.filter(sinks => Object.keys(sinks).length > 0);
-  }
-
-  initVdom$() {
-    if (typeof this.view != 'function') {
-      this.vdom$ = xs__default["default"].of(null);
-      return
-    }
-
-    const state$1        = this.sources[this.stateSourceName];
-    const renderParams = { ...this.children$[this.DOMSourceName] };
-
-    const enhancedState = state$1 && state$1.isolateSource(state$1, { get: state => this.addCalculated(state) });
-    const stateStream   = (enhancedState && enhancedState.stream) || xs__default["default"].never();
-
-    renderParams.state                 = stateStream;
-    renderParams[this.stateSourceName] = stateStream;
-
-    if (this.sources.props$) {
-      renderParams.props = this.sources.props$;
-    }
-
-    if (this.sources.children$) {
-      renderParams.children = this.sources.children$;
-    }
-
-    const pulled = Object.entries(renderParams).reduce((acc, [name, stream]) => {
-      acc.names.push(name);
-      acc.streams.push(stream);
-      return acc
-    }, {names: [], streams: []});
-
-    const merged = xs__default["default"].combine(...pulled.streams);
-
-    const throttled = merged
-      .compose(debounce__default$1["default"](5))
-      .map(arr => {
-        return pulled.names.reduce((acc, name, index) => {
-          acc[name] = arr[index];
-          return acc
-        }, {})
-      });
-
-    const componentNames = Object.keys(this.components);
-
-    const subComponentRenderedProxy$ = xs__default["default"].create();
-    const vDom$ = throttled.map((params) => params).map(this.view).map(vDom => vDom || { sel: 'div', data: {}, children: [] });
-
-
-    const componentInstances$ = vDom$
-      .fold((previousComponents, vDom) => {
-        const foundComponents = getComponents(vDom, componentNames);
-        const entries = Object.entries(foundComponents);
-
-        const rootEntry = { '::ROOT::': vDom };
-
-        if (entries.length === 0) {
-          return rootEntry
-        }
-
-        const sinkArrsByType = {};
-
-        const newComponents =  entries.reduce((acc, [id, el]) => {
-          const componentName = el.sel;
-          const data  = el.data;
-          const props = data.props || {};
-          const children = el.children || [];
-          const isCollection = data.isCollection || false;
-          const isSwitchable = data.isSwitchable || false;
-
-          if (previousComponents[id]) {
-            const entry = previousComponents[id];
-            acc[id] = entry;
-            entry.props$.shamefullySendNext(props);
-            entry.children$.shamefullySendNext(children);
-            return acc
-          }
-
-          const factory   = componentName === 'sygnal-factory' ? props.sygnalFactory : (this.components[componentName] || props.sygnalFactory);
-          if (!factory && !isCollection && !isSwitchable) {
-            if (componentName === 'sygnal-factory') throw new Error(`Component not found on element with Capitalized selector and nameless function: JSX transpilation replaces selectors starting with upper case letters with functions in-scope with the same name, Sygnal cannot see the name of the resulting component.`)
-            throw new Error(`Component not found: ${ componentName }`)
-          }
-
-          const props$    = xs__default["default"].create().startWith(props);
-          const children$ = xs__default["default"].create().startWith(children);
-          let stateSource = new state.StateSource(this.sources[this.stateSourceName].stream.startWith(this.currentState));
-          let sink$;
-          let preventStateUpdates = true;
-
-          if (isCollection) {
-            let field, lense;
-
-            const stateGetter = state => {
-              const arr = state[field];
-              if (typeof arr === 'undefined') return
-              if (!Array.isArray(arr)) {
-                const label = typeof data.props.of === 'string' ? data.props.of : 'components';
-                console.warn(`Collection of ${ label } does not have a valid array in the 'for' property: expects either an array or a string of the name of an array property on the state`);
-                return []
-              }
-              return arr
-            };
-
-            if (typeof props.for === 'undefined') {
-              lense = {
-                get: state => {
-                  if (!Array.isArray(state)) {
-                    console.warn(`Collection sub-component of ${ this.name } has no 'for' attribute and the parent state is not an array: Provide a 'for' attribute with either an array or the name of a state property containing an array`);
-                    return []
-                  }
-                  return state
-                },
-                set: (oldState, newState) => newState
-              };
-              preventStateUpdates = false;
-            } else if (typeof props.for === 'string') {
-              field  = props.for;
-              lense = {
-                get: stateGetter,
-                set: (state, arr) => {
-                  if (this.calculated && field in this.calculated) {
-                    console.warn(`Collection sub-component of ${ this.name } attempted to update state on a calculated field '${ field }': Update ignored`);
-                    return state
-                  }
-                  return { ...state, [field]: arr }
-                }
-              };
-              preventStateUpdates = false;
-            } else {
-              field  = 'for';
-              stateSource = new state.StateSource(props$.remember());
-              lense = {
-                get: stateGetter,
-                set: (state, arr) => state
-              };
-            }
-            const sources   = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$ };
-            const factory   = typeof data.props.of === 'function' ? data.props.of : this.components[data.props.of];
-            sink$ = collection(factory, lense, { container: null })(sources);
-            if (typeof sink$ !== 'object') {
-              throw new Error('Invalid sinks returned from component factory of collection element')
-            }
-          } else if (isSwitchable) {
-            const stateField = data.props.state;
-            let isolateSwitchable = false;
-            let lense;
-            if (typeof stateField === 'string') {
-              isolateSwitchable = true;
-              lense = {
-                get: state => {
-                  return state[stateField]
-                },
-                set: (oldState, newState) => {
-                  if (this.calculated && stateField in this.calculated) {
-                    console.warn(`Switchable sub-component of ${ this.name } attempted to update state on a calculated field '${ stateField }': Update ignored`);
-                    return oldState
-                  }
-                  return { ...oldState, [stateField]: newState }
-                }
-              };
-              preventStateUpdates = false;
-            } else if (typeof stateField === 'undefined') {
-              isolateSwitchable = true;
-              lense = {
-                get: state => state,
-                set: (oldState, newState) => newState
-              };
-              preventStateUpdates = false;
-            } else if (typeof stateField === 'object') {
-              stateSource = new state.StateSource(props$.map(props => props.state));
-            } else {
-              throw new Error(`Invalid state provided to collection sub-component of ${ this.name }: Expecting string, object, or none, but found ${ typeof stateField }`)
-            }
-            const switchableComponents = data.props.of;
-            const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$ };
-            if (isolateSwitchable) {
-              sink$ = isolate__default["default"](switchable(switchableComponents, props$.map(props => props.current)), { [this.stateSourceName]: lense })(sources);
-            } else {
-              sink$ = switchable(switchableComponents, props$.map(props => props.current))(sources);
-            }
-            if (typeof sink$ !== 'object') {
-              throw new Error('Invalid sinks returned from component factory of switchable element')
-            }
-          } else {
-            const { state: stateProp, sygnalFactory, id, ...sanitizedProps } = props;
-            if (typeof stateProp === 'undefined' && (typeof sanitizedProps !== 'object' || Object.keys(sanitizedProps).length === 0)) {
-              const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$: xs__default["default"].never().startWith(null), children$ };
-              sink$ = factory(sources);
-              preventStateUpdates = false;
-            } else {
-              const lense = (props) => {
-                const state = props.state;
-                if (typeof state === 'undefined') return props
-                if (typeof state !== 'object')    return state
-
-                const copy = { ...props };
-                delete copy.state;
-                return { ...copy, ...state }
-              };
-              stateSource = new state.StateSource(props$.map(lense));
-              const sources   = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$ };
-              sink$ = factory(sources);
-            }
-            if (typeof sink$ !== 'object') {
-              const name = componentName === 'sygnal-factory' ? 'custom element' : componentName;
-              throw new Error('Invalid sinks returned from component factory:', name)
-            }
-          }
-
-          if (preventStateUpdates) {
-            const originalStateSink = sink$[this.stateSourceName];
-            sink$[this.stateSourceName] = originalStateSink.filter(state => {
-              console.warn('State update attempt from component with inderect link to state: Components with state set through HTML properties/attributes cannot update application state directly');
-              return false
-            });
-          }
-
-          const originalDOMSink = sink$[this.DOMSourceName].remember();
-          const repeatChecker = (a, b) => {
-            const aa = JSON.stringify(a);
-            const bb = JSON.stringify(b);
-            return aa === bb
-          };
-          sink$[this.DOMSourceName] = stateSource.stream.compose(dropRepeats__default$1["default"](repeatChecker)).map(state => {
-            subComponentRenderedProxy$.shamefullySendNext(null);
-            return originalDOMSink
-          }).compose(debounce__default$1["default"](10)).flatten().remember();
-          acc[id] = { sink$, props$, children$ };
-
-          Object.entries(sink$).map(([name, stream]) => {
-            sinkArrsByType[name] ||= [];
-            if (name !== this.DOMSourceName) sinkArrsByType[name].push(stream);
-          });
-
-          return acc
-        }, rootEntry);
-
-        const mergedSinksByType = Object.entries(sinkArrsByType).reduce((acc, [name, streamArr]) => {
-          if (streamArr.length === 0) return acc
-          acc[name] = streamArr.length === 1 ? streamArr[0] : xs__default["default"].merge(...streamArr);
-          return acc
-        }, {});
+      if (name == this.DOMSourceName) {
+        acc[name] = {};
+      } else {
+        acc[name] = [];
+      }
+      return acc
+    }, {});
 
-        this.newSubComponentSinks(mergedSinksByType);
+    this.children$ = Object.entries(this.children).reduce((acc, [childName, childFactory]) => {
+      const child$ = childFactory(this.sources);
+      this.sourceNames.forEach(source => {
+        if (source == this.DOMSourceName) {
+          acc[source][childName] = child$[source];
+        } else {
+          acc[source].push(child$[source]);
+        }
+      });
+      return acc
+    }, initial);
+  }
 
-        // subComponentRenderedProxy$.shamefullySendNext(null)
-        return newComponents
-      }, {});
+  initSubComponentSink$() {
+    const subComponentSink$ = xs__default["default"].create({
+      start: listener => {
+        this.newSubComponentSinks = listener.next.bind(listener);
+      },
+      stop: _ => {
 
+      }
+    });
+    subComponentSink$.subscribe({ next: _ => _ });
+    this.subComponentSink$ = subComponentSink$.filter(sinks => Object.keys(sinks).length > 0);
+  }
 
-    this.vdom$ = xs__default["default"].combine(subComponentRenderedProxy$.startWith(null), componentInstances$).map(([_, components]) => {
+  initSubComponentsRendered$() {
+    const stream = xs__default["default"].create({
+      start: (listener) => {
+        this.subComponentsRendered = listener.next.bind(listener);
+      },
+      stop: _ => {
 
-        const root  = components['::ROOT::'];
-        let ids = [];
-        const entries = Object.entries(components).filter(([id]) => id !== '::ROOT::');
+      }
+    });
+    this.subComponentsRendered$ = stream.startWith(null);
+  }
 
-        if (entries.length === 0) {
-          return xs__default["default"].of(root)
-        }
+  initVdom$() {
+    if (typeof this.view != 'function') {
+      this.vdom$ = xs__default["default"].of(null);
+      return
+    }
 
-        const vdom$ = entries
-          .map(([id, val]) => {
-            ids.push(id);
-            return val.sink$[this.DOMSourceName].startWith(undefined)
-          });
+    const renderParameters$ = this.collectRenderParameters();
 
-        if (vdom$.length === 0) return xs__default["default"].of(root)
+    this.vdom$ = renderParameters$
+      .map(this.view)
+      .map(vDom => vDom || { sel: 'div', data: {}, children: [] })
+      .compose(this.instantiateSubComponents.bind(this))
+      .filter(val => val !== undefined)
+      .compose(this.renderVdom.bind(this));
 
-        return xs__default["default"].combine(...vdom$).compose(debounce__default$1["default"](5)).map(vdoms => {
-          const withIds = vdoms.reduce((acc, vdom, index) => {
-            acc[ids[index]] = vdom;
-            return acc
-          }, {});
-          const rootCopy = deepCopyVdom(root);
-          const injected = injectComponents(rootCopy, withIds, componentNames);
-          return injected
-        })
-      })
-      .flatten()
-      .filter(val => !!val)
-      .compose(debounce__default$1["default"](5))
-      .remember()
-      .compose(this.log('View Rendered'));
   }
 
   initSinks() {
@@ -1010,6 +3693,335 @@ class Component {
     return copy
   }
 
+  collectRenderParameters() {
+    const state        = this.sources[this.stateSourceName];
+    const renderParams = { ...this.children$[this.DOMSourceName] };
+
+    const enhancedState = state && state.isolateSource(state, { get: state => this.addCalculated(state) });
+    const stateStream   = (enhancedState && enhancedState.stream) || xs__default["default"].never();
+
+    renderParams.state                 = stateStream;
+    renderParams[this.stateSourceName] = stateStream;
+
+    if (this.sources.props$) {
+      renderParams.props = this.sources.props$;
+    }
+
+    if (this.sources.children$) {
+      renderParams.children = this.sources.children$;
+    }
+
+    const names   = [];
+    const streams = [];
+
+    Object.entries(renderParams).forEach(([name, stream]) => {
+      names.push(name);
+      streams.push(stream);
+    });
+
+    const combined = xs__default["default"].combine(...streams)
+      // map the streams from an array back to an object with the render parameter names as the keys
+      .map(arr => {
+        return names.reduce((acc, name, index) => {
+          acc[name] = arr[index];
+          return acc
+        }, {})
+      });
+
+    return combined
+  }
+
+  instantiateSubComponents(vDom$) {
+    return vDom$.fold((previousComponents, vDom) => {
+      const componentNames  = Object.keys(this.components);
+      const foundComponents = getComponents(vDom, componentNames);
+      const entries         = Object.entries(foundComponents);
+
+      const rootEntry = { '::ROOT::': vDom };
+
+      if (entries.length === 0) {
+        return rootEntry
+      }
+
+      const sinkArrsByType = {};
+
+      const newComponents =  entries.reduce((acc, [id, el]) => {
+        const data     = el.data;
+        const props    = data.props  || {};
+        const children = el.children || [];
+
+        const isCollection = data.isCollection || false;
+        const isSwitchable = data.isSwitchable || false;
+
+        if (previousComponents[id]) {
+          const entry = previousComponents[id];
+          acc[id] = entry;
+          entry.props$.shamefullySendNext(props);
+          entry.children$.shamefullySendNext(children);
+          return acc
+        }
+
+        const props$    = xs__default["default"].create().startWith(props);
+        const children$ = xs__default["default"].create().startWith(children);
+
+        let instantiator;
+
+        if (isCollection) {
+          instantiator = this.instantiateCollection.bind(this);
+        } else if (isSwitchable) {
+          instantiator = this.instantiateSwitchable.bind(this);
+        } else {
+          instantiator = this.instantiateCustomComponent.bind(this);
+        }
+
+        const { sink$, preventStateUpdates } = instantiator(el, props$, children$);
+
+        if (preventStateUpdates) {
+          const originalStateSink = sink$[this.stateSourceName];
+          sink$[this.stateSourceName] = originalStateSink.filter(state => {
+            console.warn('State update attempt from component with inderect link to state: Components with state set through HTML properties/attributes cannot update application state directly');
+            return false
+          });
+        }
+
+        sink$[this.DOMSourceName] = this.makeCoordinatedSubComponentDomSink(sink$[this.DOMSourceName]);
+
+        acc[id] = { sink$, props$, children$ };
+
+        Object.entries(sink$).map(([name, stream]) => {
+          sinkArrsByType[name] ||= [];
+          if (name !== this.DOMSourceName) sinkArrsByType[name].push(stream);
+        });
+
+        return acc
+      }, rootEntry);
+
+      const mergedSinksByType = Object.entries(sinkArrsByType).reduce((acc, [name, streamArr]) => {
+        if (streamArr.length === 0) return acc
+        acc[name] = streamArr.length === 1 ? streamArr[0] : xs__default["default"].merge(...streamArr);
+        return acc
+      }, {});
+
+      this.newSubComponentSinks(mergedSinksByType);
+
+      return newComponents
+    }, {})
+  }
+
+  makeCoordinatedSubComponentDomSink(domSink$) {
+    const remembered$   = domSink$.remember();
+    const repeatChecker = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+    const coordinated = this.sources[this.stateSourceName].stream
+      .compose(_default$5(repeatChecker))
+      .map(state => remembered$)
+      .compose(_default$2(10))
+      .flatten()
+      .debug(_ => this.subComponentsRendered())
+      .remember();
+
+    return coordinated
+  }
+
+  instantiateCollection(el, props$, children$) {
+    const data      = el.data;
+    const props     = data.props || {};
+    el.children || [];
+    let stateSource = new state.StateSource(this.sources[this.stateSourceName].stream.startWith(this.currentState));
+
+    let preventStateUpdates = false;
+    let sink$, field, lense;
+
+    const stateGetter = state => {
+      const arr = state[field];
+      if (typeof arr === 'undefined') return
+      if (!Array.isArray(arr)) {
+        const label = typeof props.of === 'string' ? props.of : 'components';
+        console.warn(`Collection of ${ label } does not have a valid array in the 'for' property: expects either an array or a string of the name of an array property on the state`);
+        return []
+      }
+      return arr
+    };
+
+    if (typeof props.for === 'undefined') {
+      lense = {
+        get: state => {
+          if (!Array.isArray(state)) {
+            console.warn(`Collection sub-component of ${ this.name } has no 'for' attribute and the parent state is not an array: Provide a 'for' attribute with either an array or the name of a state property containing an array`);
+            return []
+          }
+          return state
+        },
+        set: (oldState, newState) => newState
+      };
+    } else if (typeof props.for === 'string') {
+      field  = props.for;
+      lense = {
+        get: stateGetter,
+        set: (state, arr) => {
+          if (this.calculated && field in this.calculated) {
+            console.warn(`Collection sub-component of ${ this.name } attempted to update state on a calculated field '${ field }': Update ignored`);
+            return state
+          }
+          return { ...state, [field]: arr }
+        }
+      };
+    } else {
+      field  = 'for';
+      stateSource = new state.StateSource(props$.remember());
+      lense = {
+        get: stateGetter,
+        set: (state, arr) => state
+      };
+      preventStateUpdates = true;
+    }
+    const sources   = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$ };
+    const factory   = typeof props.of === 'function' ? props.of : this.components[props.of];
+    sink$ = collection(factory, lense, { container: null })(sources);
+    if (typeof sink$ !== 'object') {
+      throw new Error('Invalid sinks returned from component factory of collection element')
+    }
+    return { sink$, preventStateUpdates }
+  }
+
+  instantiateSwitchable(el, props$, children$) {
+    const data      = el.data;
+    const props     = data.props  || {};
+    el.children || [];
+    let stateSource = new state.StateSource(this.sources[this.stateSourceName].stream.startWith(this.currentState));
+
+    const stateField        = props.state;
+    let preventStateUpdates = false;
+    let isolateSwitchable   = false;
+    let sink$, lense;
+
+    if (typeof stateField === 'string') {
+      isolateSwitchable = true;
+      lense = {
+        get: state => {
+          return state[stateField]
+        },
+        set: (oldState, newState) => {
+          if (this.calculated && stateField in this.calculated) {
+            console.warn(`Switchable sub-component of ${ this.name } attempted to update state on a calculated field '${ stateField }': Update ignored`);
+            return oldState
+          }
+          return { ...oldState, [stateField]: newState }
+        }
+      };
+      preventStateUpdates = false;
+    } else if (typeof stateField === 'undefined') {
+      isolateSwitchable = true;
+      lense = {
+        get: state => state,
+        set: (oldState, newState) => newState
+      };
+      preventStateUpdates = false;
+    } else if (typeof stateField === 'object') {
+      stateSource = new state.StateSource(props$.map(props => props.state));
+    } else {
+      throw new Error(`Invalid state provided to collection sub-component of ${ this.name }: Expecting string, object, or none, but found ${ typeof stateField }`)
+    }
+
+    const switchableComponents = data.props.of;
+    const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$ };
+    if (isolateSwitchable) {
+      sink$ = isolate__default["default"](switchable(switchableComponents, props$.map(props => props.current)), { [this.stateSourceName]: lense })(sources);
+    } else {
+      sink$ = switchable(switchableComponents, props$.map(props => props.current))(sources);
+    }
+
+    if (typeof sink$ !== 'object') {
+      throw new Error('Invalid sinks returned from component factory of switchable element')
+    }
+
+    return { sink$, preventStateUpdates }
+  }
+
+  instantiateCustomComponent(el, props$, children$) {
+    const componentName = el.sel;
+    const data      = el.data;
+    const props     = data.props  || {};
+    el.children || [];
+    let stateSource = new state.StateSource(this.sources[this.stateSourceName].stream.startWith(this.currentState));
+
+    const factory   = componentName === 'sygnal-factory' ? props.sygnalFactory : (this.components[componentName] || props.sygnalFactory);
+    if (!factory && !isCollection && !isSwitchable) {
+      if (componentName === 'sygnal-factory') throw new Error(`Component not found on element with Capitalized selector and nameless function: JSX transpilation replaces selectors starting with upper case letters with functions in-scope with the same name, Sygnal cannot see the name of the resulting component.`)
+      throw new Error(`Component not found: ${ componentName }`)
+    }
+
+    let preventStateUpdates = false;
+    let sink$;
+
+    const { state: stateProp, sygnalFactory, id, ...sanitizedProps } = props;
+    if (typeof stateProp === 'undefined' && (typeof sanitizedProps !== 'object' || Object.keys(sanitizedProps).length === 0)) {
+      const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$: xs__default["default"].never().startWith(null), children$ };
+      sink$ = factory(sources);
+      preventStateUpdates = false;
+    } else {
+      const lense = (props) => {
+        const state = props.state;
+        if (typeof state === 'undefined') return props
+        if (typeof state !== 'object')    return state
+
+        const copy = { ...props };
+        delete copy.state;
+        return { ...copy, ...state }
+      };
+      stateSource = new state.StateSource(props$.map(lense));
+      const sources   = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$ };
+      sink$ = factory(sources);
+    }
+
+    if (typeof sink$ !== 'object') {
+      const name = componentName === 'sygnal-factory' ? 'custom element' : componentName;
+      throw new Error('Invalid sinks returned from component factory:', name)
+    }
+
+    return { sink$, preventStateUpdates }
+  }
+
+  renderVdom(componentInstances$) {
+    return xs__default["default"].combine(this.subComponentsRendered$, componentInstances$)
+      .compose(_default$2(5))
+      .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__default["default"].of(root)
+        }
+
+        const ids = [];
+        const vdom$ = entries
+          .map(([id, val]) => {
+            ids.push(id);
+            return val.sink$[this.DOMSourceName].startWith(undefined)
+          });
+
+        if (vdom$.length === 0) return xs__default["default"].of(root)
+
+        return xs__default["default"].combine(...vdom$)
+          .compose(_default$2(10))
+          .map(vdoms => {
+            const withIds = vdoms.reduce((acc, vdom, index) => {
+              acc[ids[index]] = vdom;
+              return acc
+            }, {});
+            const rootCopy = deepCopyVdom(root);
+            const injected = injectComponents(rootCopy, withIds, componentNames);
+            return injected
+          })
+      })
+      .flatten()
+      .filter(val => !!val)
+      .remember()
+      .compose(this.log('View Rendered'))
+  }
+
 }
 
 
@@ -1179,6 +4191,34 @@ function processForm(form, options={}) {
   })
 }
 
+var adapt$1 = {};
+
+Object.defineProperty(adapt$1, "__esModule", { value: true });
+function getGlobal() {
+    var globalObj;
+    if (typeof window !== 'undefined') {
+        globalObj = window;
+    }
+    else if (typeof commonjsGlobal !== 'undefined') {
+        globalObj = commonjsGlobal;
+    }
+    else {
+        globalObj = this;
+    }
+    globalObj.Cyclejs = globalObj.Cyclejs || {};
+    globalObj = globalObj.Cyclejs;
+    globalObj.adaptStream = globalObj.adaptStream || (function (x) { return x; });
+    return globalObj;
+}
+function setAdapt(f) {
+    getGlobal().adaptStream = f;
+}
+adapt$1.setAdapt = setAdapt;
+function adapt(stream) {
+    return getGlobal().adaptStream(stream);
+}
+var adapt_2 = adapt$1.adapt = adapt;
+
 function eventBusDriver(out$) {
   const events = new EventTarget();
 
@@ -1202,7 +4242,7 @@ function eventBusDriver(out$) {
         stop: _ => events.removeEventListener('data', cb)
       });
 
-      return adapt.adapt(in$)
+      return adapt_2(in$)
     }
   }
 }
@@ -1312,37 +4352,306 @@ function classes_processObject(obj) {
   return ret
 }
 
+var throttle$1 = {};
+
+Object.defineProperty(throttle$1, "__esModule", { value: true });
+var index_1$1 = xstream;
+var ThrottleOperator = /** @class */ (function () {
+    function ThrottleOperator(dt, ins) {
+        this.dt = dt;
+        this.ins = ins;
+        this.type = 'throttle';
+        this.out = null;
+        this.id = null;
+    }
+    ThrottleOperator.prototype._start = function (out) {
+        this.out = out;
+        this.ins._add(this);
+    };
+    ThrottleOperator.prototype._stop = function () {
+        this.ins._remove(this);
+        this.out = null;
+        this.id = null;
+    };
+    ThrottleOperator.prototype.clearInterval = function () {
+        var id = this.id;
+        if (id !== null) {
+            clearInterval(id);
+        }
+        this.id = null;
+    };
+    ThrottleOperator.prototype._n = function (t) {
+        var _this = this;
+        var u = this.out;
+        if (!u)
+            return;
+        if (this.id)
+            return;
+        u._n(t);
+        this.id = setInterval(function () {
+            _this.clearInterval();
+        }, this.dt);
+    };
+    ThrottleOperator.prototype._e = function (err) {
+        var u = this.out;
+        if (!u)
+            return;
+        this.clearInterval();
+        u._e(err);
+    };
+    ThrottleOperator.prototype._c = function () {
+        var u = this.out;
+        if (!u)
+            return;
+        this.clearInterval();
+        u._c();
+    };
+    return ThrottleOperator;
+}());
+/**
+ * Emits event and drops subsequent events until a certain amount of silence has passed.
+ *
+ * Marble diagram:
+ *
+ * ```text
+ * --1-2-----3--4----5|
+ *     throttle(60)
+ * --1-------3-------5-|
+ * ```
+ *
+ * Example:
+ *
+ * ```js
+ * import fromDiagram from 'xstream/extra/fromDiagram'
+ * import throttle from 'xstream/extra/throttle'
+ *
+ * const stream = fromDiagram('--1-2-----3--4----5|')
+ *  .compose(throttle(60))
+ *
+ * stream.addListener({
+ *   next: i => console.log(i),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('completed')
+ * })
+ * ```
+ *
+ * ```text
+ * > 1
+ * > 3
+ * > 5
+ * > completed
+ * ```
+ *
+ * @param {number} period The amount of silence required in milliseconds.
+ * @return {Stream}
+ */
+function throttle(period) {
+    return function throttleOperator(ins) {
+        return new index_1$1.Stream(new ThrottleOperator(period, ins));
+    };
+}
+var _default$1 = throttle$1.default = throttle;
+
+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 = 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.Stream(new SampleCombineOperator(sampler, streams));
+    };
+};
+var _default = sampleCombine$1.default = sampleCombine;
+
 Object.defineProperty(exports, 'xs', {
   enumerable: true,
   get: function () { return xs__default["default"]; }
 });
-Object.defineProperty(exports, 'dropRepeats', {
-  enumerable: true,
-  get: function () { return dropRepeats__default["default"]; }
-});
-Object.defineProperty(exports, 'debounce', {
-  enumerable: true,
-  get: function () { return debounce__default["default"]; }
-});
-Object.defineProperty(exports, 'throttle', {
-  enumerable: true,
-  get: function () { return throttle__default["default"]; }
-});
-Object.defineProperty(exports, 'delay', {
-  enumerable: true,
-  get: function () { return delay__default["default"]; }
-});
-Object.defineProperty(exports, 'sampleCombine', {
-  enumerable: true,
-  get: function () { return sampleCombine__default["default"]; }
-});
 exports.ABORT = ABORT;
 exports.classes = classes;
 exports.collection = collection;
 exports.component = component;
+exports.debounce = _default$2;
+exports.delay = _default$4;
+exports.dropRepeats = _default$5;
 exports.processForm = processForm;
 exports.run = run;
+exports.sampleCombine = _default;
 exports.switchable = switchable;
+exports.throttle = _default$1;
 Object.keys(dom).forEach(function (k) {
   if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
     enumerable: true,