sygnal 2.3.0 → 2.6.0

package/dist/index.esm.js

@@ -0,0 +1,4632 @@
+import isolate from '@cycle/isolate';
+import { makeCollection, StateSource, withState } from '@cycle/state';
+import xs$1, { Stream as Stream$1 } from 'xstream';
+export { default as xs } from 'xstream';
+import { run as run$1 } from '@cycle/run';
+import { makeDOMDriver } from '@cycle/dom';
+export * from '@cycle/dom';
+
+function collection(component, stateLense, opts={}) {
+  const {
+    combineList     = ['DOM'],
+    globalList      = ['EVENTS'],
+    stateSourceName = 'STATE',
+    domSourceName   = 'DOM',
+    container       = 'div',
+    containerClass
+  } = opts;
+
+  return (sources) => {
+    const key = Date.now();
+    const collectionOpts = {
+      item:         component,
+      itemKey:      (state, ind) => typeof state.id !== 'undefined' ? state.id : ind,
+      itemScope:    key => key,
+      channel:      stateSourceName,
+      collectSinks: instances => {
+        return Object.entries(sources).reduce((acc, [name, stream]) => {
+          if (combineList.includes(name)) {
+            const combined = instances.pickCombine(name);
+            if (name === domSourceName && container) {
+              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')
+              acc[name] = combined;
+            }
+          } else {
+            acc[name] = instances.pickMerge(name);
+          }
+          return acc
+        }, {})
+      }
+    };
+
+    const isolateOpts = {[stateSourceName]: stateLense};
+
+    globalList.forEach(global => isolateOpts[global] = null);
+    combineList.forEach(combine => isolateOpts[combine] = null);
+
+    return makeIsolatedCollection(collectionOpts, isolateOpts, sources)
+  }
+}
+
+/**
+ * instantiate a cycle collection and isolate
+ * (makes the code for doing isolated collections more readable)
+ *
+ * @param {Object} collectionOpts options for the makeCollection function (see cycle/state documentation)
+ * @param {String|Object} isolateOpts options for the isolate function (see cycle/isolate documentation)
+ * @param {Object} sources object of cycle style sources to use for the created collection
+ * @return {Object} collection of component sinks
+ */
+ function makeIsolatedCollection (collectionOpts, isolateOpts, sources) {
+  return isolate(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'],
+    stateSourceName='STATE'
+  } = opts;
+  const nameType     = typeof name$;
+
+  if (!name$) throw new Error(`Missing 'name$' parameter for switchable()`)
+  if (!(nameType === 'string' || nameType === 'function' || name$ instanceof Stream$1)) {
+    throw new Error(`Invalid 'name$' parameter for switchable(): expects Stream, String, or Function`)
+  }
+
+  if (name$ instanceof Stream$1) {
+    const withInitial$ = name$
+      .compose(_default$5())
+      .startWith(initial)
+      .remember();
+    return sources => _switchable(factories, sources, withInitial$, switched)
+  } else {
+    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 Stream$1) throw new Error(`Could not find the state source: ${ stateSourceName }`)
+      const _name$ = state$
+        .map(mapFunction)
+        .filter(name => typeof name === 'string')
+        .compose(_default$5())
+        .startWith(initial)
+        .remember();
+      return _switchable(factories, sources, _name$, switched, stateSourceName)
+    }
+  }
+}
+
+
+
+/**
+ * create a group of components which can be switched between based on a stream of component names
+ *
+ * @param {Object} factories maps names to component creation functions
+ * @param {Object} sources standard cycle sources object provided to each component
+ * @param {Observable} name$ stream of names corresponding to the component names
+ * @param {Array} switched which cycle sinks from the components should be `switched` when a new `name$` is emitted
+ * @return {Object} cycle sinks object where the selected sinks are switched to the last component name emitted to `name$`
+ *
+ * any component sinks not dsignated in `switched` will be merged across all components
+ */
+function _switchable (factories, sources, name$, switched=['DOM'], stateSourceName='STATE') {
+  if (typeof switched === 'string') switched = [switched];
+
+  const sinks = Object.entries(factories)
+    .map(([name, factory]) => {
+      if (sources[stateSourceName]) {
+        const state$ = sources[stateSourceName].stream;
+        const switched = xs$1.combine(name$, state$)
+                           .filter(([newComponentName, _]) => newComponentName == name)
+                           .map(([_, state]) => state)
+                           .remember();
+
+        const state = new sources[stateSourceName].constructor(switched, sources[stateSourceName]._name);
+        return [name, factory({ ...sources, state })]
+      }
+      return [name, factory(sources)]
+    });
+
+  const switchedSinks = Object.keys(sources)
+    .reduce((obj, sinkName) => {
+      if (switched.includes(sinkName)) {
+        obj[sinkName] = name$
+          .map( newComponentName => {
+            const sink = sinks.find(([componentName, _]) => componentName === newComponentName);
+            return (sink && sink[1][sinkName]) || xs$1.never()
+          })
+          .flatten()
+          .remember()
+          .startWith(undefined);
+      } else {
+        const definedSinks = sinks.filter(([_,sink]) => sink[sinkName] !== undefined)
+                                  .map(([_,sink]) => sink[sinkName]);
+        obj[sinkName] = xs$1.merge(...definedSinks);
+      }
+      return obj
+    }, {});
+
+  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) {
+//   xs.never = xs.default.never
+//   xs.merge = xs.default.merge
+//   xs.of    = xs.default.of
+// }
+// const concat = (Concat && Concat.default) ? Concat.default : Concat
+// const delay  = (Delay && Delay.default) ? Delay.default : Delay
+// const dropRepeats = (DropRepeats && DropRepeats.default) ? DropRepeats.default : DropRepeats
+
+const ENVIRONMENT = ((typeof window != 'undefined' && window) || (process && process.env)) || {};
+
+
+const REQUEST_SELECTOR_METHOD = 'request';
+const BOOTSTRAP_ACTION        = 'BOOTSTRAP';
+const INITIALIZE_ACTION       = 'INITIALIZE';
+const HYDRATE_ACTION          = 'HYDRATE';
+
+
+let IS_ROOT_COMPONENT = true;
+
+
+const ABORT = '~#~#~ABORT~#~#~';
+
+function component (opts) {
+  const { name, sources, isolateOpts, stateSourceName='STATE' } = opts;
+
+  if (sources && typeof sources !== 'object') {
+    throw new Error('Sources must be a Cycle.js sources object:', name)
+  }
+
+  let fixedIsolateOpts;
+  if (typeof isolateOpts == 'string') {
+    fixedIsolateOpts = { [stateSourceName]: isolateOpts };
+  } else {
+    if (isolateOpts === true) {
+      fixedIsolateOpts = {};
+    } else {
+      fixedIsolateOpts = isolateOpts;
+    }
+  }
+
+  const currySources = typeof sources === 'undefined';
+
+  if (typeof fixedIsolateOpts == 'object') {
+    const wrapped = (sources) => {
+      const fixedOpts = { ...opts, sources };
+      return (new Component(fixedOpts)).sinks
+    };
+    return currySources ? isolate(wrapped, fixedIsolateOpts) : isolate(wrapped, fixedIsolateOpts)(sources)
+  } else {
+    return currySources ? (sources) => (new Component({ ...opts, sources })).sinks : (new Component(opts)).sinks
+  }
+}
+
+
+
+
+
+class Component {
+  // [ PASSED PARAMETERS ]
+  // name
+  // sources
+  // intent
+  // request
+  // model
+  // response
+  // view
+  // children
+  // initialState
+  // calculated
+  // storeCalculatedInState
+  // DOMSourceName
+  // stateSourceName
+  // requestSourceName
+
+  // [ PRIVATE / CALCULATED VALUES ]
+  // sourceNames
+  // intent$
+  // action$
+  // model$
+  // response$
+  // sendResponse$
+  // children$
+  // vdom$
+  // subComponentSink$
+
+  // [ INSTANTIATED STREAM OPERATOR ]
+  // log
+
+  // [ OUTPUT ]
+  // sinks
+
+  constructor({ name='NO NAME', sources, intent, request, model, response, view, children={}, components={}, initialState, calculated, storeCalculatedInState=true, DOMSourceName='DOM', stateSourceName='STATE', requestSourceName='HTTP' }) {
+    if (!sources || typeof sources != 'object') throw new Error('Missing or invalid sources')
+
+    this.name       = name;
+    this.sources    = sources;
+    this.intent     = intent;
+    this.request    = request;
+    this.model      = model;
+    this.response   = response;
+    this.view       = view;
+    this.children   = children;
+    this.components = components;
+    this.initialState      = initialState;
+    this.calculated        = calculated;
+    this.storeCalculatedInState = storeCalculatedInState;
+    this.DOMSourceName     = DOMSourceName;
+    this.stateSourceName   = stateSourceName;
+    this.requestSourceName = requestSourceName;
+    this.sourceNames       = Object.keys(sources);
+
+    this.isSubComponent = this.sourceNames.includes('props$');
+
+    const state$ = sources[stateSourceName] && sources[stateSourceName].stream;
+
+    if (state$) {
+      this.currentState = initialState || {};
+      this.sources[this.stateSourceName] = new StateSource(state$.map(val => {
+        this.currentState = val;
+        return val
+      }));
+    }
+
+    if (IS_ROOT_COMPONENT && typeof this.intent === 'undefined' && typeof this.model === 'undefined') {
+      this.initialState = initialState || true;
+      this.intent = _ => ({__NOOP_ACTION__:xs$1.never()});
+      this.model = {
+        __NOOP_ACTION__: state => state
+      };
+    }
+    IS_ROOT_COMPONENT = false;
+
+    this.log = makeLog(name);
+
+    this.initIntent$();
+    this.initAction$();
+    this.initResponse$();
+    this.initState();
+    this.initModel$();
+    this.initSendResponse$();
+    this.initChildren$();
+    this.initSubComponentSink$();
+    this.initSubComponentsRendered$();
+    this.initVdom$();
+    this.initSinks();
+  }
+
+  initIntent$() {
+    if (!this.intent) {
+      return
+    }
+    if (typeof this.intent != 'function') {
+      throw new Error('Intent must be a function')
+    }
+
+    this.intent$ = this.intent(this.sources);
+
+    if (!(this.intent$ instanceof Stream$1) && (typeof this.intent$ != 'object')) {
+      throw new Error('Intent must return either an action$ stream or map of event streams')
+    }
+  }
+
+  initAction$() {
+    const requestSource  = (this.sources && this.sources[this.requestSourceName]) || null;
+
+    if (!this.intent$) {
+      this.action$ = xs$1.never();
+      return
+    }
+
+    let runner;
+    if (this.intent$ instanceof Stream$1) {
+      runner = this.intent$;
+    } else {
+      const mapped = Object.entries(this.intent$)
+                           .map(([type, data$]) => data$.map(data => ({type, data})));
+      runner = xs$1.merge(xs$1.never(), ...mapped);
+    }
+
+    const action$  = ((runner instanceof Stream$1) ? runner : (runner.apply && runner(this.sources) || xs$1.never()));
+    const wrapped$ = _default$3(xs$1.of({ type: BOOTSTRAP_ACTION }), action$)
+      .compose(_default$4(10));
+
+    let initialApiData;
+    if (requestSource && typeof requestSource.select == 'function') {
+      initialApiData = requestSource.select('initial')
+        .flatten();
+    } else {
+      initialApiData = xs$1.never();
+    }
+
+    const hydrate$ = initialApiData.map(data => ({ type: HYDRATE_ACTION, data }));
+
+    this.action$   = xs$1.merge(wrapped$, hydrate$)
+      .compose(this.log(({ type }) => `Action triggered: <${ type }>`));
+  }
+
+  initResponse$() {
+    if (typeof this.request == 'undefined') {
+      return
+    } else if (typeof this.request != 'object') {
+      throw new Error('The request parameter must be an object')
+    }
+
+    const router$ = this.sources[this.requestSourceName];
+    const methods = Object.entries(this.request);
+
+    const wrapped = methods.reduce((acc, [method, routes]) => {
+      const _method = method.toLowerCase();
+      if (typeof router$[_method] != 'function') {
+        throw new Error('Invalid method in request object:', method)
+      }
+      const entries = Object.entries(routes);
+      const mapped = entries.reduce((acc, [route, action]) => {
+        const routeString = `[${_method.toUpperCase()}]:${route || 'none'}`;
+        const actionType = typeof action;
+        if (actionType === 'undefined') {
+          throw new Error(`Action for '${ route }' route in request object not specified`)
+        } else if (actionType !== 'string' && actionType !== 'function') {
+          throw new Error(`Invalid action for '${ route }' route: expecting string or function`)
+        }
+        const actionString = (actionType === 'function') ? '[ FUNCTION ]' : `< ${ action } >`;
+        console.log(`[${ this.name }] Adding ${ this.requestSourceName } route:`, _method.toUpperCase(), `'${ route }' <${ actionString }>`);
+        const route$ = router$[_method](route)
+          .compose(_default$5((a, b) => a.id == b.id))
+          .map(req => {
+            if (!req || !req.id) {
+              throw new Error(`No id found in request: ${ routeString }`)
+            }
+            try {
+              const _reqId  = req.id;
+              const params  = req.params;
+              const body    = req.body;
+              const cookies = req.cookies;
+              const type    = (actionType === 'function') ? 'FUNCTION' : action;
+              const data    = { params, body, cookies, req };
+              const obj     = { type, data: body, req, _reqId, _action: type };
+
+              const timestamp = (new Date()).toISOString();
+              const ip = req.get ? req.get('host') : '0.0.0.0';
+
+              console.log(`${ timestamp } ${ ip } ${ req.method } ${ req.url }`);
+
+              if (ENVIRONMENT.DEBUG) {
+                this.action$.setDebugListener({next: ({ type }) => console.log(`[${ this.name }] Action from ${ this.requestSourceName } request: <${ type }>`)});
+              }
+
+              if (actionType === 'function') {
+                const enhancedState = this.addCalculated(this.currentState);
+                const result = action(enhancedState, req);
+                return xs$1.of({ ...obj, data: result })
+              } else {
+                this.action$.shamefullySendNext(obj);
+
+                const sourceEntries = Object.entries(this.sources);
+                const responses     = sourceEntries.reduce((acc, [name, source]) => {
+                  if (!source || typeof source[REQUEST_SELECTOR_METHOD] != 'function') return acc
+                  const selected$ = source[REQUEST_SELECTOR_METHOD](_reqId);
+                  return [ ...acc, selected$ ]
+                }, []);
+                return xs$1.merge(...responses)
+              }
+            } catch(err) {
+              console.error(err);
+            }
+          }).flatten();
+        return [ ...acc, route$ ]
+      }, []);
+      const mapped$ = xs$1.merge(...mapped);
+      return [ ...acc, mapped$ ]
+    }, []);
+
+    this.response$ = xs$1.merge(...wrapped)
+      .compose(this.log(res => {
+        if (res._action) return `[${ this.requestSourceName }] response data received for Action: <${ res._action }>`
+        return `[${ this.requestSourceName }] response data received from FUNCTION`
+      }));
+
+    if (typeof this.response != 'undefined' && typeof this.response$ == 'undefined') {
+      throw new Error('Cannot have a response parameter without a request parameter')
+    }
+  }
+
+  initState() {
+    if (this.model != undefined) {
+      if (this.model[INITIALIZE_ACTION] === undefined) {
+        this.model[INITIALIZE_ACTION] = {
+          [this.stateSourceName]: (_, data) => ({ ...this.addCalculated(data) })
+        };
+      } else {
+        Object.keys(this.model[INITIALIZE_ACTION]).forEach(name => {
+          if (name !== this.stateSourceName) {
+            console.warn(`${ INITIALIZE_ACTION } can only be used with the ${ this.stateSourceName } source... disregarding ${ name }`);
+            delete this.model[INITIALIZE_ACTION][name];
+          }
+        });
+      }
+    }
+  }
+
+  initModel$() {
+    if (typeof this.model == 'undefined') {
+      this.model$ = this.sourceNames.reduce((a,s) => {
+        a[s] = xs$1.never();
+        return a
+      }, {});
+      return
+    }
+
+    const initial  = { type: INITIALIZE_ACTION, data: this.initialState };
+    const shimmed$ = this.initialState ? _default$3(xs$1.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$);
+
+
+    const modelEntries = Object.entries(this.model);
+
+    const reducers = {};
+
+    modelEntries.forEach((entry) => {
+      let [action, sinks] = entry;
+
+      if (typeof sinks === 'function') {
+        sinks = { [this.stateSourceName]: sinks };
+      }
+
+      if (typeof sinks !== 'object') {
+        throw new Error(`Entry for each action must be an object: ${ this.name } ${ action }`)
+      }
+
+      const sinkEntries = Object.entries(sinks);
+
+      sinkEntries.forEach((entry) => {
+        const [sink, reducer] = entry;
+
+        const isStateSink = (sink == this.stateSourceName);
+
+        const on = isStateSink ? onState : onNormal;
+        const onned = on(action, reducer);
+
+        const wrapped = onned.compose(this.log(data => {
+            if (isStateSink) {
+              return `State reducer added: <${ action }>`
+            } else {
+              const extra = data && (data.type || data.command || data.name || data.key || (Array.isArray(data) && 'Array') || data);
+              return `Data sent to [${ sink }]: <${ action }> ${ extra }`
+            }
+          }));
+
+        if (Array.isArray(reducers[sink])) {
+          reducers[sink].push(wrapped);
+        } else {
+          reducers[sink] = [wrapped];
+        }
+      });
+    });
+
+    const model$ = Object.entries(reducers).reduce((acc, entry) => {
+      const [sink, streams] = entry;
+      acc[sink] = xs$1.merge(xs$1.never(), ...streams);
+      return acc
+    }, {});
+
+    this.model$ = model$;
+  }
+
+  initSendResponse$() {
+    const responseType = typeof this.response;
+    if (responseType != 'function' && responseType != 'undefined') {
+      throw new Error('The response parameter must be a function')
+    }
+
+    if (responseType == 'undefined') {
+      if (this.response$) {
+        this.response$.subscribe({
+          next: this.log(({ _reqId, _action }) => `Unhandled response for request: ${ _action } ${ _reqId }`)
+        });
+      }
+      this.sendResponse$ = xs$1.never();
+      return
+    }
+
+    const selectable = {
+      select: (actions) => {
+        if (typeof actions == 'undefined') return this.response$
+        if (!Array.isArray(actions)) actions = [actions];
+        return this.response$.filter(({_action}) => (actions.length > 0) ? (_action === 'FUNCTION' || actions.includes(_action)) : true)
+      }
+    };
+
+    const out = this.response(selectable);
+    if (typeof out != 'object') {
+      throw new Error('The response function must return an object')
+    }
+
+    const entries = Object.entries(out);
+    const out$    = entries.reduce((acc, [command, response$]) => {
+      const mapped$ = response$.map(({ _reqId, _action, data }) => {
+        if (!_reqId) {
+          throw new Error(`No request id found for response for: ${ command }`)
+        }
+        return { _reqId, _action, command, data }
+      });
+      return [ ...acc, mapped$ ]
+    }, []);
+
+    this.sendResponse$ = xs$1.merge(...out$)
+      .compose(this.log(({ _reqId, _action }) => `[${ this.requestSourceName }] response sent for: <${ _action }>`));
+  }
+
+  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$1.create({
+      start: listener => {
+        this.newSubComponentSinks = listener.next.bind(listener);
+      },
+      stop: _ => {
+
+      }
+    });
+    subComponentSink$.subscribe({ next: _ => _ });
+    this.subComponentSink$ = subComponentSink$.filter(sinks => Object.keys(sinks).length > 0);
+  }
+
+  initSubComponentsRendered$() {
+    const stream = xs$1.create({
+      start: (listener) => {
+        this.subComponentsRendered = listener.next.bind(listener);
+      },
+      stop: _ => {
+
+      }
+    });
+    this.subComponentsRendered$ = stream.startWith(null);
+  }
+
+  initVdom$() {
+    if (typeof this.view != 'function') {
+      this.vdom$ = xs$1.of(null);
+      return
+    }
+
+    const renderParameters$ = this.collectRenderParameters();
+
+    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));
+
+  }
+
+  initSinks() {
+    this.sinks = this.sourceNames.reduce((acc, name) => {
+      if (name == this.DOMSourceName) return acc
+      const subComponentSink$ = this.subComponentSink$ ? this.subComponentSink$.map(sinks => sinks[name]).filter(sink => !!sink).flatten() : xs$1.never();
+      if (name === this.stateSourceName) {
+        acc[name] = xs$1.merge((this.model$[name] || xs$1.never()), subComponentSink$, this.sources[this.stateSourceName].stream.filter(_ => false), ...this.children$[name]);
+      } else {
+        acc[name] = xs$1.merge((this.model$[name] || xs$1.never()), subComponentSink$, ...this.children$[name]);
+      }
+      return acc
+    }, {});
+
+    this.sinks[this.DOMSourceName]     = this.vdom$;
+    this.sinks[this.requestSourceName] = xs$1.merge(this.sendResponse$ ,this.sinks[this.requestSourceName]);
+  }
+
+  makeOnAction(action$, isStateSink=true, rootAction$) {
+    rootAction$ = rootAction$ || action$;
+    return (name, reducer) => {
+      const filtered$ = action$.filter(({type}) => type == name);
+
+      let returnStream$;
+      if (typeof reducer === 'function') {
+        returnStream$ = filtered$.map(action => {
+          const next = (type, data) => {
+            const _reqId = action._reqId || (action.req && action.req.id);
+            const _data  = _reqId ? (typeof data == 'object' ? { ...data, _reqId, _action: name } : { data, _reqId, _action: name }) : data;
+            // put the "next" action request at the end of the event loop so the "current" action completes first
+            setTimeout(() => {
+              // push the "next" action request into the action$ stream
+              rootAction$.shamefullySendNext({ type, data: _data });
+            }, 10);
+          };
+
+          let data = action.data;
+          if (data && data.data && data._reqId) data = data.data;
+          if (isStateSink) {
+            return (state) => {
+              const _state = this.isSubComponent ? this.currentState : state;
+              const enhancedState = this.addCalculated(_state);
+              const newState = reducer(enhancedState, data, next, action.req);
+              if (newState == ABORT) return _state
+              return this.cleanupCalculated(newState)
+            }
+          } else {
+            const enhancedState = this.addCalculated(this.currentState);
+            const reduced = reducer(enhancedState, data, next, action.req);
+            const type = typeof reduced;
+            const _reqId = action._reqId || (action.req && action.req.id);
+            if (['string', 'number', 'boolean', 'function'].includes(type)) return reduced
+            if (type == 'object') return { ...reduced, _reqId, _action: name }
+            if (type == 'undefined') {
+              console.warn(`'undefined' value sent to ${ name }`);
+              return reduced
+            }
+            throw new Error(`Invalid reducer type for ${ name } ${ type }`)
+          }
+        }).filter(result => result != ABORT);
+      } else if (reducer === undefined || reducer === true) {
+        returnStream$ = filtered$.map(({data}) => data);
+      } else {
+        const value = reducer;
+        returnStream$ = filtered$.mapTo(value);
+      }
+
+      return returnStream$
+    }
+  }
+
+  addCalculated(state) {
+    if (!this.calculated || typeof state !== 'object') return state
+    if (typeof this.calculated !== 'object') throw new Error(`'calculated' parameter must be an object mapping calculated state field named to functions`)
+    const entries = Object.entries(this.calculated);
+    const calculated = entries.reduce((acc, [field, fn]) => {
+      if (typeof fn !== 'function') throw new Error(`Missing or invalid calculator function for calculated field '${ field }`)
+      try {
+        acc[field] = fn(state);
+      } catch(e) {
+        console.warn(`Calculated field '${ field }' threw an error during calculation: ${ e.message }`);
+      }
+      return acc
+    }, {});
+    return { ...state, ...calculated }
+  }
+
+  cleanupCalculated(state) {
+    if (this.storeCalculatedInState) return this.addCalculated(state)
+    if (!this.calculated || !state || typeof state !== 'object') return state
+    const keys = Object.keys(this.calculated);
+    const copy = { ...state };
+    keys.forEach(key => {
+      if (this.initialState && typeof this.initialState[key] !== 'undefined') {
+        copy[key] = this.initialState[key];
+      } else {
+        delete copy[key];
+      }
+    });
+    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$1.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$1.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$1.create().startWith(props);
+        const children$ = xs$1.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$1.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 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 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 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 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(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 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$1.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 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$1.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$1.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$1.of(root)
+
+        return xs$1.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'))
+  }
+
+}
+
+
+
+
+
+
+
+/**
+ * factory to create a logging function meant to be used inside of an xstream .compose()
+ *
+ * @param {String} context name of the component or file to be prepended to any messages
+ * @return {Function}
+ *
+ * returned function accepts either a `String` of `Function`
+ * `String` values will be logged to `console` as is
+ * `Function` values will be called with the current `stream` value and the result will be logged to `console`
+ * all output will be prepended with the `context` (ex. "[CONTEXT] My output")
+ * ONLY outputs if the global `DEBUG` variable is set to `true`
+ */
+ function makeLog (context) {
+  return function (msg) {
+    const fixedMsg = (typeof msg === 'function') ? msg : _ => msg;
+    return stream => {
+      return stream.debug(msg => {
+        if (ENVIRONMENT.DEBUG == 'true' || ENVIRONMENT.DEBUG === true) {
+          console.log(`[${context}] ${fixedMsg(msg)}`);
+        }
+      })
+    }
+  }
+}
+
+
+
+function getComponents(currentElement, componentNames, depth=0, index=0) {
+  if (!currentElement) return {}
+
+  if (currentElement.data?.componentsProcessed) return {}
+  if (depth === 0) currentElement.data.componentsProcessed = true;
+
+  const sel          = currentElement.sel;
+  const isCollection = sel && sel.toLowerCase() === 'collection';
+  const isSwitchable = sel && sel.toLowerCase() === 'switchable';
+  const isComponent  = sel && (['collection', 'switchable', 'sygnal-factory', ...componentNames].includes(currentElement.sel)) || typeof currentElement.data?.props?.sygnalFactory === 'function';
+  const props        = (currentElement.data && currentElement.data.props) || {};
+  const attrs        = (currentElement.data && currentElement.data.attrs) || {};
+  const children     = currentElement.children || [];
+
+  let found    = {};
+
+  if (isComponent) {
+    const id  = getComponentIdFromElement(currentElement, depth, index);
+    if (isCollection) {
+      if (!props.of)                            throw new Error(`Collection element missing required 'component' property`)
+      if (typeof props.of !== 'string' && typeof props.of !== 'function')         throw new Error(`Invalid 'component' property of collection element: found ${ typeof props.of } requires string or component factory function`)
+      if (typeof props.of !== 'function' && !componentNames.includes(props.of))   throw new Error(`Specified component for collection not found: ${ props.of }`)
+      if (typeof attrs.for !== 'undefined' && !(typeof attrs.for === 'string' || Array.isArray(attrs.for))) console.warn(`No valid array found in the 'value' property of collection ${ typeof props.of === 'string' ? props.of : 'function component' }: no collection components will be created`);
+      currentElement.data.isCollection = true;
+      currentElement.data.props ||= {};
+      currentElement.data.props.for = attrs.for;
+      currentElement.data.attrs = undefined;
+    } else if (isSwitchable) {
+      if (!props.of)                    throw new Error(`Switchable element missing required 'of' property`)
+      if (typeof props.of !== 'object') throw new Error(`Invalid 'components' property of switchable element: found ${ typeof props.of } requires object mapping names to component factories`)
+      const switchableComponents = Object.values(props.of);
+      if (!switchableComponents.every(comp => typeof comp === 'function')) throw new Error(`One or more components provided to switchable element is not a valid component factory`)
+      if (!props.current || (typeof props.current !== 'string' && typeof props.current !== 'function')) throw new Error(`Missing or invalid 'current' property for switchable element: found '${ typeof props.current }' requires string or function`)
+      const switchableComponentNames = Object.keys(props.of);
+      if (!switchableComponentNames.includes(props.current)) throw new Error(`Component '${ props.current }' not found in switchable element`)
+      currentElement.data.isSwitchable = true;
+    } else ;
+    found[id] = currentElement;
+  }
+
+  if (children.length > 0) {
+    children.map((child, i) => getComponents(child, componentNames, depth + 1, i))
+            .forEach((child) => {
+              Object.entries(child).forEach(([id, el]) => found[id] = el);
+            });
+  }
+
+  return found
+}
+
+function injectComponents(currentElement, components, componentNames, depth=0, index) {
+  if (!currentElement) return
+  if (currentElement.data?.componentsInjected) return currentElement
+  if (depth === 0 && currentElement.data) currentElement.data.componentsInjected = true;
+
+
+  const sel          = currentElement.sel || 'NO SELECTOR';
+  const isComponent  = ['collection', 'switchable', 'sygnal-factory', ...componentNames].includes(sel) || typeof currentElement.data?.props?.sygnalFactory === 'function';
+  const isCollection = currentElement?.data?.isCollection;
+  const isSwitchable = currentElement?.data?.isSwitchable;
+  (currentElement.data && currentElement.data.props) || {};
+  const children     = currentElement.children || [];
+
+  if (isComponent) {
+    const id  = getComponentIdFromElement(currentElement, depth, index);
+    const component = components[id];
+    if (isCollection) {
+      currentElement.sel = 'div';
+      currentElement.children = Array.isArray(component) ? component : [component];
+      return currentElement
+    } else if (isSwitchable) {
+      return component
+    } else {
+      return component
+    }
+  } else if (children.length > 0) {
+    currentElement.children = children.map((child, i) => injectComponents(child, components, componentNames, depth + 1, i)).flat();
+    return currentElement
+  } else {
+    return currentElement
+  }
+}
+
+const selMap = new Map();
+function getComponentIdFromElement(el, depth, index) {
+  const sel  = el.sel;
+  const name = typeof sel === 'string' ? sel : 'functionComponent';
+  let base = selMap.get(sel);
+  if (!base) {
+    const date = Date.now();
+    const rand = Math.floor(Math.random() * 10000);
+    base = `${date}-${rand}`;
+    selMap.set(sel, base);
+  }
+  const uid = `${base}-${depth}-${index}`;
+  const props   = (el.data && el.data.props) || {};
+  const id      = (props.id && JSON.stringify(props.id)) || uid;
+  const fullId = `${ name }::${ id }`;
+  return fullId
+}
+
+
+function deepCopyVdom(obj) {
+  if (typeof obj === 'undefined') return obj
+  return { ...obj, children: Array.isArray(obj.children) ? obj.children.map(deepCopyVdom) : undefined, data: obj.data && { ...obj.data, componentsInjected: false } }
+}
+
+function processForm(form, options={}) {
+  let { events = ['input', 'submit'], preventDefault = true } = options;
+  if (typeof events === 'string') events = [events];
+
+  const eventStream$ = events.map(event => form.events(event));
+
+  const merged$ = xs$1.merge(...eventStream$);
+
+  return merged$.map((e) => {
+    if (preventDefault) e.preventDefault();
+    const form = (e.type === 'submit') ? e.srcElement : e.currentTarget;
+    const formData = new FormData(form);
+    let entries = {};
+    entries.event = e;
+    entries.eventType = e.type;
+    const submitBtn = form.querySelector('input[type=submit]:focus');
+    if (submitBtn) {
+      const { name, value } = submitBtn;
+      entries[name || 'submit'] = value;
+    }
+    for (let [name, value] of formData.entries()) {
+      entries[name] = value;
+    }
+    return entries
+  })
+}
+
+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();
+
+  out$.subscribe({
+    next: event => events.dispatchEvent(new CustomEvent('data', { detail: event }))
+  });
+
+  return {
+    select: (type) => {
+      const all = !type;
+      const _type = (Array.isArray(type)) ? type : [type];
+      let cb;
+      const in$ = xs$1.create({
+        start: (listener) => {
+          cb = ({detail: event}) => {
+            const data = (event && event.data) || null;
+            if (all || _type.includes(event.type)) listener.next(data);
+          };
+          events.addEventListener('data', cb);
+        },
+        stop: _ => events.removeEventListener('data', cb)
+      });
+
+      return adapt_2(in$)
+    }
+  }
+}
+
+function logDriver(out$) {
+  out$.addListener({
+    next: (val) => {
+      console.log(val);
+    }
+  });
+}
+
+function run(app, drivers={}, options={}) {
+  const { mountPoint='#root', fragments=true } = options;
+
+  const wrapped = withState(app, 'STATE');
+
+  const baseDrivers = {
+    EVENTS: eventBusDriver,
+    DOM:    makeDOMDriver(mountPoint, { snabbdomOptions: { experimental: { fragments } } }),
+    LOG:    logDriver
+  };
+
+  const combinedDrivers = { ...baseDrivers, ...drivers };
+
+  return run$1(wrapped, combinedDrivers)
+}
+
+/**
+ * return a validated and properly separated string of CSS class names from any number of strings, arrays, and objects
+ *
+ * @param  {...String|Array|Object} args any number of strings or arrays with valid CSS class names, or objects where the keys are valid class names and the values evaluate to true or false
+ * @return {String} list of `active` classes separated by spaces
+ *
+ * any `string` or `array` arguments are simply validated and appended to the result
+ * `objects` will evaluate the values (which can be booleans or functions), and the keys with `thruthy` values will be validated and appended to the result
+ * this function makes it easier to set dynamic classes on HTML elements
+ */
+function classes(...args) {
+  return args.reduce((acc, arg) => {
+    if (typeof arg === 'string' && !acc.includes(arg)) {
+      acc.push(...classes_processString(arg));
+    } else if (Array.isArray(arg)) {
+      acc.push(...classes_processArray(arg));
+    } else if (typeof arg === 'object') {
+      acc.push(...classes_processObject(arg));
+    }
+    return acc
+  }, []).join(' ')
+}
+
+
+
+/**
+ * validate a string as a CSS class name
+ *
+ * @param {String} className CSS class name to validate
+ * @return {Boolean} true if the name is a valid CSS class, false otherwise
+ */
+function isValidClassName (className) {
+  return /^[a-zA-Z0-9-_]+$/.test(className)
+}
+
+/**
+ * find and validate CSS class names in a string
+ *
+ * @param {String} str string containing one or more CSS class names
+ * @return {Array} valid CSS classnames from the provided string
+ */
+function classes_processString(str) {
+  if (typeof str !== 'string') throw new Error('Class name must be a string')
+  return str.trim().split(' ').reduce((acc, item) => {
+    if (item.trim().length === 0) return acc
+    if (!isValidClassName(item)) throw new Error(`${item} is not a valid CSS class name`)
+    acc.push(item);
+    return acc
+  }, [])
+}
+
+/**
+ * find and validate CSS class names in an array of strings
+ *
+ * @param {Array} arr array containing one or more strings with valid CSS class names
+ * @return {Array} valid CSS class names from the provided array
+ */
+function classes_processArray(arr) {
+  return arr.map(classes_processString).flat()
+}
+
+/**
+ * find and validate CSS class names in an object, and exclude keys whose value evaluates to `false`
+ *
+ * @param {Object} obj object with keys as CSS class names and values which if `truthy` cause the associated key to be returned
+ * @return {Array} valid CSS class names from the keys of the provided object where the associated value evaluated to `true`
+ *
+ * the value for each key can be either a value that evaluates to a boolean or a function that returns a boolean
+ * if the value is a function, it will be run and the returned value will be used
+ */
+function classes_processObject(obj) {
+  const ret =  Object.entries(obj)
+                      .filter(([key, predicate]) => (typeof predicate === 'function') ? predicate() : !!predicate)
+                      .map(([key, _]) => {
+                        const trimmed = key.trim();
+                        if (!isValidClassName(trimmed)) throw new Error (`${trimmed} is not a valid CSS class name`)
+                        return trimmed
+                      });
+  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;
+
+export { ABORT, classes, collection, component, _default$2 as debounce, _default$4 as delay, _default$5 as dropRepeats, processForm, run, _default as sampleCombine, switchable, _default$1 as throttle };