sygnal 5.3.7 → 6.0.0

package/dist/astro/client.esm.js

@@ -1,4665 +0,0 @@
-import { setup } from '@cycle/run';
-import { makeCollection, StateSource, withState } from '@cycle/state';
-import { makeDOMDriver } from '@cycle/dom';
-import xs$1, { Stream as Stream$1 } from 'xstream';
-import isolate from '@cycle/isolate';
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-var adapt$1 = {};
-
-Object.defineProperty(adapt$1, "__esModule", { value: true });
-function getGlobal$1() {
-    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$1().adaptStream = f;
-}
-adapt$1.setAdapt = setAdapt;
-function adapt(stream) {
-    return getGlobal$1().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 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 dropRepeats$1 = {};
-
-var xstream = {};
-
-var ponyfill$1 = {};
-
-(function (exports) {
-
-	Object.defineProperty(exports, "__esModule", {
-		value: true
-	});
-	exports['default'] = symbolObservablePonyfill;
-	function symbolObservablePonyfill(root) {
-		var result;
-		var _Symbol = root.Symbol;
-
-		if (typeof _Symbol === 'function') {
-			if (_Symbol.observable) {
-				result = _Symbol.observable;
-			} else {
-
-				// This just needs to be something that won't trample other user's Symbol.for use
-				// It also will guide people to the source of their issues, if this is problematic.
-				// META: It's a resource locator!
-				result = _Symbol['for']('https://github.com/benlesh/symbol-observable');
-				try {
-					_Symbol.observable = result;
-				} catch (err) {
-					// Do nothing. In some environments, users have frozen `Symbol` for security reasons,
-					// if it is frozen assigning to it will throw. In this case, we don't care, because
-					// they will need to use the returned value from the ponyfill.
-				}
-			}
-		} else {
-			result = '@@observable';
-		}
-
-		return result;
-	}} (ponyfill$1));
-
-var ponyfill = ponyfill$1;
-
-var toStr$2 = Object.prototype.toString;
-
-var isArguments = function isArguments(value) {
-	var str = toStr$2.call(value);
-	var isArgs = str === '[object Arguments]';
-	if (!isArgs) {
-		isArgs = str !== '[object Array]' &&
-			value !== null &&
-			typeof value === 'object' &&
-			typeof value.length === 'number' &&
-			value.length >= 0 &&
-			toStr$2.call(value.callee) === '[object Function]';
-	}
-	return isArgs;
-};
-
-var implementation$5;
-var hasRequiredImplementation;
-
-function requireImplementation () {
-	if (hasRequiredImplementation) return implementation$5;
-	hasRequiredImplementation = 1;
-
-	var keysShim;
-	if (!Object.keys) {
-		// modified from https://github.com/es-shims/es5-shim
-		var has = Object.prototype.hasOwnProperty;
-		var toStr = Object.prototype.toString;
-		var isArgs = isArguments; // eslint-disable-line global-require
-		var isEnumerable = Object.prototype.propertyIsEnumerable;
-		var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
-		var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
-		var dontEnums = [
-			'toString',
-			'toLocaleString',
-			'valueOf',
-			'hasOwnProperty',
-			'isPrototypeOf',
-			'propertyIsEnumerable',
-			'constructor'
-		];
-		var equalsConstructorPrototype = function (o) {
-			var ctor = o.constructor;
-			return ctor && ctor.prototype === o;
-		};
-		var excludedKeys = {
-			$applicationCache: true,
-			$console: true,
-			$external: true,
-			$frame: true,
-			$frameElement: true,
-			$frames: true,
-			$innerHeight: true,
-			$innerWidth: true,
-			$onmozfullscreenchange: true,
-			$onmozfullscreenerror: true,
-			$outerHeight: true,
-			$outerWidth: true,
-			$pageXOffset: true,
-			$pageYOffset: true,
-			$parent: true,
-			$scrollLeft: true,
-			$scrollTop: true,
-			$scrollX: true,
-			$scrollY: true,
-			$self: true,
-			$webkitIndexedDB: true,
-			$webkitStorageInfo: true,
-			$window: true
-		};
-		var hasAutomationEqualityBug = (function () {
-			/* global window */
-			if (typeof window === 'undefined') { return false; }
-			for (var k in window) {
-				try {
-					if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
-						try {
-							equalsConstructorPrototype(window[k]);
-						} catch (e) {
-							return true;
-						}
-					}
-				} catch (e) {
-					return true;
-				}
-			}
-			return false;
-		}());
-		var equalsConstructorPrototypeIfNotBuggy = function (o) {
-			/* global window */
-			if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
-				return equalsConstructorPrototype(o);
-			}
-			try {
-				return equalsConstructorPrototype(o);
-			} catch (e) {
-				return false;
-			}
-		};
-
-		keysShim = function keys(object) {
-			var isObject = object !== null && typeof object === 'object';
-			var isFunction = toStr.call(object) === '[object Function]';
-			var isArguments = isArgs(object);
-			var isString = isObject && toStr.call(object) === '[object String]';
-			var theKeys = [];
-
-			if (!isObject && !isFunction && !isArguments) {
-				throw new TypeError('Object.keys called on a non-object');
-			}
-
-			var skipProto = hasProtoEnumBug && isFunction;
-			if (isString && object.length > 0 && !has.call(object, 0)) {
-				for (var i = 0; i < object.length; ++i) {
-					theKeys.push(String(i));
-				}
-			}
-
-			if (isArguments && object.length > 0) {
-				for (var j = 0; j < object.length; ++j) {
-					theKeys.push(String(j));
-				}
-			} else {
-				for (var name in object) {
-					if (!(skipProto && name === 'prototype') && has.call(object, name)) {
-						theKeys.push(String(name));
-					}
-				}
-			}
-
-			if (hasDontEnumBug) {
-				var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
-
-				for (var k = 0; k < dontEnums.length; ++k) {
-					if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
-						theKeys.push(dontEnums[k]);
-					}
-				}
-			}
-			return theKeys;
-		};
-	}
-	implementation$5 = keysShim;
-	return implementation$5;
-}
-
-var slice$1 = Array.prototype.slice;
-var isArgs = isArguments;
-
-var origKeys = Object.keys;
-var keysShim = origKeys ? function keys(o) { return origKeys(o); } : requireImplementation();
-
-var originalKeys = Object.keys;
-
-keysShim.shim = function shimObjectKeys() {
-	if (Object.keys) {
-		var keysWorksWithArguments = (function () {
-			// Safari 5.0 bug
-			var args = Object.keys(arguments);
-			return args && args.length === arguments.length;
-		}(1, 2));
-		if (!keysWorksWithArguments) {
-			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
-				if (isArgs(object)) {
-					return originalKeys(slice$1.call(object));
-				}
-				return originalKeys(object);
-			};
-		}
-	} else {
-		Object.keys = keysShim;
-	}
-	return Object.keys || keysShim;
-};
-
-var objectKeys = keysShim;
-
-/* eslint complexity: [2, 18], max-statements: [2, 33] */
-var shams = function hasSymbols() {
-	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
-	if (typeof Symbol.iterator === 'symbol') { return true; }
-
-	var obj = {};
-	var sym = Symbol('test');
-	var symObj = Object(sym);
-	if (typeof sym === 'string') { return false; }
-
-	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
-	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
-
-	// temp disabled per https://github.com/ljharb/object.assign/issues/17
-	// if (sym instanceof Symbol) { return false; }
-	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
-	// if (!(symObj instanceof Symbol)) { return false; }
-
-	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
-	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
-
-	var symVal = 42;
-	obj[sym] = symVal;
-	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
-	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
-
-	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
-
-	var syms = Object.getOwnPropertySymbols(obj);
-	if (syms.length !== 1 || syms[0] !== sym) { return false; }
-
-	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
-
-	if (typeof Object.getOwnPropertyDescriptor === 'function') {
-		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
-		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
-	}
-
-	return true;
-};
-
-var origSymbol = typeof Symbol !== 'undefined' && Symbol;
-var hasSymbolSham = shams;
-
-var hasSymbols$2 = function hasNativeSymbols() {
-	if (typeof origSymbol !== 'function') { return false; }
-	if (typeof Symbol !== 'function') { return false; }
-	if (typeof origSymbol('foo') !== 'symbol') { return false; }
-	if (typeof Symbol('bar') !== 'symbol') { return false; }
-
-	return hasSymbolSham();
-};
-
-var test = {
-	foo: {}
-};
-
-var $Object = Object;
-
-var hasProto$1 = function hasProto() {
-	return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
-};
-
-/* eslint no-invalid-this: 1 */
-
-var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
-var slice = Array.prototype.slice;
-var toStr$1 = Object.prototype.toString;
-var funcType = '[object Function]';
-
-var implementation$4 = function bind(that) {
-    var target = this;
-    if (typeof target !== 'function' || toStr$1.call(target) !== funcType) {
-        throw new TypeError(ERROR_MESSAGE + target);
-    }
-    var args = slice.call(arguments, 1);
-
-    var bound;
-    var binder = function () {
-        if (this instanceof bound) {
-            var result = target.apply(
-                this,
-                args.concat(slice.call(arguments))
-            );
-            if (Object(result) === result) {
-                return result;
-            }
-            return this;
-        } else {
-            return target.apply(
-                that,
-                args.concat(slice.call(arguments))
-            );
-        }
-    };
-
-    var boundLength = Math.max(0, target.length - args.length);
-    var boundArgs = [];
-    for (var i = 0; i < boundLength; i++) {
-        boundArgs.push('$' + i);
-    }
-
-    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
-
-    if (target.prototype) {
-        var Empty = function Empty() {};
-        Empty.prototype = target.prototype;
-        bound.prototype = new Empty();
-        Empty.prototype = null;
-    }
-
-    return bound;
-};
-
-var implementation$3 = implementation$4;
-
-var functionBind = Function.prototype.bind || implementation$3;
-
-var bind$1 = functionBind;
-
-var src = bind$1.call(Function.call, Object.prototype.hasOwnProperty);
-
-var undefined$1;
-
-var $SyntaxError = SyntaxError;
-var $Function = Function;
-var $TypeError = TypeError;
-
-// eslint-disable-next-line consistent-return
-var getEvalledConstructor = function (expressionSyntax) {
-	try {
-		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
-	} catch (e) {}
-};
-
-var $gOPD = Object.getOwnPropertyDescriptor;
-if ($gOPD) {
-	try {
-		$gOPD({}, '');
-	} catch (e) {
-		$gOPD = null; // this is IE 8, which has a broken gOPD
-	}
-}
-
-var throwTypeError = function () {
-	throw new $TypeError();
-};
-var ThrowTypeError = $gOPD
-	? (function () {
-		try {
-			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
-			arguments.callee; // IE 8 does not throw here
-			return throwTypeError;
-		} catch (calleeThrows) {
-			try {
-				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
-				return $gOPD(arguments, 'callee').get;
-			} catch (gOPDthrows) {
-				return throwTypeError;
-			}
-		}
-	}())
-	: throwTypeError;
-
-var hasSymbols$1 = hasSymbols$2();
-var hasProto = hasProto$1();
-
-var getProto = Object.getPrototypeOf || (
-	hasProto
-		? function (x) { return x.__proto__; } // eslint-disable-line no-proto
-		: null
-);
-
-var needsEval = {};
-
-var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined$1 : getProto(Uint8Array);
-
-var INTRINSICS = {
-	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
-	'%Array%': Array,
-	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
-	'%ArrayIteratorPrototype%': hasSymbols$1 && getProto ? getProto([][Symbol.iterator]()) : undefined$1,
-	'%AsyncFromSyncIteratorPrototype%': undefined$1,
-	'%AsyncFunction%': needsEval,
-	'%AsyncGenerator%': needsEval,
-	'%AsyncGeneratorFunction%': needsEval,
-	'%AsyncIteratorPrototype%': needsEval,
-	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
-	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
-	'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
-	'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
-	'%Boolean%': Boolean,
-	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
-	'%Date%': Date,
-	'%decodeURI%': decodeURI,
-	'%decodeURIComponent%': decodeURIComponent,
-	'%encodeURI%': encodeURI,
-	'%encodeURIComponent%': encodeURIComponent,
-	'%Error%': Error,
-	'%eval%': eval, // eslint-disable-line no-eval
-	'%EvalError%': EvalError,
-	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
-	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
-	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
-	'%Function%': $Function,
-	'%GeneratorFunction%': needsEval,
-	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
-	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
-	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
-	'%isFinite%': isFinite,
-	'%isNaN%': isNaN,
-	'%IteratorPrototype%': hasSymbols$1 && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
-	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
-	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
-	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$1 || !getProto ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
-	'%Math%': Math,
-	'%Number%': Number,
-	'%Object%': Object,
-	'%parseFloat%': parseFloat,
-	'%parseInt%': parseInt,
-	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
-	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
-	'%RangeError%': RangeError,
-	'%ReferenceError%': ReferenceError,
-	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
-	'%RegExp%': RegExp,
-	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
-	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$1 || !getProto ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
-	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
-	'%String%': String,
-	'%StringIteratorPrototype%': hasSymbols$1 && getProto ? getProto(''[Symbol.iterator]()) : undefined$1,
-	'%Symbol%': hasSymbols$1 ? Symbol : undefined$1,
-	'%SyntaxError%': $SyntaxError,
-	'%ThrowTypeError%': ThrowTypeError,
-	'%TypedArray%': TypedArray,
-	'%TypeError%': $TypeError,
-	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
-	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
-	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
-	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
-	'%URIError%': URIError,
-	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
-	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
-	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
-};
-
-if (getProto) {
-	try {
-		null.error; // eslint-disable-line no-unused-expressions
-	} catch (e) {
-		// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
-		var errorProto = getProto(getProto(e));
-		INTRINSICS['%Error.prototype%'] = errorProto;
-	}
-}
-
-var doEval = function doEval(name) {
-	var value;
-	if (name === '%AsyncFunction%') {
-		value = getEvalledConstructor('async function () {}');
-	} else if (name === '%GeneratorFunction%') {
-		value = getEvalledConstructor('function* () {}');
-	} else if (name === '%AsyncGeneratorFunction%') {
-		value = getEvalledConstructor('async function* () {}');
-	} else if (name === '%AsyncGenerator%') {
-		var fn = doEval('%AsyncGeneratorFunction%');
-		if (fn) {
-			value = fn.prototype;
-		}
-	} else if (name === '%AsyncIteratorPrototype%') {
-		var gen = doEval('%AsyncGenerator%');
-		if (gen && getProto) {
-			value = getProto(gen.prototype);
-		}
-	}
-
-	INTRINSICS[name] = value;
-
-	return value;
-};
-
-var LEGACY_ALIASES = {
-	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
-	'%ArrayPrototype%': ['Array', 'prototype'],
-	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
-	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
-	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
-	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
-	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
-	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
-	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
-	'%BooleanPrototype%': ['Boolean', 'prototype'],
-	'%DataViewPrototype%': ['DataView', 'prototype'],
-	'%DatePrototype%': ['Date', 'prototype'],
-	'%ErrorPrototype%': ['Error', 'prototype'],
-	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
-	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
-	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
-	'%FunctionPrototype%': ['Function', 'prototype'],
-	'%Generator%': ['GeneratorFunction', 'prototype'],
-	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
-	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
-	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
-	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
-	'%JSONParse%': ['JSON', 'parse'],
-	'%JSONStringify%': ['JSON', 'stringify'],
-	'%MapPrototype%': ['Map', 'prototype'],
-	'%NumberPrototype%': ['Number', 'prototype'],
-	'%ObjectPrototype%': ['Object', 'prototype'],
-	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
-	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
-	'%PromisePrototype%': ['Promise', 'prototype'],
-	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
-	'%Promise_all%': ['Promise', 'all'],
-	'%Promise_reject%': ['Promise', 'reject'],
-	'%Promise_resolve%': ['Promise', 'resolve'],
-	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
-	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
-	'%RegExpPrototype%': ['RegExp', 'prototype'],
-	'%SetPrototype%': ['Set', 'prototype'],
-	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
-	'%StringPrototype%': ['String', 'prototype'],
-	'%SymbolPrototype%': ['Symbol', 'prototype'],
-	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
-	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
-	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
-	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
-	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
-	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
-	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
-	'%URIErrorPrototype%': ['URIError', 'prototype'],
-	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
-	'%WeakSetPrototype%': ['WeakSet', 'prototype']
-};
-
-var bind = functionBind;
-var hasOwn = src;
-var $concat = bind.call(Function.call, Array.prototype.concat);
-var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
-var $replace = bind.call(Function.call, String.prototype.replace);
-var $strSlice = bind.call(Function.call, String.prototype.slice);
-var $exec = bind.call(Function.call, RegExp.prototype.exec);
-
-/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
-var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
-var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
-var stringToPath = function stringToPath(string) {
-	var first = $strSlice(string, 0, 1);
-	var last = $strSlice(string, -1);
-	if (first === '%' && last !== '%') {
-		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
-	} else if (last === '%' && first !== '%') {
-		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
-	}
-	var result = [];
-	$replace(string, rePropName, function (match, number, quote, subString) {
-		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
-	});
-	return result;
-};
-/* end adaptation */
-
-var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
-	var intrinsicName = name;
-	var alias;
-	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
-		alias = LEGACY_ALIASES[intrinsicName];
-		intrinsicName = '%' + alias[0] + '%';
-	}
-
-	if (hasOwn(INTRINSICS, intrinsicName)) {
-		var value = INTRINSICS[intrinsicName];
-		if (value === needsEval) {
-			value = doEval(intrinsicName);
-		}
-		if (typeof value === 'undefined' && !allowMissing) {
-			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
-		}
-
-		return {
-			alias: alias,
-			name: intrinsicName,
-			value: value
-		};
-	}
-
-	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
-};
-
-var getIntrinsic = function GetIntrinsic(name, allowMissing) {
-	if (typeof name !== 'string' || name.length === 0) {
-		throw new $TypeError('intrinsic name must be a non-empty string');
-	}
-	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
-		throw new $TypeError('"allowMissing" argument must be a boolean');
-	}
-
-	if ($exec(/^%?[^%]*%?$/, name) === null) {
-		throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
-	}
-	var parts = stringToPath(name);
-	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
-
-	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
-	var intrinsicRealName = intrinsic.name;
-	var value = intrinsic.value;
-	var skipFurtherCaching = false;
-
-	var alias = intrinsic.alias;
-	if (alias) {
-		intrinsicBaseName = alias[0];
-		$spliceApply(parts, $concat([0, 1], alias));
-	}
-
-	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
-		var part = parts[i];
-		var first = $strSlice(part, 0, 1);
-		var last = $strSlice(part, -1);
-		if (
-			(
-				(first === '"' || first === "'" || first === '`')
-				|| (last === '"' || last === "'" || last === '`')
-			)
-			&& first !== last
-		) {
-			throw new $SyntaxError('property names with quotes must have matching quotes');
-		}
-		if (part === 'constructor' || !isOwn) {
-			skipFurtherCaching = true;
-		}
-
-		intrinsicBaseName += '.' + part;
-		intrinsicRealName = '%' + intrinsicBaseName + '%';
-
-		if (hasOwn(INTRINSICS, intrinsicRealName)) {
-			value = INTRINSICS[intrinsicRealName];
-		} else if (value != null) {
-			if (!(part in value)) {
-				if (!allowMissing) {
-					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
-				}
-				return void undefined$1;
-			}
-			if ($gOPD && (i + 1) >= parts.length) {
-				var desc = $gOPD(value, part);
-				isOwn = !!desc;
-
-				// By convention, when a data property is converted to an accessor
-				// property to emulate a data property that does not suffer from
-				// the override mistake, that accessor's getter is marked with
-				// an `originalValue` property. Here, when we detect this, we
-				// uphold the illusion by pretending to see that original data
-				// property, i.e., returning the value rather than the getter
-				// itself.
-				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
-					value = desc.get;
-				} else {
-					value = value[part];
-				}
-			} else {
-				isOwn = hasOwn(value, part);
-				value = value[part];
-			}
-
-			if (isOwn && !skipFurtherCaching) {
-				INTRINSICS[intrinsicRealName] = value;
-			}
-		}
-	}
-	return value;
-};
-
-var GetIntrinsic = getIntrinsic;
-
-var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
-
-var hasPropertyDescriptors$1 = function hasPropertyDescriptors() {
-	if ($defineProperty) {
-		try {
-			$defineProperty({}, 'a', { value: 1 });
-			return true;
-		} catch (e) {
-			// IE 8 has a broken defineProperty
-			return false;
-		}
-	}
-	return false;
-};
-
-hasPropertyDescriptors$1.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
-	// node v0.6 has a bug where array lengths can be Set but not Defined
-	if (!hasPropertyDescriptors$1()) {
-		return null;
-	}
-	try {
-		return $defineProperty([], 'length', { value: 1 }).length !== 1;
-	} catch (e) {
-		// In Firefox 4-22, defining length on an array throws an exception.
-		return true;
-	}
-};
-
-var hasPropertyDescriptors_1 = hasPropertyDescriptors$1;
-
-var keys = objectKeys;
-var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
-
-var toStr = Object.prototype.toString;
-var concat$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) {
-		if (predicate === true) {
-			if (object[name] === value) {
-				return;
-			}
-		} else if (!isFunction(predicate) || !predicate()) {
-			return;
-		}
-	}
-	if (supportsDescriptors) {
-		origDefineProperty(object, name, {
-			configurable: true,
-			enumerable: false,
-			value: value,
-			writable: true
-		});
-	} else {
-		object[name] = value; // eslint-disable-line no-param-reassign
-	}
-};
-
-var defineProperties$1 = function (object, map) {
-	var predicates = arguments.length > 2 ? arguments[2] : {};
-	var props = keys(map);
-	if (hasSymbols) {
-		props = concat$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 = function () { return polyfill; };
-
-defineProperties(getGlobal, {
-	getPolyfill: getPolyfill,
-	implementation: implementation,
-	shim: shim
-});
-
-var globalthis = getGlobal;
-
-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;
-var globalthis_1 = globalthis;
-var $$observable = ponyfill_1.default(globalthis_1.getPolyfill());
-var NO = {};
-xstream.NO = NO;
-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;
-    }
-}
-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;
-        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;
-    };
-    Merge.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._n(t);
-    };
-    Merge.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._e(err);
-    };
-    Merge.prototype._c = function () {
-        if (--this.ac <= 0) {
-            var u = this.out;
-            if (u === NO)
-                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)
-            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)
-            return;
-        out._e(err);
-    };
-    CombineListener.prototype._c = function () {
-        var p = this.p;
-        if (p.out === NO)
-            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;
-        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 ? --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;
-                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;
-        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;
-        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;
-    };
-    Debug.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            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)
-            return;
-        u._e(err);
-    };
-    Debug.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._c();
-    };
-    return Debug;
-}());
-var Drop = /** @class */ (function () {
-    function Drop(max, ins) {
-        this.type = 'drop';
-        this.ins = ins;
-        this.out = NO;
-        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;
-    };
-    Drop.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        if (this.dropped++ >= this.max)
-            u._n(t);
-    };
-    Drop.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._e(err);
-    };
-    Drop.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            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;
-        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;
-        this.oil = NO_IL;
-    };
-    EndWhen.prototype.end = function () {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._c();
-    };
-    EndWhen.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._n(t);
-    };
-    EndWhen.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            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;
-        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;
-    };
-    Filter.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        var r = _try(this, t, u);
-        if (r === NO || !r)
-            return;
-        u._n(t);
-    };
-    Filter.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._e(err);
-    };
-    Filter.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            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;
-        this.op.less();
-    };
-    return FlattenListener;
-}());
-var Flatten = /** @class */ (function () {
-    function Flatten(ins) {
-        this.type = 'flatten';
-        this.ins = ins;
-        this.out = NO;
-        this.open = true;
-        this.inner = NO;
-        this.il = NO_IL;
-    }
-    Flatten.prototype._start = function (out) {
-        this.out = out;
-        this.open = true;
-        this.inner = NO;
-        this.il = NO_IL;
-        this.ins._add(this);
-    };
-    Flatten.prototype._stop = function () {
-        this.ins._remove(this);
-        if (this.inner !== NO)
-            this.inner._remove(this.il);
-        this.out = NO;
-        this.open = true;
-        this.inner = NO;
-        this.il = NO_IL;
-    };
-    Flatten.prototype.less = function () {
-        var u = this.out;
-        if (u === NO)
-            return;
-        if (!this.open && this.inner === NO)
-            u._c();
-    };
-    Flatten.prototype._n = function (s) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        var _a = this, inner = _a.inner, il = _a.il;
-        if (inner !== NO && 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)
-            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;
-        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;
-        this.acc = this.seed;
-    };
-    Fold.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        var r = _try(this, t, u);
-        if (r === NO)
-            return;
-        u._n(this.acc = r);
-    };
-    Fold.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._e(err);
-    };
-    Fold.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._c();
-    };
-    return Fold;
-}());
-var Last = /** @class */ (function () {
-    function Last(ins) {
-        this.type = 'last';
-        this.ins = ins;
-        this.out = NO;
-        this.has = false;
-        this.val = NO;
-    }
-    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;
-        this.val = NO;
-    };
-    Last.prototype._n = function (t) {
-        this.has = true;
-        this.val = t;
-    };
-    Last.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._e(err);
-    };
-    Last.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            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;
-        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;
-    };
-    MapOp.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        var r = _try(this, t, u);
-        if (r === NO)
-            return;
-        u._n(r);
-    };
-    MapOp.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._e(err);
-    };
-    MapOp.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._c();
-    };
-    return MapOp;
-}());
-var Remember = /** @class */ (function () {
-    function Remember(ins) {
-        this.type = 'remember';
-        this.ins = ins;
-        this.out = NO;
-    }
-    Remember.prototype._start = function (out) {
-        this.out = out;
-        this.ins._add(out);
-    };
-    Remember.prototype._stop = function () {
-        this.ins._remove(this.out);
-        this.out = NO;
-    };
-    return Remember;
-}());
-var ReplaceError = /** @class */ (function () {
-    function ReplaceError(replacer, ins) {
-        this.type = 'replaceError';
-        this.ins = ins;
-        this.out = NO;
-        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;
-    };
-    ReplaceError.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._n(t);
-    };
-    ReplaceError.prototype._e = function (err) {
-        var u = this.out;
-        if (u === NO)
-            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)
-            return;
-        u._c();
-    };
-    return ReplaceError;
-}());
-var StartWith = /** @class */ (function () {
-    function StartWith(ins, val) {
-        this.type = 'startWith';
-        this.ins = ins;
-        this.out = NO;
-        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;
-    };
-    return StartWith;
-}());
-var Take = /** @class */ (function () {
-    function Take(max, ins) {
-        this.type = 'take';
-        this.ins = ins;
-        this.out = NO;
-        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;
-    };
-    Take.prototype._n = function (t) {
-        var u = this.out;
-        if (u === NO)
-            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)
-            return;
-        u._e(err);
-    };
-    Take.prototype._c = function () {
-        var u = this.out;
-        if (u === NO)
-            return;
-        u._c();
-    };
-    return Take;
-}());
-var Stream = /** @class */ (function () {
-    function Stream(producer) {
-        this._prod = producer || NO;
-        this._ils = [];
-        this._stopID = NO;
-        this._dl = NO;
-        this._d = false;
-        this._target = null;
-        this._err = NO;
-    }
-    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)
-            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)
-            this._prod._stop();
-        this._err = NO;
-        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;
-        this._stopID = NO;
-    };
-    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) {
-            clearTimeout(this._stopID);
-            this._stopID = NO;
-        }
-        else {
-            var p = this._prod;
-            if (p !== NO)
-                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 && a.length <= 0) {
-                this._err = NO;
-                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)
-            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;
-        }
-        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) {
-            if (this._has)
-                il._n(this._v);
-            clearTimeout(this._stopID);
-            this._stopID = NO;
-        }
-        else if (this._has)
-            il._n(this._v);
-        else {
-            var p = this._prod;
-            if (p !== NO)
-                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$3 = 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$3.Stream(new DropRepeatsOperator(ins, isEqual));
-    };
-}
-var _default$3 = 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$3())
-      .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$3())
-        .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$2 = 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$2.Stream(new DelayOperator(period, ins));
-    };
-}
-var _default$2 = delay$1.default = delay;
-
-var concat$1 = {};
-
-Object.defineProperty(concat$1, "__esModule", { value: true });
-var index_1$1 = 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$1.Stream(new ConcatProducer(streams));
-}
-var _default$1 = concat$1.default = concat;
-
-var debounce$1 = {};
-
-Object.defineProperty(debounce$1, "__esModule", { value: true });
-var index_1 = xstream;
-var DebounceOperator = /** @class */ (function () {
-    function DebounceOperator(dt, ins) {
-        this.dt = dt;
-        this.ins = ins;
-        this.type = 'debounce';
-        this.out = null;
-        this.id = null;
-        this.t = index_1.NO;
-    }
-    DebounceOperator.prototype._start = function (out) {
-        this.out = out;
-        this.ins._add(this);
-    };
-    DebounceOperator.prototype._stop = function () {
-        this.ins._remove(this);
-        this.out = null;
-        this.clearInterval();
-    };
-    DebounceOperator.prototype.clearInterval = function () {
-        var id = this.id;
-        if (id !== null) {
-            clearInterval(id);
-        }
-        this.id = null;
-    };
-    DebounceOperator.prototype._n = function (t) {
-        var _this = this;
-        var u = this.out;
-        if (!u)
-            return;
-        this.clearInterval();
-        this.t = t;
-        this.id = setInterval(function () {
-            _this.clearInterval();
-            u._n(t);
-            _this.t = index_1.NO;
-        }, this.dt);
-    };
-    DebounceOperator.prototype._e = function (err) {
-        var u = this.out;
-        if (!u)
-            return;
-        this.clearInterval();
-        u._e(err);
-    };
-    DebounceOperator.prototype._c = function () {
-        var u = this.out;
-        if (!u)
-            return;
-        this.clearInterval();
-        if (this.t != index_1.NO)
-            u._n(this.t);
-        this.t = index_1.NO;
-        u._c();
-    };
-    return DebounceOperator;
-}());
-/**
- * Delays events until a certain amount of silence has passed. If that timespan
- * of silence is not met the event is dropped.
- *
- * Marble diagram:
- *
- * ```text
- * --1----2--3--4----5|
- *     debounce(60)
- * -----1----------4--|
- * ```
- *
- * Example:
- *
- * ```js
- * import fromDiagram from 'xstream/extra/fromDiagram'
- * import debounce from 'xstream/extra/debounce'
- *
- * const stream = fromDiagram('--1----2--3--4----5|')
- *  .compose(debounce(60))
- *
- * stream.addListener({
- *   next: i => console.log(i),
- *   error: err => console.error(err),
- *   complete: () => console.log('completed')
- * })
- * ```
- *
- * ```text
- * > 1
- * > 4
- * > completed
- * ```
- *
- * @param {number} period The amount of silence required in milliseconds.
- * @return {Stream}
- */
-function debounce(period) {
-    return function debounceOperator(ins) {
-        return new index_1.Stream(new DebounceOperator(period, ins));
-    };
-}
-var _default = debounce$1.default = debounce;
-
-const ENVIRONMENT = ((typeof window != 'undefined' && window) || (process && process.env)) || {};
-
-
-const BOOTSTRAP_ACTION  = 'BOOTSTRAP';
-const INITIALIZE_ACTION = 'INITIALIZE';
-const HYDRATE_ACTION    = 'HYDRATE';
-const PARENT_SINK_NAME  = 'PARENT';
-const CHILD_SOURCE_NAME = 'CHILD';
-
-
-let COMPONENT_COUNT   = 0;
-
-
-const ABORT$1 = '~#~#~ABORT~#~#~';
-
-function component (opts) {
-  const { name, sources, isolateOpts, stateSourceName='STATE' } = opts;
-
-  if (sources && !isObj(sources)) {
-    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';
-  let returnFunction;
-
-  if (isObj(fixedIsolateOpts)) {
-    const wrapped = (sources) => {
-      const fixedOpts = { ...opts, sources };
-      return (new Component(fixedOpts)).sinks
-    };
-    returnFunction = currySources ? isolate(wrapped, fixedIsolateOpts) : isolate(wrapped, fixedIsolateOpts)(sources);
-  } else {
-    returnFunction = currySources ? (sources) => (new Component({ ...opts, sources })).sinks : (new Component(opts)).sinks;
-  }
-
-  returnFunction.componentName = name;
-  returnFunction.isSygnalComponent = true;
-
-  return returnFunction
-}
-
-
-
-
-
-class Component {
-  // [ PASSED PARAMETERS ]
-  // name
-  // sources
-  // intent
-  // model
-  // context
-  // view
-  // peers
-  // components
-  // initialState
-  // calculated
-  // storeCalculatedInState
-  // DOMSourceName
-  // stateSourceName
-  // requestSourceName
-  // debug
-
-  // [ PRIVATE / CALCULATED VALUES ]
-  // sourceNames
-  // intent$
-  // action$
-  // model$
-  // context$
-  // peers$
-  // childSources
-  // vdom$
-  // currentState
-  // currentProps
-  // currentChildren
-  // currentContext
-  // subComponentSink$
-  // unmountRequest$ <- TODO
-  // unmount() <- TODO
-  // _debug
-
-  // [ INSTANTIATED STREAM OPERATOR ]
-  // log
-
-  // [ OUTPUT ]
-  // sinks
-
-  constructor({ name='NO NAME', sources, intent, model, hmrActions, context, response, view, peers={}, components={}, initialState, calculated, storeCalculatedInState=true, DOMSourceName='DOM', stateSourceName='STATE', requestSourceName='HTTP', debug=false }) {
-    if (!sources || !isObj(sources)) throw new Error('Missing or invalid sources')
-
-    this.name       = name;
-    this.sources    = sources;
-    this.intent     = intent;
-    this.model      = model;
-    this.hmrActions = hmrActions;
-    this.context    = context;
-    this.response   = response;
-    this.view       = view;
-    this.peers      = peers;
-    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._debug            = debug;
-
-    this.isSubComponent = this.sourceNames.includes('props$');
-
-    const state$ = sources[stateSourceName] && sources[stateSourceName].stream;
-
-    if (state$) {
-      this.currentState = initialState || {};
-      this.sources[stateSourceName] = new StateSource(state$.map(val => {
-        this.currentState = val;
-        return val
-      }));
-    }
-
-    const props$ = sources.props$;
-    if (props$) {
-      this.sources.props$ = props$.map(val => {
-        const { sygnalFactory, sygnalOptions, ...sanitizedProps } = val;
-        this.currentProps = sanitizedProps;
-        return val
-      });
-    }
-
-    const children$ = sources.children$;
-    if (children$) {
-      this.sources.children$ = children$.map(val => {
-        this.currentChildren = val;
-        return val
-      });
-    }
-
-
-    // Ensure that the root component has an intent and model
-    // This is necessary to ensure that the component tree's state sink is subscribed to
-    if (!this.isSubComponent && 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
-      };
-    }
-
-    const componentNumber = COMPONENT_COUNT++;
-
-    this.addCalculated = this.createMemoizedAddCalculated();
-    this.log = makeLog(`${componentNumber} | ${name}`);
-
-    this.initChildSources$();
-    this.initIntent$();
-    this.initHmrActions();
-    this.initAction$();
-    this.initState();
-    this.initContext();
-    this.initModel$();
-    this.initPeers$();
-    this.initSubComponentSink$();
-    this.initSubComponentsRendered$();
-    this.initVdom$();
-    this.initSinks();
-
-    this.sinks.__index = componentNumber;
-
-    this.log(`Instantiated`, true);
-  }
-
-  get debug() {
-    return this._debug || (ENVIRONMENT.SYGNAL_DEBUG === 'true' || ENVIRONMENT.SYGNAL_DEBUG === true)
-  }
-
-  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) && (!isObj(this.intent$))) {
-      throw new Error('Intent must return either an action$ stream or map of event streams')
-    }
-  }
-
-  initHmrActions() {
-    if (typeof this.hmrActions === 'undefined') {
-      this.hmrAction$ = xs$1.of().filter(_ => false);
-      return
-    }
-    if (typeof this.hmrActions === 'string') {
-      this.hmrActions = [this.hmrActions];
-    }
-    if (!Array.isArray(this.hmrActions)) {
-      throw new Error(`[${ this.name }] hmrActions must be the name of an action or an array of names of actions to run when a component is hot-reloaded`)
-    }
-    if (this.hmrActions.some(action => typeof action !== 'string')) {
-      throw new Error(`[${ this.name }] hmrActions must be the name of an action or an array of names of actions to run when a component is hot-reloaded`)
-    }
-    this.hmrAction$ = xs$1.fromArray(this.hmrActions.map(action => ({ type: action })));
-  }
-
-  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 bootstrap$ = xs$1.of({ type: BOOTSTRAP_ACTION }).compose(_default$2(10));
-    const hmrAction$ = window?.__SYGNAL_HMR_UPDATING === true ? this.hmrAction$ : xs$1.of().filter(_ => false);
-    const wrapped$   = (this.model[BOOTSTRAP_ACTION] && window?.__SYGNAL_HMR_UPDATING !== true) ? _default$1(bootstrap$, action$) : _default$1(xs$1.of().compose(_default$2(1)).filter(_ => false), hmrAction$, action$);
-
-
-    let initialApiData;
-    if (window?.__SYGNAL_HMR_UPDATING !== true && 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 }) => `<${ type }> Action triggered`));
-  }
-
-  initState() {
-    if (this.model !== undefined) {
-      if (this.model[INITIALIZE_ACTION] === undefined) {
-        this.model[INITIALIZE_ACTION] = {
-          [this.stateSourceName]: (_, data) => ({ ...this.addCalculated(data) })
-        };
-      } else if (isObj(this.model[INITIALIZE_ACTION])) {
-        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];
-          }
-        });
-      }
-    }
-  }
-
-  initContext() {
-    if (!this.context && !this.sources.__parentContext$) {
-      this.context$ = xs$1.of({});
-      return
-    }
-
-    const state$ = this.sources[this.stateSourceName]?.stream.startWith({}).compose(_default$3(objIsEqual)) || xs$1.never();
-    const parentContext$ = this.sources.__parentContext$?.startWith({}).compose(_default$3(objIsEqual)) || xs$1.of({});
-    if (this.context && !isObj(this.context)) {
-      console.error(`[${this.name}] Context must be an object mapping names to values of functions: ignoring provided ${ typeof this.context }`);
-    }
-    this.context$ = xs$1.combine(state$, parentContext$)
-      .map(([_, parent]) => {
-        const _parent = isObj(parent) ? parent : {};
-        const context = isObj(this.context) ? this.context : {};
-        const state = this.currentState;
-        const values = Object.entries(context).reduce((acc, current) => {
-          const [name, value] = current;
-          let _value;
-          const valueType = typeof value;
-          if (valueType === 'string') {
-            _value = state[value];
-          } else if (valueType === 'boolean') {
-            _value = state[name];
-          } else if (valueType === 'function') {
-            _value = value(state);
-          } else {
-            console.error(`[${ this.name }] Invalid context entry '${ name }': must be the name of a state property or a function returning a value to use`);
-            return acc
-          }
-          acc[name] = _value;
-          return acc
-        }, {});
-        const newContext = { ..._parent, ...values };
-        this.currentContext = newContext;
-        return newContext
-      })
-      .compose(_default$3(objIsEqual))
-      .startWith({});
-    this.context$.subscribe({ next: _ => _ });
-  }
-
-  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 };
-    if (this.isSubComponent && this.initialState) {
-      console.warn(`[${ this.name }] Initial state provided to sub-component. This will overwrite any state provided by the parent component.`);
-    }
-    const shimmed$ = (this.initialState && window?.__SYGNAL_HMR_UPDATING !== true) ? _default$1(xs$1.of(initial), this.action$).compose(_default$2(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 (!isObj(sinks)) {
-        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 isParentSink = (sink === PARENT_SINK_NAME);
-
-        const on  = isStateSink ? onState() : onNormal();
-        const on$ = isParentSink ? on(action, reducer).map(value => ({ name: this.name, value })) : on(action, reducer);
-
-        const wrapped$ = on$
-          .compose(this.log(data => {
-            if (isStateSink) {
-              return `<${ action }> State reducer added`
-            } else if (isParentSink) {
-              return `<${ action }> Data sent to parent component: ${ JSON.stringify(data.value).replaceAll('"', '') }`
-            } else {
-              const extra = data && (data.type || data.command || data.name || data.key || (Array.isArray(data) && 'Array') || data);
-              return `<${ action }> Data sent to [${ sink }]: ${ JSON.stringify(extra).replaceAll('"', '') }`
-            }
-          }));
-
-        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$;
-  }
-
-  initPeers$() {
-    const initial = this.sourceNames.reduce((acc, name) => {
-      if (name == this.DOMSourceName) {
-        acc[name] = {};
-      } else {
-        acc[name] = [];
-      }
-      return acc
-    }, {});
-
-    this.peers$ = Object.entries(this.peers).reduce((acc, [peerName, peerFactory]) => {
-      const peer$ = peerFactory(this.sources);
-      this.sourceNames.forEach(source => {
-        if (source == this.DOMSourceName) {
-          acc[source][peerName] = peer$[source];
-        } else {
-          acc[source].push(peer$[source]);
-        }
-      });
-      return acc
-    }, initial);
-  }
-
-  initChildSources$() {
-    let newSourcesNext;
-    const childSources$ = xs$1.create({
-      start: listener => {
-        newSourcesNext = listener.next.bind(listener);
-      },
-      stop: _ => {
-
-      }
-    }).map(sources => xs$1.merge(...sources)).flatten();
-
-    this.sources[CHILD_SOURCE_NAME] = {
-      select: (name) => {
-        const all$ = childSources$;
-        const filtered$ = name ? all$.filter(entry => entry.name === name) : all$;
-        const unwrapped$ = filtered$.map(entry => entry.value);
-        return unwrapped$
-      }
-    };
-
-    this.newChildSources = (sources) => {
-      if (typeof newSourcesNext === 'function') newSourcesNext(sources);
-    };
-  }
-
-  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.triggerSubComponentsRendered = 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(params => {
-        const { props, state, children, context, ...peers } = params;
-        const { sygnalFactory, sygnalOptions, ...sanitizedProps} = props || {};
-        return this.view({ ...sanitizedProps, state, children, context, peers }, state, context, peers)
-      })
-      .compose(this.log('View rendered'))
-      .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$ && name !== PARENT_SINK_NAME) ? 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.peers$[name] || []));
-      } else {
-        acc[name] = xs$1.merge((this.model$[name] || xs$1.never()), subComponentSink$, ...(this.peers$[name] || []));
-      }
-      return acc
-    }, {});
-
-    this.sinks[this.DOMSourceName] = this.vdom$;
-    this.sinks[PARENT_SINK_NAME] = this.model$[PARENT_SINK_NAME] || xs$1.never();
-  }
-
-  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, delay=10) => {
-            if (typeof delay !== 'number') throw new Error(`[${ this.name } ] Invalid delay value provided to next() function in model action '${ name }'. Must be a number in ms.`)
-            // 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 });
-            }, delay);
-            this.log(`<${ name }> Triggered a next() action: <${ type }> ${ delay }ms delay`, true);
-          };
-
-          const props = { ...this.currentProps, children: this.currentChildren, context: this.currentContext };
-
-          let data = action.data;
-          if (isStateSink) {
-            return (state) => {
-              const _state = this.isSubComponent ? this.currentState : state;
-              const enhancedState = this.addCalculated(_state);
-              props.state = enhancedState;
-              const newState = reducer(enhancedState, data, next, props);
-              if (newState == ABORT$1) return _state
-              return this.cleanupCalculated(newState)
-            }
-          } else {
-            const enhancedState = this.addCalculated(this.currentState);
-            props.state = enhancedState;
-            const reduced = reducer(enhancedState, data, next, props);
-            const type = typeof reduced;
-            if (isObj(reduced) || ['string', 'number', 'boolean', 'function'].includes(type)) return reduced
-            if (type == 'undefined') {
-              console.warn(`'undefined' value sent to ${ name }`);
-              return reduced
-            }
-            throw new Error(`Invalid reducer type for ${ name } ${ type }`)
-          }
-        }).filter(result => result != ABORT$1);
-      } else if (reducer === undefined || reducer === true) {
-        returnStream$ = filtered$.map(({data}) => data);
-      } else {
-        const value = reducer;
-        returnStream$ = filtered$.mapTo(value);
-      }
-
-      return returnStream$
-    }
-  }
-
-  createMemoizedAddCalculated() {
-    let lastState;
-    let lastResult;
-
-    return function(state) {
-      if (!this.calculated || !isObj(state) || Array.isArray(state)) return state
-      if (state === lastState) {
-        return lastResult
-      }
-      if (!isObj(this.calculated)) throw new Error(`'calculated' parameter must be an object mapping calculated state field named to functions`)
-
-      const calculated = this.getCalculatedValues(state);
-      if (!calculated) {
-        lastState = state;
-        lastResult = state;
-        return state
-      }
-
-      const newState = { ...state, ...calculated };
-
-      lastState = state;
-      lastResult = newState;
-
-      return newState
-    }
-  }
-
-  getCalculatedValues(state) {
-    const entries = Object.entries(this.calculated || {});
-    if (entries.length === 0) {
-      return
-    }
-    return 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
-    }, {})
-  }
-
-  cleanupCalculated(incomingState) {
-    if (!incomingState || !isObj(incomingState) || Array.isArray(incomingState)) return incomingState
-    const state = this.storeCalculatedInState ? this.addCalculated(incomingState) : incomingState;
-    const copy  = { ...state };
-    if (!this.calculated || this.storeCalculatedInState) return copy
-    const keys = Object.keys(this.calculated);
-    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.peers$[this.DOMSourceName] };
-
-    const enhancedState = state && state.isolateSource(state, { get: state => this.addCalculated(state) });
-    const stateStream   = (enhancedState && enhancedState.stream) || xs$1.never();
-
-    
-    renderParams.state  = stateStream.compose(_default$3(objIsEqual));
-
-    if (this.sources.props$) {
-      renderParams.props = this.sources.props$.compose(_default$3(propsIsEqual));
-    }
-
-    if (this.sources.children$) {
-      renderParams.children = this.sources.children$.compose(_default$3(objIsEqual));
-    }
-
-    if (this.context$) {
-      renderParams.context = this.context$.compose(_default$3(objIsEqual));
-    }
-
-    const names   = [];
-    const streams = [];
-
-    Object.entries(renderParams).forEach(([name, stream]) => {
-      names.push(name);
-      streams.push(stream);
-    });
-
-    const combined = xs$1.combine(...streams)
-      .compose(_default(1))
-      // map the streams from an array back to an object with the render parameter names as the keys
-      .map(arr => {
-        const params = names.reduce((acc, name, index) => {
-          acc[name] = arr[index];
-          if (name === 'state') {
-            acc[this.stateSourceName] = arr[index];
-            acc.calculated = (arr[index] && this.getCalculatedValues(arr[index])) || {};
-          }
-          return acc
-        }, {});
-        return params
-      });
-
-    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 childSources = [];
-      let newInstanceCount = 0;
-
-      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;
-
-        const addSinks = (sinks) => {
-          Object.entries(sinks).forEach(([name, stream]) => {
-            sinkArrsByType[name] ||= [];
-            if (name === PARENT_SINK_NAME) {
-              childSources.push(stream);
-            } else if (name !== this.DOMSourceName) {
-              sinkArrsByType[name].push(stream);
-            }
-          });
-        };
-
-
-        if (previousComponents[id]) {
-          const entry = previousComponents[id];
-          acc[id] = entry;
-          entry.props$.shamefullySendNext(props);
-          entry.children$.shamefullySendNext(children);
-          addSinks(entry.sink$);
-          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);
-        }
-
-        newInstanceCount++;
-
-        const sink$ = instantiator(el, props$, children$);
-
-        sink$[this.DOMSourceName] = sink$[this.DOMSourceName] ? this.makeCoordinatedSubComponentDomSink(sink$[this.DOMSourceName]) : xs$1.never();
-
-        acc[id] = { sink$, props$, children$ };
-
-        addSinks(sink$);
-
-        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);
-      this.newChildSources(childSources);
-
-
-      if (newInstanceCount > 0) this.log(`New sub components instantiated: ${ newInstanceCount }`, true);
-
-      return newComponents
-    }, {})
-  }
-
-  makeCoordinatedSubComponentDomSink(domSink$) {
-    const remembered$   = domSink$.remember();
-
-    const coordinated = this.sources[this.stateSourceName].stream
-      .compose(_default$3(objIsEqual))
-      .map(state => remembered$)
-      .flatten()
-      .debug(_ => this.triggerSubComponentsRendered())
-      .remember();
-
-    return coordinated
-  }
-
-  instantiateCollection(el, props$, children$) {
-    const data      = el.data;
-    const props     = data.props || {};
-    let filter      = typeof props.filter === 'function' ? props.filter : undefined;
-    let sort        = sortFunctionFromProp(props.sort);
-
-    const arrayOperators = {
-      filter,
-      sort
-    };
-    
-    const state$ = xs$1.combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$.startWith(props))
-      // this debounce is important. it forces state and prop updates to happen at the same time
-      // without this, changes to sort or filter won't happen properly
-      .compose(_default(1))
-      .map(([state, props]) => {
-        if (props.filter !== arrayOperators.filter) {
-          arrayOperators.filter = typeof props.filter === 'function' ? props.filter : undefined;
-        }
-        if (props.sort !== arrayOperators.sort) {
-          arrayOperators.sort = sortFunctionFromProp(props.sort);
-        }
-        
-        return isObj(state) ? this.addCalculated(state) : state
-      });
-
-    const stateSource  = new StateSource(state$);
-    const stateField   = props.from;
-    const collectionOf = props.of;
-    const idField      = props.idfield || 'id';
-
-    let lense;
-    let factory;
-
-    if (typeof collectionOf === 'function') {
-      if (collectionOf.isSygnalComponent) {
-        factory = collectionOf;
-      } else {
-        const name = collectionOf.componentName || collectionOf.label || collectionOf.name || 'FUNCTION_COMPONENT';
-        const view = collectionOf;
-        const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug } = collectionOf;
-        const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug };
-        factory = component(options);
-      }
-    } else if (this.components[collectionOf]) {
-      factory = this.components[collectionOf];
-    } else {
-      throw new Error(`[${this.name}] Invalid 'of' propery in collection: ${ collectionOf }`)
-    }
-
-    const fieldLense = {
-      get: state => {
-        if (!Array.isArray(state[stateField])) return []
-        const items = state[stateField];
-        const filtered = typeof arrayOperators.filter === 'function' ? items.filter(arrayOperators.filter) : items;
-        const sorted = typeof arrayOperators.sort ? filtered.sort(arrayOperators.sort) : filtered;
-        const mapped = sorted.map((item, index) => {
-          return (isObj(item)) ? { ...item, [idField]: item[idField] || index } : { value: item, [idField]: index }
-        });
-
-        return mapped
-      },
-      set: (oldState, newState) => {
-        if (this.calculated && stateField in this.calculated) {
-          console.warn(`Collection sub-component of ${ this.name } attempted to update state on a calculated field '${ stateField }': Update ignored`);
-          return oldState
-        }
-        const updated = [];
-        for (const oldItem of oldState[stateField].map((item, index) => (isObj(item) ? { ...item, [idField]: item[idField] || index } : { __primitive: true, value: item, [idField]: index }))) {
-          if (typeof arrayOperators.filter === 'function' && !arrayOperators.filter(oldItem)) {
-            updated.push(oldItem.__primitive ? oldItem.value : oldItem);
-          } else {
-            const newItem = newState.find(item => item[idField] === oldItem[idField]);
-            if (typeof newItem !== 'undefined') updated.push(oldItem.__primitive ? newItem.value : newItem);
-          }
-        }
-        return { ...oldState, [stateField]: updated }
-      }
-    };
-
-    if (stateField === undefined) {
-      lense = {
-        get: state => {
-          if (!(state instanceof Array) && state.value && state.value instanceof Array) return state.value
-          return state
-        },
-        set: (oldState, newState) => {
-          return newState
-        }
-      };
-    } else if (typeof stateField === 'string') {
-      if (isObj(this.currentState)) {
-        if(!(this.currentState && stateField in this.currentState) && !(this.calculated && stateField in this.calculated)) {
-          console.error(`Collection component in ${ this.name } is attempting to use non-existent state property '${ stateField }': To fix this error, specify a valid array property on the state.  Attempting to use parent component state.`);
-          lense = undefined;
-        } else if (!Array.isArray(this.currentState[stateField])) {
-          console.warn(`State property '${ stateField }' in collection comopnent of ${ this.name } is not an array: No components will be instantiated in the collection.`);
-          lense = fieldLense;
-        } else {
-          lense = fieldLense;
-        }
-      } else {
-        if (!Array.isArray(this.currentState[stateField])) {
-          console.warn(`State property '${ stateField }' in collection component of ${ this.name } is not an array: No components will be instantiated in the collection.`);
-          lense = fieldLense;
-        } else {
-          lense = fieldLense;
-        }
-      }
-    } else if (isObj(stateField)) {
-      if (typeof stateField.get !== 'function') {
-        console.error(`Collection component in ${ this.name } has an invalid 'from' field: Expecting 'undefined', a string indicating an array property in the state, or an object with 'get' and 'set' functions for retrieving and setting child state from the current state. Attempting to use parent component state.`);
-        lense = undefined;
-      } else {
-        lense = {
-          get: (state) => {
-            const newState = stateField.get(state);
-            if (!Array.isArray(newState)) {
-              console.warn(`State getter function in collection component of ${ this.name } did not return an array: No components will be instantiated in the collection. Returned value:`, newState);
-              return []
-            }
-            return newState
-          },
-          set: stateField.set
-        };
-      }
-    } else {
-      console.error(`Collection component in ${ this.name } has an invalid 'from' field: Expecting 'undefined', a string indicating an array property in the state, or an object with 'get' and 'set' functions for retrieving and setting child state from the current state. Attempting to use parent component state.`);
-      lense = undefined;
-    }
-
-    const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$, __parentContext$: this.context$, PARENT: null };
-    const sink$   = collection(factory, lense, { container: null })(sources);
-    if (!isObj(sink$)) {
-      throw new Error('Invalid sinks returned from component factory of collection element')
-    }
-    return sink$
-  }
-
-  instantiateSwitchable(el, props$, children$) {
-    const data      = el.data;
-    const props     = data.props  || {};
-
-    const state$ = this.sources[this.stateSourceName].stream.startWith(this.currentState)
-      .map((state) => {
-        return isObj(state) ? this.addCalculated(state) : state
-      });
-
-    const stateSource = new StateSource(state$);
-    const stateField  = props.state;
-    let lense;
-
-    const fieldLense = {
-      get: state => 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
-        }
-        if (!isObj(newState) || Array.isArray(newState)) return { ...oldState, [stateField]: newState }
-        return { ...oldState, [stateField]: newState }
-      }
-    };
-
-    const baseLense = {
-      get: state => state,
-      set: (oldState, newState) => newState
-    };
-
-    if (typeof stateField === 'undefined') {
-      lense = baseLense;
-    } else if (typeof stateField === 'string') {
-      lense = fieldLense;
-    } else if (isObj(stateField)) {
-      if (typeof stateField.get !== 'function') {
-        console.error(`Switchable component in ${ this.name } has an invalid 'state' field: Expecting 'undefined', a string indicating an array property in the state, or an object with 'get' and 'set' functions for retrieving and setting sub-component state from the current state. Attempting to use parent component state.`);
-        lense = baseLense;
-      } else {
-        lense = { get: stateField.get, set: stateField.set };
-      }
-    } else {
-      console.error(`Invalid state provided to switchable sub-component of ${ this.name }: Expecting string, object, or undefined, but found ${ typeof stateField }. Attempting to use parent component state.`);
-      lense = baseLense;
-    }
-
-    const switchableComponents = props.of;
-    const keys = Object.keys(switchableComponents);
-    keys.forEach(key => {
-      const current = switchableComponents[key];
-      if (!current.isSygnalComponent) {
-        const name = current.componentName || current.label || current.name || 'FUNCTION_COMPONENT';
-        const view = current;
-        const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug } = current;
-        const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug };
-        switchableComponents[key] = component(options);
-      }
-    });
-    const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$, __parentContext$: this.context$ };
-
-    const sink$ = isolate(switchable(switchableComponents, props$.map(props => props.current)), { [this.stateSourceName]: lense })(sources);
-
-    if (!isObj(sink$)) {
-      throw new Error('Invalid sinks returned from component factory of switchable element')
-    }
-
-    return sink$
-  }
-
-  instantiateCustomComponent(el, props$, children$) {
-    const componentName = el.sel;
-    const data      = el.data;
-    const props     = data.props  || {};
-
-    const state$ = this.sources[this.stateSourceName].stream.startWith(this.currentState)
-      .map((state) => {
-        return isObj(state) ? this.addCalculated(state) : state
-      });
-
-    const stateSource = new StateSource(state$);
-    const stateField  = props.state;
-
-    if (typeof props.sygnalFactory !== 'function' && isObj(props.sygnalOptions)) {
-      props.sygnalFactory = component(props.sygnalOptions);
-    }
-
-    const factory   = componentName === 'sygnal-factory' ? props.sygnalFactory : (this.components[componentName] || props.sygnalFactory);
-    if (!factory) {
-      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 lense;
-
-    const fieldLense = {
-      get: state => state[stateField],
-      set: (oldState, newState) => {
-        if (this.calculated && stateField in this.calculated) {
-          console.warn(`Sub-component of ${ this.name } attempted to update state on a calculated field '${ stateField }': Update ignored`);
-          return oldState
-        }
-        return { ...oldState, [stateField]: newState }
-      }
-    };
-
-    const baseLense = {
-      get: state => state,
-      set: (oldState, newState) => newState
-    };
-
-    if (typeof stateField === 'undefined') {
-      lense = baseLense;
-    } else if (typeof stateField === 'string') {
-      lense = fieldLense;
-    } else if (isObj(stateField)) {
-      if (typeof stateField.get !== 'function') {
-        console.error(`Sub-component in ${ this.name } has an invalid 'state' field: Expecting 'undefined', a string indicating an array property in the state, or an object with 'get' and 'set' functions for retrieving and setting sub-component state from the current state. Attempting to use parent component state.`);
-        lense = baseLense;
-      } else {
-        lense = { get: stateField.get, set: stateField.set };
-      }
-    } else {
-      console.error(`Invalid state provided to sub-component of ${ this.name }: Expecting string, object, or undefined, but found ${ typeof stateField }. Attempting to use parent component state.`);
-      lense = baseLense;
-    }
-
-    const sources = { ...this.sources, [this.stateSourceName]: stateSource, props$, children$, __parentContext$: this.context$ };
-    const sink$   = isolate(factory, { [this.stateSourceName]: lense })(sources);
-
-    if (!isObj(sink$)) {
-      const name = componentName === 'sygnal-factory' ? 'custom element' : componentName;
-      throw new Error('Invalid sinks returned from component factory:', name)
-    }
-
-    return sink$
-  }
-
-  renderVdom(componentInstances$) {
-    return xs$1.combine(this.subComponentsRendered$, componentInstances$)
-      .compose(_default(1))
-      .map(([_, components]) => {
-        const componentNames = Object.keys(this.components);
-
-        const root  = components['::ROOT::'];
-        const entries = Object.entries(components).filter(([id]) => id !== '::ROOT::');
-
-        if (entries.length === 0) {
-          return xs$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(1))
-          .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()
-  }
-
-}
-
-
-
-
-
-
-
-/**
- * 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, immediate=false) {
-    const fixedMsg = (typeof msg === 'function') ? msg : _ => msg;
-    if (immediate) {
-      if (this.debug) {
-        console.log(`[${context}] ${fixedMsg(msg)}`);
-      }
-      return
-    } else {
-      return stream => {
-        return stream.debug(msg => {
-          if (this.debug) {
-            console.log(`[${context}] ${fixedMsg(msg)}`);
-          }
-        })
-      }
-    }
-  }
-}
-
-
-
-function getComponents(currentElement, componentNames, depth=0, index=0, parentId) {
-  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(sel)) || typeof currentElement.data?.props?.sygnalFactory === 'function' || isObj(currentElement.data?.props?.sygnalOptions);
-  const props        = (currentElement.data && currentElement.data.props) || {};
-  (currentElement.data && currentElement.data.attrs) || {};
-  const children     = currentElement.children || [];
-
-  let found    = {};
-  
-  let id = parentId;
-  if (isComponent) {
-    id  = getComponentIdFromElement(currentElement, depth, index, parentId);
-    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 props.from !== 'undefined' && !(typeof props.from === 'string' || Array.isArray(props.from) || typeof props.from.get === 'function')) console.warn(`No valid array found for collection ${ typeof props.of === 'string' ? props.of : 'function component' }: no collection components will be created`, props.from);
-      currentElement.data.isCollection = true;
-      currentElement.data.props ||= {};
-    } else if (isSwitchable) {
-      if (!props.of)        throw new Error(`Switchable element missing required 'of' property`)
-      if (!isObj(props.of)) throw new Error(`Invalid 'of' 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 ;
-    if (typeof props.key === 'undefined') currentElement.data.props.key = id;
-    found[id] = currentElement;
-  }
-
-  if (children.length > 0) {
-    children.map((child, i) => getComponents(child, componentNames, depth + 1, index + i, id))
-            .forEach((child) => {
-              Object.entries(child).forEach(([id, el]) => found[id] = el);
-            });
-  }
-
-  return found
-}
-
-function injectComponents(currentElement, components, componentNames, depth=0, index=0, parentId) {
-  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' || isObj(currentElement.data?.props?.sygnalOptions);
-  const isCollection = currentElement?.data?.isCollection;
-  const isSwitchable = currentElement?.data?.isSwitchable;
-  (currentElement.data && currentElement.data.props) || {};
-  const children     = currentElement.children || [];
-
-  let id = parentId;
-  if (isComponent) {
-    id  = getComponentIdFromElement(currentElement, depth, index, parentId);
-    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, index + i, id)).flat();
-    return currentElement
-  } else {
-    return currentElement
-  }
-}
-
-function getComponentIdFromElement(el, depth, index, parentId) {
-  const sel    = el.sel;
-  const name   = typeof sel === 'string' ? sel : 'functionComponent';
-  const uid    = `${depth}:${index}`;
-  const props  = el.data?.props || {};
-  const id     = (props.id && JSON.stringify(props.id).replaceAll('"', '')) || uid;
-  const parentString = parentId ? `${ parentId }|` : '';
-  const fullId = `${ parentString }${ 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 propsIsEqual(obj1, obj2) {
-  return objIsEqual(sanitizeObject(obj1))
-}
-
-function objIsEqual(obj1, obj2, maxDepth = 5, depth = 0) {
-  // Base case: if the current depth exceeds maxDepth, return true
-  if (depth > maxDepth) {
-      return false;
-  }
-
-  // If both are the same object or are both exactly null or undefined
-  if (obj1 === obj2) {
-      return true;
-  }
-
-  // If either is not an object (null, undefined, or primitive), directly compare
-  if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
-      return false;
-  }
-
-  // Special handling for arrays
-  if (Array.isArray(obj1) && Array.isArray(obj2)) {
-    if (obj1.length !== obj2.length) {
-        return false;
-    }
-    for (let i = 0; i < obj1.length; i++) {
-        if (!objIsEqual(obj1[i], obj2[i], maxDepth, depth + 1)) {
-            return false;
-        }
-    }
-    return true;
-  }
-
-  // Get keys of both objects
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-
-  // Check if the number of properties is different
-  if (keys1.length !== keys2.length) {
-      return false;
-  }
-
-  // Recursively check each property
-  for (const key of keys1) {
-      if (!keys2.includes(key)) {
-          return false;
-      }
-      if (!objIsEqual(obj1[key], obj2[key], maxDepth, depth + 1)) {
-          return false;
-      }
-  }
-
-  return true;
-}
-
-function sanitizeObject(obj) {
-  if (!isObj(obj)) return obj
-  const {state, of, from, filter, ...sanitized} = obj;
-  return sanitized
-}
-
-function isObj(obj) {
-  return typeof obj === 'object' && obj !== null && !Array.isArray(obj)
-}
-
-function __baseSort(a, b, ascending=true) {
-  const direction = ascending ? 1 : -1;
-  switch(true) {
-    case a > b: return 1 * direction
-    case a < b: return -1 * direction
-    default: return 0
-  }
-}
-
-function __sortFunctionFromObj(item) {
-  const entries = Object.entries(item);
-  if (entries.length > 1) {
-    console.error('Sort objects can only have one key:', item);
-    return undefined
-  }
-  const entry = entries[0];
-  const [field, directionRaw] = entry;
-  if (!['string', 'number'].includes(typeof directionRaw)) {
-    console.error('Sort object properties must be a string or number:', item);
-    return undefined
-  }
-  let ascending = true;
-  if (typeof directionRaw === 'string') {
-    if (!['asc', 'dec'].includes(directionRaw.toLowerCase())) {
-      console.error('Sort object string values must be asc or dec:', item);
-      return undefined
-    }
-    ascending = directionRaw.toLowerCase() === 'asc';
-  }
-  if (typeof directionRaw === 'number') {
-    if (directionRaw !== 1 && directionRaw !== -1) {
-      console.error('Sort object number values must be 1 or -1:', item);
-      return undefined
-    }
-    ascending = directionRaw === 1;
-  }
-  return (a, b) => __baseSort(a[field], b[field], ascending)
-}
-
-function sortFunctionFromProp(sortProp) {
-  if (!sortProp) return undefined
-  const propType = typeof sortProp;
-  // if function do nothing
-  if (propType === 'function') return sortProp
-  if (propType === 'string') {
-    // if passed either 'asc' or 'dec' sort on the entire item
-    if (sortProp.toLowerCase() === 'asc' || sortProp.toLowerCase() === 'dec') {
-      const ascending = sortProp.toLowerCase() === 'asc';
-      return (a, b) => __baseSort(a, b, ascending)
-    }
-    // assume it's a field/property name, and sort it ascending
-    const field = sortProp;
-    return (a, b) => __baseSort(a[field], b[field], true)
-  } else if (Array.isArray(sortProp)) {
-    const sorters = sortProp.map(item => {
-      if (typeof item === 'function') return item
-      if (typeof item === 'string' && !['asc', 'dec'].includes(item.toLowerCase())) return (a, b) => __baseSort(a[item], b[item], true)
-      if (isObj(item)) {
-        return __sortFunctionFromObj(item)
-      }
-    });
-    
-    return (a, b) => sorters.filter(sorter => typeof sorter === 'function').reduce((comparisonSoFar, currentSorter) => {
-      if (comparisonSoFar !== 0) return comparisonSoFar
-      return currentSorter(a, b)
-    }, 0)
-  } else if (isObj(sortProp)) {
-    return __sortFunctionFromObj(sortProp)
-  } else {
-    console.error('Invalid sort option (ignoring):', item);
-    return undefined
-  }
-}
-
-function run(app, drivers={}, options={}) {
-  const { mountPoint='#root', fragments=true, useDefaultDrivers=true } = options;
-  if (!app.isSygnalComponent) {
-    const name = app.name || app.componentName || app.label || "FUNCTIONAL_COMPONENT";
-    const view = app;
-    const { model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug } = app;
-    const options = { name, view, model, intent, hmrActions, context, peers, components, initialState, calculated, storeCalculatedInState, DOMSourceName, stateSourceName, debug };
-
-    app = component(options);
-  }
-
-  const wrapped = withState(app, 'STATE');
-
-  const baseDrivers = useDefaultDrivers ? {
-    EVENTS: eventBusDriver,
-    DOM:    makeDOMDriver(mountPoint, { snabbdomOptions: { experimental: { fragments } } }),
-    LOG:    logDriver
-  } : {};
-
-  const combinedDrivers = { ...baseDrivers, ...drivers };
-
-  const { sources, sinks, run: _run } = setup(wrapped, combinedDrivers);
-  const dispose = _run();
-
-  const exposed = { sources, sinks, dispose };
-
-  const hmr = (newComponent) => {
-    exposed.sinks.STATE.shamefullySendNext((state) => {
-      window.__SYGNAL_HMR_UPDATING = true;
-      exposed.dispose();
-      const App = newComponent.default;
-      App.initialState = state;
-      const updated = run(App, drivers);
-      exposed.sources = updated.sources;
-      exposed.sinks = updated.sinks;
-      exposed.dispose = updated.dispose;
-      updated.sinks.STATE.shamefullySendNext(() => {
-        return { ...state }
-      });
-      updated.sources.STATE.stream.setDebugListener({
-        next: () => {
-          exposed.sources.STATE.stream.setDebugListener(null);
-          setTimeout(() => {
-            window.__SYGNAL_HMR_UPDATING = false;
-          }, 100);
-        }
-      });
-      return ABORT
-    });
-  };
-
-  exposed.hmr = hmr;
-
-  return exposed
-}
-
-function looksLikeSygnalComponent(Component) {
-  if (typeof Component !== 'function') return false
-  return Boolean(
-    Component.isSygnalComponent ||
-      Component.model ||
-      Component.intent ||
-      Component.initialState ||
-      Component.componentName
-  )
-}
-
-var client = (element) => {
-  return async (Component, props, _slotted, metadata) => {
-    if (!looksLikeSygnalComponent(Component)) return
-
-    const mountPoint = element;
-    const { client } = metadata || {};
-    const canHydrate = element.hasAttribute('ssr');
-
-    if (client !== 'only' && !canHydrate) return
-
-    const previous = element.__sygnal;
-    if (previous && typeof previous.dispose === 'function') {
-      previous.dispose();
-    }
-
-    const Wrapped = (args) => Component({ ...args, props: { ...(props || {}) } });
-    Wrapped.model = Component.model;
-    Wrapped.intent = Component.intent;
-    Wrapped.hmrActions = Component.hmrActions;
-    Wrapped.context = Component.context;
-    Wrapped.peers = Component.peers;
-    Wrapped.components = Component.components;
-    Wrapped.initialState = Component.initialState;
-    Wrapped.calculated = Component.calculated;
-    Wrapped.storeCalculatedInState = Component.storeCalculatedInState;
-    Wrapped.DOMSourceName = Component.DOMSourceName;
-    Wrapped.stateSourceName = Component.stateSourceName;
-    Wrapped.debug = Component.debug;
-    Wrapped.componentName = Component.componentName || Component.name;
-
-    const app = run(Wrapped, {}, { mountPoint });
-    element.__sygnal = app;
-  }
-};
-
-export { client as default };