sygnal 5.4.0 → 6.0.0

package/dist/astro/server.cjs.js

@@ -2,6 +2,2968 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var onError = require('virtual:sygnal/astro-on-error');
+
+function _mergeNamespaces(n, m) {
+    m.forEach(function (e) {
+        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+            if (k !== 'default' && !(k in n)) {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    });
+    return Object.freeze(n);
+}
+
+/*
+ * Tiny helpers shared by the core and the helper modules (behaviors, undo, the dev entry), kept
+ * out of the core so importing them never pulls it in.
+ */
+/** The "no change / send nothing" sentinel (a registered symbol: the same in every copy) */
+/**
+ * PLAN-4 GS-9 / G-214: one part of a uid() path (a child's path or `id` prop, a Collection item
+ * key, a Switchable page name), encoded injectively into [A-Za-z0-9_]: letters and digits stay,
+ * anything else (including '_' and '-') becomes '_<UTF-16 code>_' ('0.2' → '0_46_2', 'a_b' →
+ * 'a_95_b'), so the '-' between parts is unambiguous too. renderToString encodes the same way
+ * (ssr.ts).
+ */
+const uidPart = (s) => (s + '').replace(/\W|_/g, c => '_' + c.charCodeAt(0) + '_');
+/**
+ * PLAN-5 A-1: a Collection item's style with its view-transition name and class
+ * (`viewTransitionName="card"`): `card-<id>`, the id escaped as uidPart does (a valid CSS
+ * identifier, unique per id), and the class `card`; the item's own style wins, except its
+ * `undefined` values (G-418: no value is no override; snabbdom would leave the old one). The
+ * core's Collection host and SSR share it
+ */
+const vtStyle = (p, id, style) => {
+    const o = { viewTransitionName: p + '-' + uidPart(id), viewTransitionClass: p };
+    for (const k in style)
+        if (style[k] !== undefined)
+            o[k] = style[k];
+    return o;
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var xstream = {};
+
+var ponyfill$1 = {};
+
+(function (exports) {
+
+	Object.defineProperty(exports, "__esModule", {
+		value: true
+	});
+	exports['default'] = symbolObservablePonyfill;
+	function symbolObservablePonyfill(root) {
+		var result;
+		var _Symbol = root.Symbol;
+
+		if (typeof _Symbol === 'function') {
+			if (_Symbol.observable) {
+				result = _Symbol.observable;
+			} else {
+
+				// This just needs to be something that won't trample other user's Symbol.for use
+				// It also will guide people to the source of their issues, if this is problematic.
+				// META: It's a resource locator!
+				result = _Symbol['for']('https://github.com/benlesh/symbol-observable');
+				try {
+					_Symbol.observable = result;
+				} catch (err) {
+					// Do nothing. In some environments, users have frozen `Symbol` for security reasons,
+					// if it is frozen assigning to it will throw. In this case, we don't care, because
+					// they will need to use the returned value from the ponyfill.
+				}
+			}
+		} else {
+			result = '@@observable';
+		}
+
+		return result;
+	}} (ponyfill$1));
+
+var ponyfill = ponyfill$1;
+
+var toStr$2 = Object.prototype.toString;
+
+var isArguments = function isArguments(value) {
+	var str = toStr$2.call(value);
+	var isArgs = str === '[object Arguments]';
+	if (!isArgs) {
+		isArgs = str !== '[object Array]' &&
+			value !== null &&
+			typeof value === 'object' &&
+			typeof value.length === 'number' &&
+			value.length >= 0 &&
+			toStr$2.call(value.callee) === '[object Function]';
+	}
+	return isArgs;
+};
+
+var implementation$5;
+var hasRequiredImplementation;
+
+function requireImplementation () {
+	if (hasRequiredImplementation) return implementation$5;
+	hasRequiredImplementation = 1;
+
+	var keysShim;
+	if (!Object.keys) {
+		// modified from https://github.com/es-shims/es5-shim
+		var has = Object.prototype.hasOwnProperty;
+		var toStr = Object.prototype.toString;
+		var isArgs = isArguments; // eslint-disable-line global-require
+		var isEnumerable = Object.prototype.propertyIsEnumerable;
+		var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
+		var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
+		var dontEnums = [
+			'toString',
+			'toLocaleString',
+			'valueOf',
+			'hasOwnProperty',
+			'isPrototypeOf',
+			'propertyIsEnumerable',
+			'constructor'
+		];
+		var equalsConstructorPrototype = function (o) {
+			var ctor = o.constructor;
+			return ctor && ctor.prototype === o;
+		};
+		var excludedKeys = {
+			$applicationCache: true,
+			$console: true,
+			$external: true,
+			$frame: true,
+			$frameElement: true,
+			$frames: true,
+			$innerHeight: true,
+			$innerWidth: true,
+			$onmozfullscreenchange: true,
+			$onmozfullscreenerror: true,
+			$outerHeight: true,
+			$outerWidth: true,
+			$pageXOffset: true,
+			$pageYOffset: true,
+			$parent: true,
+			$scrollLeft: true,
+			$scrollTop: true,
+			$scrollX: true,
+			$scrollY: true,
+			$self: true,
+			$webkitIndexedDB: true,
+			$webkitStorageInfo: true,
+			$window: true
+		};
+		var hasAutomationEqualityBug = (function () {
+			/* global window */
+			if (typeof window === 'undefined') { return false; }
+			for (var k in window) {
+				try {
+					if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
+						try {
+							equalsConstructorPrototype(window[k]);
+						} catch (e) {
+							return true;
+						}
+					}
+				} catch (e) {
+					return true;
+				}
+			}
+			return false;
+		}());
+		var equalsConstructorPrototypeIfNotBuggy = function (o) {
+			/* global window */
+			if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
+				return equalsConstructorPrototype(o);
+			}
+			try {
+				return equalsConstructorPrototype(o);
+			} catch (e) {
+				return false;
+			}
+		};
+
+		keysShim = function keys(object) {
+			var isObject = object !== null && typeof object === 'object';
+			var isFunction = toStr.call(object) === '[object Function]';
+			var isArguments = isArgs(object);
+			var isString = isObject && toStr.call(object) === '[object String]';
+			var theKeys = [];
+
+			if (!isObject && !isFunction && !isArguments) {
+				throw new TypeError('Object.keys called on a non-object');
+			}
+
+			var skipProto = hasProtoEnumBug && isFunction;
+			if (isString && object.length > 0 && !has.call(object, 0)) {
+				for (var i = 0; i < object.length; ++i) {
+					theKeys.push(String(i));
+				}
+			}
+
+			if (isArguments && object.length > 0) {
+				for (var j = 0; j < object.length; ++j) {
+					theKeys.push(String(j));
+				}
+			} else {
+				for (var name in object) {
+					if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+						theKeys.push(String(name));
+					}
+				}
+			}
+
+			if (hasDontEnumBug) {
+				var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+
+				for (var k = 0; k < dontEnums.length; ++k) {
+					if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
+						theKeys.push(dontEnums[k]);
+					}
+				}
+			}
+			return theKeys;
+		};
+	}
+	implementation$5 = keysShim;
+	return implementation$5;
+}
+
+var slice$1 = Array.prototype.slice;
+var isArgs = isArguments;
+
+var origKeys = Object.keys;
+var keysShim = origKeys ? function keys(o) { return origKeys(o); } : requireImplementation();
+
+var originalKeys = Object.keys;
+
+keysShim.shim = function shimObjectKeys() {
+	if (Object.keys) {
+		var keysWorksWithArguments = (function () {
+			// Safari 5.0 bug
+			var args = Object.keys(arguments);
+			return args && args.length === arguments.length;
+		}(1, 2));
+		if (!keysWorksWithArguments) {
+			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
+				if (isArgs(object)) {
+					return originalKeys(slice$1.call(object));
+				}
+				return originalKeys(object);
+			};
+		}
+	} else {
+		Object.keys = keysShim;
+	}
+	return Object.keys || keysShim;
+};
+
+var objectKeys = keysShim;
+
+/* eslint complexity: [2, 18], max-statements: [2, 33] */
+var shams = function hasSymbols() {
+	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
+	if (typeof Symbol.iterator === 'symbol') { return true; }
+
+	var obj = {};
+	var sym = Symbol('test');
+	var symObj = Object(sym);
+	if (typeof sym === 'string') { return false; }
+
+	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
+	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
+
+	// temp disabled per https://github.com/ljharb/object.assign/issues/17
+	// if (sym instanceof Symbol) { return false; }
+	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
+	// if (!(symObj instanceof Symbol)) { return false; }
+
+	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
+	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
+
+	var symVal = 42;
+	obj[sym] = symVal;
+	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
+	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
+
+	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
+
+	var syms = Object.getOwnPropertySymbols(obj);
+	if (syms.length !== 1 || syms[0] !== sym) { return false; }
+
+	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
+
+	if (typeof Object.getOwnPropertyDescriptor === 'function') {
+		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
+	}
+
+	return true;
+};
+
+var origSymbol = typeof Symbol !== 'undefined' && Symbol;
+var hasSymbolSham = shams;
+
+var hasSymbols$2 = function hasNativeSymbols() {
+	if (typeof origSymbol !== 'function') { return false; }
+	if (typeof Symbol !== 'function') { return false; }
+	if (typeof origSymbol('foo') !== 'symbol') { return false; }
+	if (typeof Symbol('bar') !== 'symbol') { return false; }
+
+	return hasSymbolSham();
+};
+
+var test = {
+	foo: {}
+};
+
+var $Object = Object;
+
+var hasProto$1 = function hasProto() {
+	return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
+};
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var slice = Array.prototype.slice;
+var toStr$1 = Object.prototype.toString;
+var funcType = '[object Function]';
+
+var implementation$4 = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr$1.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slice.call(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                args.concat(slice.call(arguments))
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        } else {
+            return target.apply(
+                that,
+                args.concat(slice.call(arguments))
+            );
+        }
+    };
+
+    var boundLength = Math.max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs.push('$' + i);
+    }
+
+    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};
+
+var implementation$3 = implementation$4;
+
+var functionBind = Function.prototype.bind || implementation$3;
+
+var bind$1 = functionBind;
+
+var src = bind$1.call(Function.call, Object.prototype.hasOwnProperty);
+
+var undefined$1;
+
+var $SyntaxError = SyntaxError;
+var $Function = Function;
+var $TypeError = TypeError;
+
+// eslint-disable-next-line consistent-return
+var getEvalledConstructor = function (expressionSyntax) {
+	try {
+		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
+	} catch (e) {}
+};
+
+var $gOPD = Object.getOwnPropertyDescriptor;
+if ($gOPD) {
+	try {
+		$gOPD({}, '');
+	} catch (e) {
+		$gOPD = null; // this is IE 8, which has a broken gOPD
+	}
+}
+
+var throwTypeError = function () {
+	throw new $TypeError();
+};
+var ThrowTypeError = $gOPD
+	? (function () {
+		try {
+			// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
+			arguments.callee; // IE 8 does not throw here
+			return throwTypeError;
+		} catch (calleeThrows) {
+			try {
+				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
+				return $gOPD(arguments, 'callee').get;
+			} catch (gOPDthrows) {
+				return throwTypeError;
+			}
+		}
+	}())
+	: throwTypeError;
+
+var hasSymbols$1 = hasSymbols$2();
+var hasProto = hasProto$1();
+
+var getProto = Object.getPrototypeOf || (
+	hasProto
+		? function (x) { return x.__proto__; } // eslint-disable-line no-proto
+		: null
+);
+
+var needsEval = {};
+
+var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined$1 : getProto(Uint8Array);
+
+var INTRINSICS = {
+	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
+	'%Array%': Array,
+	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
+	'%ArrayIteratorPrototype%': hasSymbols$1 && getProto ? getProto([][Symbol.iterator]()) : undefined$1,
+	'%AsyncFromSyncIteratorPrototype%': undefined$1,
+	'%AsyncFunction%': needsEval,
+	'%AsyncGenerator%': needsEval,
+	'%AsyncGeneratorFunction%': needsEval,
+	'%AsyncIteratorPrototype%': needsEval,
+	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
+	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
+	'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined$1 : BigInt64Array,
+	'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined$1 : BigUint64Array,
+	'%Boolean%': Boolean,
+	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
+	'%Date%': Date,
+	'%decodeURI%': decodeURI,
+	'%decodeURIComponent%': decodeURIComponent,
+	'%encodeURI%': encodeURI,
+	'%encodeURIComponent%': encodeURIComponent,
+	'%Error%': Error,
+	'%eval%': eval, // eslint-disable-line no-eval
+	'%EvalError%': EvalError,
+	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
+	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
+	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
+	'%Function%': $Function,
+	'%GeneratorFunction%': needsEval,
+	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
+	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
+	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
+	'%isFinite%': isFinite,
+	'%isNaN%': isNaN,
+	'%IteratorPrototype%': hasSymbols$1 && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
+	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
+	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
+	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$1 || !getProto ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
+	'%Math%': Math,
+	'%Number%': Number,
+	'%Object%': Object,
+	'%parseFloat%': parseFloat,
+	'%parseInt%': parseInt,
+	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
+	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
+	'%RangeError%': RangeError,
+	'%ReferenceError%': ReferenceError,
+	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
+	'%RegExp%': RegExp,
+	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
+	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$1 || !getProto ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
+	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
+	'%String%': String,
+	'%StringIteratorPrototype%': hasSymbols$1 && getProto ? getProto(''[Symbol.iterator]()) : undefined$1,
+	'%Symbol%': hasSymbols$1 ? Symbol : undefined$1,
+	'%SyntaxError%': $SyntaxError,
+	'%ThrowTypeError%': ThrowTypeError,
+	'%TypedArray%': TypedArray,
+	'%TypeError%': $TypeError,
+	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
+	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
+	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
+	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
+	'%URIError%': URIError,
+	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
+	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
+	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
+};
+
+if (getProto) {
+	try {
+		null.error; // eslint-disable-line no-unused-expressions
+	} catch (e) {
+		// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
+		var errorProto = getProto(getProto(e));
+		INTRINSICS['%Error.prototype%'] = errorProto;
+	}
+}
+
+var doEval = function doEval(name) {
+	var value;
+	if (name === '%AsyncFunction%') {
+		value = getEvalledConstructor('async function () {}');
+	} else if (name === '%GeneratorFunction%') {
+		value = getEvalledConstructor('function* () {}');
+	} else if (name === '%AsyncGeneratorFunction%') {
+		value = getEvalledConstructor('async function* () {}');
+	} else if (name === '%AsyncGenerator%') {
+		var fn = doEval('%AsyncGeneratorFunction%');
+		if (fn) {
+			value = fn.prototype;
+		}
+	} else if (name === '%AsyncIteratorPrototype%') {
+		var gen = doEval('%AsyncGenerator%');
+		if (gen && getProto) {
+			value = getProto(gen.prototype);
+		}
+	}
+
+	INTRINSICS[name] = value;
+
+	return value;
+};
+
+var LEGACY_ALIASES = {
+	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
+	'%ArrayPrototype%': ['Array', 'prototype'],
+	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
+	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
+	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
+	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
+	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
+	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
+	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
+	'%BooleanPrototype%': ['Boolean', 'prototype'],
+	'%DataViewPrototype%': ['DataView', 'prototype'],
+	'%DatePrototype%': ['Date', 'prototype'],
+	'%ErrorPrototype%': ['Error', 'prototype'],
+	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
+	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
+	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
+	'%FunctionPrototype%': ['Function', 'prototype'],
+	'%Generator%': ['GeneratorFunction', 'prototype'],
+	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
+	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
+	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
+	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
+	'%JSONParse%': ['JSON', 'parse'],
+	'%JSONStringify%': ['JSON', 'stringify'],
+	'%MapPrototype%': ['Map', 'prototype'],
+	'%NumberPrototype%': ['Number', 'prototype'],
+	'%ObjectPrototype%': ['Object', 'prototype'],
+	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
+	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
+	'%PromisePrototype%': ['Promise', 'prototype'],
+	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
+	'%Promise_all%': ['Promise', 'all'],
+	'%Promise_reject%': ['Promise', 'reject'],
+	'%Promise_resolve%': ['Promise', 'resolve'],
+	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
+	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
+	'%RegExpPrototype%': ['RegExp', 'prototype'],
+	'%SetPrototype%': ['Set', 'prototype'],
+	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
+	'%StringPrototype%': ['String', 'prototype'],
+	'%SymbolPrototype%': ['Symbol', 'prototype'],
+	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
+	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
+	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
+	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
+	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
+	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
+	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
+	'%URIErrorPrototype%': ['URIError', 'prototype'],
+	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
+	'%WeakSetPrototype%': ['WeakSet', 'prototype']
+};
+
+var bind = functionBind;
+var hasOwn = src;
+var $concat = bind.call(Function.call, Array.prototype.concat);
+var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+var $replace = bind.call(Function.call, String.prototype.replace);
+var $strSlice = bind.call(Function.call, String.prototype.slice);
+var $exec = bind.call(Function.call, RegExp.prototype.exec);
+
+/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
+var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
+var stringToPath = function stringToPath(string) {
+	var first = $strSlice(string, 0, 1);
+	var last = $strSlice(string, -1);
+	if (first === '%' && last !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
+	} else if (last === '%' && first !== '%') {
+		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
+	}
+	var result = [];
+	$replace(string, rePropName, function (match, number, quote, subString) {
+		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
+	});
+	return result;
+};
+/* end adaptation */
+
+var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
+	var intrinsicName = name;
+	var alias;
+	if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+		alias = LEGACY_ALIASES[intrinsicName];
+		intrinsicName = '%' + alias[0] + '%';
+	}
+
+	if (hasOwn(INTRINSICS, intrinsicName)) {
+		var value = INTRINSICS[intrinsicName];
+		if (value === needsEval) {
+			value = doEval(intrinsicName);
+		}
+		if (typeof value === 'undefined' && !allowMissing) {
+			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
+		}
+
+		return {
+			alias: alias,
+			name: intrinsicName,
+			value: value
+		};
+	}
+
+	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
+};
+
+var getIntrinsic = function GetIntrinsic(name, allowMissing) {
+	if (typeof name !== 'string' || name.length === 0) {
+		throw new $TypeError('intrinsic name must be a non-empty string');
+	}
+	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
+		throw new $TypeError('"allowMissing" argument must be a boolean');
+	}
+
+	if ($exec(/^%?[^%]*%?$/, name) === null) {
+		throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');
+	}
+	var parts = stringToPath(name);
+	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';
+
+	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
+	var intrinsicRealName = intrinsic.name;
+	var value = intrinsic.value;
+	var skipFurtherCaching = false;
+
+	var alias = intrinsic.alias;
+	if (alias) {
+		intrinsicBaseName = alias[0];
+		$spliceApply(parts, $concat([0, 1], alias));
+	}
+
+	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+		var part = parts[i];
+		var first = $strSlice(part, 0, 1);
+		var last = $strSlice(part, -1);
+		if (
+			(
+				(first === '"' || first === "'" || first === '`')
+				|| (last === '"' || last === "'" || last === '`')
+			)
+			&& first !== last
+		) {
+			throw new $SyntaxError('property names with quotes must have matching quotes');
+		}
+		if (part === 'constructor' || !isOwn) {
+			skipFurtherCaching = true;
+		}
+
+		intrinsicBaseName += '.' + part;
+		intrinsicRealName = '%' + intrinsicBaseName + '%';
+
+		if (hasOwn(INTRINSICS, intrinsicRealName)) {
+			value = INTRINSICS[intrinsicRealName];
+		} else if (value != null) {
+			if (!(part in value)) {
+				if (!allowMissing) {
+					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
+				}
+				return void undefined$1;
+			}
+			if ($gOPD && (i + 1) >= parts.length) {
+				var desc = $gOPD(value, part);
+				isOwn = !!desc;
+
+				// By convention, when a data property is converted to an accessor
+				// property to emulate a data property that does not suffer from
+				// the override mistake, that accessor's getter is marked with
+				// an `originalValue` property. Here, when we detect this, we
+				// uphold the illusion by pretending to see that original data
+				// property, i.e., returning the value rather than the getter
+				// itself.
+				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
+					value = desc.get;
+				} else {
+					value = value[part];
+				}
+			} else {
+				isOwn = hasOwn(value, part);
+				value = value[part];
+			}
+
+			if (isOwn && !skipFurtherCaching) {
+				INTRINSICS[intrinsicRealName] = value;
+			}
+		}
+	}
+	return value;
+};
+
+var GetIntrinsic = getIntrinsic;
+
+var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
+
+var hasPropertyDescriptors$1 = function hasPropertyDescriptors() {
+	if ($defineProperty) {
+		try {
+			$defineProperty({}, 'a', { value: 1 });
+			return true;
+		} catch (e) {
+			// IE 8 has a broken defineProperty
+			return false;
+		}
+	}
+	return false;
+};
+
+hasPropertyDescriptors$1.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+	// node v0.6 has a bug where array lengths can be Set but not Defined
+	if (!hasPropertyDescriptors$1()) {
+		return null;
+	}
+	try {
+		return $defineProperty([], 'length', { value: 1 }).length !== 1;
+	} catch (e) {
+		// In Firefox 4-22, defining length on an array throws an exception.
+		return true;
+	}
+};
+
+var hasPropertyDescriptors_1 = hasPropertyDescriptors$1;
+
+var keys = objectKeys;
+var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+
+var toStr = Object.prototype.toString;
+var concat = 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.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 });
+var NO_IL_1 = xstream.NO_IL = NO_1 = xstream.NO = MemoryStream_1 = xstream.MemoryStream = Stream_1 = xstream.Stream = void 0;
+var ponyfill_1 = ponyfill;
+var globalthis_1 = globalthis;
+var $$observable = ponyfill_1.default(globalthis_1.getPolyfill());
+var NO = {};
+var NO_1 = 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,
+};
+NO_IL_1 = xstream.NO_IL = NO_IL;
+// mutates the input
+function internalizeProducer(producer) {
+    producer._start = function _start(il) {
+        il.next = il._n;
+        il.error = il._e;
+        il.complete = il._c;
+        this.start(il);
+    };
+    producer._stop = producer.stop;
+}
+var StreamSub = /** @class */ (function () {
+    function StreamSub(_stream, _listener) {
+        this._stream = _stream;
+        this._listener = _listener;
+    }
+    StreamSub.prototype.unsubscribe = function () {
+        this._stream._remove(this._listener);
+    };
+    return StreamSub;
+}());
+var Observer = /** @class */ (function () {
+    function Observer(_listener) {
+        this._listener = _listener;
+    }
+    Observer.prototype.next = function (value) {
+        this._listener._n(value);
+    };
+    Observer.prototype.error = function (err) {
+        this._listener._e(err);
+    };
+    Observer.prototype.complete = function () {
+        this._listener._c();
+    };
+    return Observer;
+}());
+var FromObservable = /** @class */ (function () {
+    function FromObservable(observable) {
+        this.type = 'fromObservable';
+        this.ins = observable;
+        this.active = false;
+    }
+    FromObservable.prototype._start = function (out) {
+        this.out = out;
+        this.active = true;
+        this._sub = this.ins.subscribe(new Observer(out));
+        if (!this.active)
+            this._sub.unsubscribe();
+    };
+    FromObservable.prototype._stop = function () {
+        if (this._sub)
+            this._sub.unsubscribe();
+        this.active = false;
+    };
+    return FromObservable;
+}());
+var Merge = /** @class */ (function () {
+    function Merge(insArr) {
+        this.type = 'merge';
+        this.insArr = insArr;
+        this.out = NO;
+        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;
+}());
+var Stream_1 = 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));
+var MemoryStream_1 = xstream.MemoryStream = MemoryStream;
+var xs$1 = Stream;
+var _default = xstream.default = xs$1;
+
+var xstreamNamespace = /*#__PURE__*/_mergeNamespaces({
+    __proto__: null,
+    get MemoryStream () { return MemoryStream_1; },
+    get NO () { return NO_1; },
+    get NO_IL () { return NO_IL_1; },
+    get Stream () { return Stream_1; },
+    default: _default
+}, [xstream]);
+
+function resolveInteropDefault(namespaceValue) {
+    if (namespaceValue &&
+        namespaceValue.default &&
+        namespaceValue.default.default &&
+        typeof namespaceValue.default.default === 'function') {
+        return namespaceValue.default.default;
+    }
+    if (namespaceValue && namespaceValue.default) {
+        return namespaceValue.default;
+    }
+    return namespaceValue;
+}
+function getXs(namespaceValue) {
+    const value = resolveInteropDefault(namespaceValue);
+    if (value &&
+        value.default &&
+        typeof value.default.create === 'function') {
+        return value.default;
+    }
+    return value;
+}
+const xs = getXs(xstreamNamespace);
+Stream_1 ||
+    (_default && _default.Stream) ||
+    (xs && xs.Stream);
+
+const DOCS_BASE_URL = 'https://sygnal.js.org';
+const CODE_SEVERITY = {
+    SYG101: 'warn',
+    SYG102: 'info',
+    SYG103: 'info',
+    SYG104: 'warn',
+    SYG105: 'info',
+    SYG106: 'warn',
+    SYG110: 'warn',
+    SYG111: 'warn',
+    SYG201: 'warn',
+    SYG202: 'warn',
+    SYG301: 'error',
+    SYG401: 'warn',
+    SYG900: 'warn',
+    // ---- 1E retrofit codes (SYG206-299, 402-499, 601-699, 901-999) ----
+    SYG206: 'error',
+    SYG207: 'warn',
+    SYG208: 'warn',
+    SYG209: 'error',
+    SYG210: 'warn',
+    SYG211: 'error',
+    SYG212: 'error',
+    SYG213: 'warn',
+    SYG214: 'error',
+    SYG215: 'error',
+    SYG216: 'error',
+    SYG217: 'warn',
+    SYG218: 'error',
+    SYG219: 'warn',
+    SYG220: 'warn',
+    SYG402: 'error',
+    SYG403: 'error',
+    SYG404: 'error',
+    SYG405: 'error',
+    SYG406: 'error',
+    SYG407: 'error',
+    SYG408: 'error',
+    SYG409: 'warn',
+    SYG410: 'error',
+    SYG411: 'error',
+    SYG412: 'error',
+    SYG413: 'error',
+    SYG414: 'error',
+    SYG415: 'error',
+    SYG416: 'error',
+    SYG417: 'warn',
+    SYG418: 'error',
+    SYG419: 'error',
+    SYG420: 'error',
+    SYG601: 'error',
+    SYG602: 'error',
+    SYG603: 'error',
+    SYG604: 'error',
+    SYG605: 'error',
+    SYG606: 'error',
+    SYG607: 'error',
+    SYG608: 'warn',
+    SYG609: 'warn',
+    SYG610: 'error',
+    SYG901: 'error',
+    SYG902: 'error',
+    SYG903: 'error',
+    // ---- end 1E retrofit codes ----
+};
+function docsUrlFor(code) {
+    return `${DOCS_BASE_URL}/reference/errors#${code.toLowerCase()}`;
+}
+
+class DiagnosticError extends Error {
+    constructor(diagnostic) {
+        super(diagnostic.text);
+        this.diagnostic = diagnostic;
+    }
+}
+let mode = 'off';
+let enabled = false;
+let ignored = new Set();
+let listeners = [];
+let checks = [];
+function resolveDiagnosticsMode() {
+    mode = (globalThis.__SYGNAL_DEV__ === true ? 'warn' : 'off');
+    enabled = mode !== 'off';
+    return mode;
+}
+function getDiagnosticsMode() {
+    return mode;
+}
+function isDiagnosticsEnabled() {
+    return enabled;
+}
+const nameOf = (c) => (c && typeof c === 'object' ? c.name : c) || undefined;
+const sentence = (s) => /[.!?]$/.test(s) ? s : s + '.';
+function formatDiagnostic(code, details) {
+    const name = nameOf(details.component);
+    return `[Sygnal ${code}] ${name ? name + ': ' : ''}${sentence(details.message)}` +
+        (details.fix ? ' ' + sentence(details.fix) : '') + ' ' + docsUrlFor(code);
+}
+function report(code, details) {
+    if (!enabled || ignored.has(code))
+        return;
+    const severity = details.severity || CODE_SEVERITY[code] || 'warn';
+    const d = {
+        code,
+        severity,
+        component: nameOf(details.component),
+        message: details.message,
+        fix: details.fix,
+        data: details.data,
+        docsUrl: docsUrlFor(code),
+        get text() { return formatDiagnostic(code, this); },
+        timestamp: Date.now(),
+    };
+    listeners.forEach(cb => { try {
+        cb(d);
+    }
+    catch (_) { } });
+    if (severity !== 'info') {
+        if (mode === 'error')
+            throw new DiagnosticError(d);
+        if (mode === 'warn')
+            console[severity](d.text);
+    }
+    return d;
+}
+function registerCheck(check) {
+    checks = [...checks, check];
+    return () => { checks = checks.filter(c => c !== check); };
+}
+const defaultAsyncThrow = (err) => {
+    const raise = () => { throw err; };
+    typeof queueMicrotask === 'function' ? queueMicrotask(raise) : setTimeout(raise);
+};
+let asyncThrow = defaultAsyncThrow;
+const hook = (name) => (component, ...args) => {
+    for (const check of checks) {
+        if (!enabled && !check.always)
+            continue;
+        try {
+            check[name]?.(component, ...args);
+        }
+        catch (err) {
+            // Never throw into the stream pipeline: 'error'-mode diagnostics (also a
+            // SYG900 escalated by 'error' mode) are rethrown asynchronously.
+            try {
+                if (err instanceof DiagnosticError)
+                    throw err;
+                report('SYG900', {
+                    component,
+                    message: `Diagnostics check '${check.id}' threw in ${name}: ${err?.message}`,
+                    data: { check: check.id, hook: name, error: err },
+                });
+            }
+            catch (e) {
+                asyncThrow(e);
+            }
+        }
+    }
+};
+const onIntent = hook('onIntent');
+const onModel = hook('onModel');
+const onRender = hook('onRender');
+const onReducer = hook('onReducer');
+const onDispose = hook('onDispose');
+/**
+ * (PLAN-2 E2) The sources object a component's intent is called with: `component.sources`,
+ * wrapped by every active check with a `sources` hook (the dev entry's SYG609 check,
+ * renderComponent's fake sources). Without such a check it is `component.sources` itself.
+ */
+function sourcesFor(component) {
+    let s = component.sources;
+    for (const check of checks) {
+        if (!check.sources || (!enabled && !check.always))
+            continue;
+        try {
+            s = check.sources(component, s) || s;
+        }
+        catch (_) { }
+    }
+    return s;
+}
+globalThis.__SYGNAL_DIAGNOSTICS__ = { registerCheck, report, hooks: { onIntent, onModel, onRender, onReducer, onDispose, sourcesFor, on: isDiagnosticsEnabled } };
+resolveDiagnosticsMode();
+
+const emit = (severity) => (code, component, message, fix, ...extra) => {
+    const details = { component, message, fix, severity, data: extra[0] };
+    const mode = getDiagnosticsMode();
+    if (mode === 'off') {
+        console[severity](formatDiagnostic(code, details), ...extra);
+        return;
+    }
+    try {
+        const d = report(code, details);
+        if (d && mode === 'collect' && severity === 'error')
+            console.error(d.text, ...extra);
+        else if (d && mode === 'warn' && extra.length)
+            console[severity](...extra);
+    }
+    catch (err) {
+        setTimeout(() => { throw err; });
+    }
+};
+const error = emit('error');
+globalThis.__SYGNAL_DIAGNOSTICS__.error = error;
+
+const isObj = (o) => o !== null && typeof o == 'object' && !Array.isArray(o);
+
+/**
+ * PLAN-4.6 core: state cells (03-proposal §4). Pull-based views of the one state tree,
+ * memoized on the parent value's identity. A write goes straight to the parent (no reducer
+ * wrappers climbing the tree); the root's (or an isolated instance's local) write commits.
+ *
+ * | cell  | get                                        | set                                     |
+ * | root  | app.state                                  | app.state = v; commit                   |
+ * | key   | parent.get()[k] (or a default, isolated)   | parent.set({...p, [k]: v}); SYG409 when k is a calculated field of the parent |
+ * | lens  | lens.get(parent.get())                     | parent.set(lens.set(p, v))              |
+ * | local | its own value; the parent's until written  | own value; commit (isolatedState)       |
+ *
+ * Calculated fields (and `idle` defaults) are a decorator: get() adds them, memoized per input
+ * identity and per declared dependency values; set() stores them (the only behaviour after D164).
+ * Children read through their parent's decorated cell, so they see its calculated fields, and a
+ * child's write stores freshly computed ones (4-F).
+ */
+// ------------------------------------------------------------------ Collection items
+/**
+ * An item's key: the `id` of an object item (anything but undefined / null, compared as a string,
+ * as today's stringified keys), else its raw index in the state array (D169: not its
+ * filtered/sorted position), in a namespace of its own ('\0' + index: G-306/G-307, so an index
+ * never collides with an id).
+ */
+const keyOf = (it, i) => (isObj(it) && it.id != null ? '' + it.id : '\0' + i);
+
+(typeof window != 'undefined' && window) || (typeof process != 'undefined' && process.env) || {};
+
+/**
+ * PLAN-4.6 core: the Collection host (03-proposal §2 hosts/, R2). Registered on import (the
+ * public `Collection` module imports this file); the core only looks `hosts.collection` up.
+ *
+ * It stands where the `<Collection>` marker was in its owner's template and renders the items
+ * inside the owner's render: no stream of its own, no pickCombine.
+ * - `of`: a component function (D163: no names). `from`: a state key (SYG409 on a calculated
+ *   one), a `{ get, set }` lens (SYG412 without get(); SYG401 for a non-array) or none (the
+ *   owner's state is the array).
+ * - Items are keyed by `id`, an id-less item by its raw index (D169); one key -> index map per
+ *   array identity serves every item (cell.ts indexer). A duplicate key renders its first element
+ *   only; the dev warning is R4's (hooks.onDuplicateKey is the hook point).
+ * - `filter` / `sort` (every form today's core accepts; SYG418 for an invalid one) change what
+ *   renders and in which order; the state array keeps its order, and an item writes back to its
+ *   own element. An item returning `undefined` removes itself.
+ * - The other props go to every item, and the Collection's children are each item's children.
+ * - 4-H (D229): no element of its own. It renders a keyed fragment of the items' vnodes (its key:
+ *   the marker's, else its id), which the DOM driver splices into the parent's children before
+ *   each patch (utils.ts flat): the items are the parent element's own children, and their keys
+ *   take the fragment's, so two sibling Collections' items never collide. The wrapper `div` of
+ *   5.x is gone: `className` / `style` / `class` / ... on the marker are a removed-form error in development
+ *   (checks/next.ts) and are ignored.
+ * - Removed items are disposed synchronously in the render that drops them (G-257: a move between
+ *   two Collections is one patch).
+ * - PLAN-5 A-1: `viewTransitionName="card"` styles each keyed item's root element with
+ *   `view-transition-name: card-<id>` (shared.ts vtStyle) and `view-transition-class:
+ *   card`, the item's own style winning, so a `viewTransitions` action animates each item between
+ *   its places, across Collections with the same prefix too. Id-less items (keyed by index) and
+ *   fragment roots get none.
+ */
+const SORT_FIX = "Use a field name, { field: 'asc'|'desc'|1|-1 }, or a function";
+const sortError = (msg, value) => void error('SYG418', 'Collection', msg, SORT_FIX, value);
+const base = (a, b, asc = true) => (a > b ? (asc ? 1 : -1) : a < b ? (asc ? -1 : 1) : 0);
+function fromObj(item) {
+    const e = Object.entries(item);
+    if (e.length > 1)
+        return sortError('sort object must have one key; ignored', item);
+    const [f, d] = e[0];
+    let asc;
+    if (typeof d == 'string') {
+        const x = d.toLowerCase();
+        if (x != 'asc' && x != 'desc')
+            return sortError("sort direction must be 'asc' or 'desc'; ignored", item);
+        asc = x == 'asc';
+    }
+    else if (typeof d == 'number') {
+        if (d !== 1 && d !== -1)
+            return sortError('sort direction must be 1 or -1; ignored', item);
+        asc = d === 1;
+    }
+    else
+        return sortError('sort direction must be a string or number; ignored', item);
+    return (a, b) => base(a[f], b[f], asc);
+}
+/** the comparator of a `sort` prop (today's sortFunctionFromProp) */
+function sortFn(p) {
+    if (!p)
+        return;
+    if (typeof p == 'function')
+        return p;
+    if (typeof p == 'string') {
+        const d = p.toLowerCase();
+        if (d == 'asc' || d == 'desc')
+            return (a, b) => base(a, b, d == 'asc');
+        return (a, b) => base(a[p], b[p]);
+    }
+    if (Array.isArray(p)) {
+        const fs = p.map(i => typeof i == 'function' ? i
+            : typeof i == 'string' ? (['asc', 'desc'].includes(i.toLowerCase()) ? undefined : (a, b) => base(a[i], b[i]))
+                : isObj(i) ? fromObj(i) : undefined).filter(f => typeof f == 'function');
+        return (a, b) => fs.reduce((r, f) => (r !== 0 ? r : f(a, b)), 0);
+    }
+    if (isObj(p))
+        return fromObj(p);
+    return sortError('Invalid sort prop; ignored', p);
+}
+
 /**
  * Server-Side Rendering utilities for Sygnal components.
  *
@@ -21,7 +2983,12 @@ const ESC_MAP = {
     '"': '&quot;',
     "'": '&#39;',
 };
-function escapeHtml(str) {
+// 4-F: renderComponent's t.html() serialises like the browser's innerHTML: text escapes only
+// & < >, attribute values only & and " (SSR output keeps escaping all five)
+let innerHtmlMode = false;
+// G-480: the <Slot> marker (its function in `data.m`), not a plain <slot> element
+const isSlot = (v) => v?.data?.m && v.sel === 'slot';
+function escapeHtml(str, attr) {
     return String(str).replace(/[&<>"']/g, (ch) => ESC_MAP[ch]);
 }
 /**
@@ -52,6 +3019,116 @@ function serializeStyle(style) {
     }
     return parts.join('; ');
 }
+// the `onError` option of the outermost renderToString call that has one (GS-11)
+let ssrOnError;
+// the `head` option of the outermost renderToString call that has one
+let heads;
+// 5-5: the `cache` option of the outermost renderToString call that has one
+let ssrCache;
+/**
+ * PLAN-4 GS-1: a host's behaviors: each `uses` key missing from the state is the slice the
+ * behavior starts with (its initialState, the options naming its keys, its calculated fields: the
+ * factory's precomputed `state`), as the client's merge gives it (behaviors.ts). A host with no
+ * state gets an object with just its slices
+ */
+function withUses(def, state) {
+    const uses = def && def.uses;
+    if (!uses || typeof uses !== 'object')
+        return state;
+    if (state == null)
+        state = {};
+    if (typeof state !== 'object' || Array.isArray(state))
+        return state;
+    let out = state;
+    for (const k in uses) {
+        const u = uses[k];
+        if (!u)
+            continue;
+        let v = out[k] === undefined ? u.state : out[k];
+        // G-423: a sygnal/ui part (ui/shared.ts keyed()) names its ids by its `uses` key (or its
+        // `id` option) when the slice has no id, as the client's merge and calculated `id` do
+        if (u.keyed && v && typeof v === 'object' && v.id == null)
+            v = { ...v, id: u.options?.id ?? k };
+        if (v !== out[k] && v !== undefined) {
+            if (out === state)
+                out = { ...state };
+            out[k] = v;
+        }
+    }
+    return out;
+}
+/**
+ * 5-5 (H-7): the state a component's view renders with: each `resources` entry missing from the
+ * state reads from the cache ('success' with the cached data), else 'loading' ('idle' for a
+ * falsy request), as the client's first paint does with the same (hydrated) cache
+ */
+function withResources(def, state) {
+    state = withUses(def, state);
+    const res = def && def.resources;
+    if (!res || !state || typeof state !== 'object' || Array.isArray(state))
+        return state;
+    const out = { ...state };
+    for (const n of Object.keys(res)) {
+        if (out[n] !== undefined)
+            continue;
+        let q;
+        try {
+            q = typeof res[n] === 'function' ? res[n](state) : res[n];
+        }
+        catch (_) { }
+        const E = q && ssrCache ? ssrCache.get(ssrCache.key(q, 1)) : undefined;
+        out[n] = E && E.at > 0 ? { status: 'success', data: E.v } : { status: q ? 'loading' : 'idle' };
+    }
+    return out;
+}
+// PLAN-4 GS-9: uid(name?) as on the client: the root is 'u'; a child component adds its path in
+// the parent's view (or its `id` prop), as getComponentIdFromElement and instantiateSubComponents
+// in the core do; a Collection item adds its key, a Switchable page its name; anything but
+// each part encoded by uidPart (G-214); in the root option anything but [A-Za-z0-9_-] becomes '_'
+// (as run() does). SSR ids = hydration ids
+const makeUid = (base) => (n) => n ? base + '-' + n : base;
+function childUid(uid, vnode, path) {
+    const id = vnode.data?.props?.id;
+    return uid + '-' + uidPart(('::' + ((id && JSON.stringify(id).replaceAll('"', '')) || path)).replace(/.*::(r\.)?/, ''));
+}
+// G-567: a view that returns a string or a number renders it as text (core/instance.ts view());
+// another falsy value, an empty <div>
+const textOr = (r) => typeof r == 'string' || typeof r == 'number' ? { text: '' + r } : r;
+const viewOut = (r) => textOr(r) || { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
+const errorDiv = () => ({ sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined });
+/**
+ * A view threw: the component's onError boundary picks the fallback (the error <div> without
+ * one, or when it throws), then the app's onError hook is told (GS-11)
+ */
+function viewFailed(def, err, name) {
+    let vnode = errorDiv();
+    if (typeof def.onError === 'function') {
+        try {
+            vnode = def.onError(err, { componentName: name });
+        }
+        catch (_) {
+            vnode = errorDiv();
+        }
+    }
+    // reporting only: a throwing hook is logged and swallowed (no diagnostics import: the Astro and
+    // Vike server bundles carry this file without the core)
+    try {
+        ssrOnError && ssrOnError(err, { componentName: name, phase: 'view' });
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return vnode;
+}
+function collectHead(def, state) {
+    const h = def && def.head;
+    if (!heads || !h)
+        return;
+    try {
+        heads.push(typeof h === 'function' ? h(state) : h);
+    }
+    catch (_) { }
+}
 /**
  * Render a Sygnal component to an HTML string.
  *
@@ -62,12 +3139,38 @@ function serializeStyle(style) {
  * import { renderToString } from 'sygnal'
  *
  * const html = renderToString(App, { state: { count: 0 } })
- * // → '<div><h1>Count: 0</h1></div>'
+ * // → '<div data-sygnal-ssr=""><h1>Count: 0</h1></div>'
  * ```
+ *
+ * The root element (a fragment's first element) carries an empty `data-sygnal-ssr` attribute,
+ * which marks the markup as Sygnal's server HTML (persist() under plain run() then restores after
+ * the first render); the first client render removes it.
  */
 function renderToString(componentDef, options = {}) {
+    const prevHeads = heads, prevCache = ssrCache, prevOnError = ssrOnError;
+    if (options.head)
+        heads = options.head;
+    if (options.cache)
+        ssrCache = options.cache;
+    if (options.onError)
+        ssrOnError = options.onError;
+    try {
+        return renderRoot(componentDef, options);
+    }
+    finally {
+        heads = prevHeads;
+        ssrCache = prevCache;
+        ssrOnError = prevOnError;
+    }
+}
+function renderRoot(componentDef, options) {
     const { state, props = {}, context = {}, hydrateState } = options;
-    const resolvedState = state !== undefined ? state : componentDef.initialState;
+    // G-206: the uid root (sanitized as run() does)
+    const uid = (options.uid || 'u').replace(/[^\w-]+/g, '_');
+    const ownState = state !== undefined ? state : componentDef.initialState;
+    // 5-5: the view sees its resources; the hydration script keeps the state as it was given
+    const resolvedState = withResources(componentDef, ownState);
+    collectHead(componentDef, resolvedState);
     // Build context: merge parent context with component's own context definitions
     const componentContext = componentDef.context || {};
     const mergedContext = { ...context };
@@ -89,36 +3192,42 @@ function renderToString(componentDef, options = {}) {
             children: props.children || [],
             slots: props.slots || {},
             context: mergedContext,
-            peers: {},
-        }, resolvedState, mergedContext, {});
+            uid: makeUid(uid),
+        });
     }
     catch (err) {
         // Error boundary
-        if (typeof componentDef.onError === 'function') {
-            const name = componentDef.componentName || componentDef.name || 'Component';
-            try {
-                vnode = componentDef.onError(err, { componentName: name });
-            }
-            catch (_) {
-                vnode = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-            }
-        }
-        else {
-            vnode = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-        }
+        vnode = viewFailed(componentDef, err, componentDef.componentName || componentDef.name || 'Component');
     }
     if (!vnode) {
         vnode = { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
     }
     // Process special components in the VNode tree
-    vnode = processSSRTree(vnode, mergedContext, resolvedState);
+    vnode = processSSRTree(vnode, mergedContext, resolvedState, uid, 'r');
+    // PLAN-4 3-R: mark the root element (a fragment's first element) as Sygnal's server markup, so
+    // persist() under plain run() can tell it from a client-only app's loading placeholder. The
+    // first client render drops the attribute (the new vnode doesn't have it)
+    // (4-H: through nested fragments, e.g. a Collection's)
+    const firstEl = (v) => {
+        if (v?.sel)
+            return v.sel !== '!' && v;
+        if (Array.isArray(v?.children))
+            for (const c of v.children) {
+                const f = firstEl(c);
+                if (f)
+                    return f;
+            }
+    };
+    const first = vnode?.sel ? vnode : firstEl(vnode);
+    if (first && !innerHtmlMode)
+        first.data = { ...first.data, attrs: { 'data-sygnal-ssr': '', ...first.data?.attrs } };
     // Serialize to HTML
     let html = vnodeToHtml(vnode);
     // Optionally embed state for hydration
-    if (hydrateState && resolvedState != null) {
+    if (hydrateState && ownState != null) {
         const varName = typeof hydrateState === 'string' ? hydrateState : '__SYGNAL_STATE__';
-        escapeHtml(JSON.stringify(resolvedState));
-        html += `<script>window.${varName}=${JSON.stringify(resolvedState)}</script>`;
+        escapeHtml(JSON.stringify(ownState));
+        html += `<script>window.${varName}=${JSON.stringify(ownState)}</script>`;
     }
     return html;
 }
@@ -126,7 +3235,7 @@ function renderToString(componentDef, options = {}) {
  * Walk the VNode tree and recursively render sub-components,
  * handle Suspense/Portal/Transition markers, and process Collections.
  */
-function processSSRTree(vnode, context, parentState) {
+function processSSRTree(vnode, context, parentState, uid, path) {
     if (!vnode)
         return vnode;
     if (typeof vnode === 'string' || vnode.text != null)
@@ -135,7 +3244,7 @@ function processSSRTree(vnode, context, parentState) {
     // Fragment: no selector, recurse into children
     if (!sel && vnode.children && Array.isArray(vnode.children)) {
         vnode.children = vnode.children
-            .map((c) => processSSRTree(c, context, parentState))
+            .map((c, i) => processSSRTree(c, context, parentState, uid, `${path}.${i}`))
             .filter((c) => c != null);
         return vnode;
     }
@@ -145,11 +3254,13 @@ function processSSRTree(vnode, context, parentState) {
         if (children.length === 0)
             return null;
         if (children.length === 1)
-            return processSSRTree(children[0], context, parentState);
+            return processSSRTree(children[0], context, parentState, uid, `${path}.0`);
+        // P46-Q (D187): the client placeholder's selector (div.sygnal-portal), so hydration patches
+        // this element in place and the Portal mounts from its postpatch (G-318)
         return {
-            sel: 'div',
-            data: { attrs: { 'data-sygnal-portal': '' } },
-            children: children.map((c) => processSSRTree(c, context, parentState)),
+            sel: 'div.sygnal-portal',
+            data: { attrs: { 'data-sygnal-portal': vnode.data?.props?.target ?? '' } },
+            children: children.map((c, i) => processSSRTree(c, context, parentState, uid, `${path}.${i}`)),
             text: undefined,
             elm: undefined,
             key: undefined,
@@ -161,7 +3272,7 @@ function processSSRTree(vnode, context, parentState) {
         const child = children[0];
         if (!child)
             return null;
-        return processSSRTree(child, context, parentState);
+        return processSSRTree(child, context, parentState, uid, path);
     }
     // Suspense: render children (SSR always shows content, not fallback)
     if (sel === 'suspense') {
@@ -169,11 +3280,11 @@ function processSSRTree(vnode, context, parentState) {
         if (children.length === 0)
             return null;
         if (children.length === 1)
-            return processSSRTree(children[0], context, parentState);
+            return processSSRTree(children[0], context, parentState, uid, `${path}.0`);
         return {
             sel: 'div',
             data: { attrs: { 'data-sygnal-suspense': 'resolved' } },
-            children: children.map((c) => processSSRTree(c, context, parentState)),
+            children: children.map((c, i) => processSSRTree(c, context, parentState, uid, `${path}.${i}`)),
             text: undefined,
             elm: undefined,
             key: undefined,
@@ -185,7 +3296,7 @@ function processSSRTree(vnode, context, parentState) {
         const fallback = props.fallback;
         if (fallback) {
             // fallback can be a VNode or a string
-            return processSSRTree(fallback, context, parentState);
+            return processSSRTree(fallback, context, parentState, uid, path);
         }
         // No fallback — render an empty placeholder div
         return {
@@ -197,85 +3308,70 @@ function processSSRTree(vnode, context, parentState) {
             key: undefined,
         };
     }
+    // PLAN-5 W-1 widget marker: the host element with the widget's `fallback` inside (processed like
+    // any children); the client patch replaces the fallback and mounts the widget (extra/widget.ts)
+    if (sel === 'widget' && vnode.data?.ww) {
+        const { ww, wp, h } = vnode.data, fb = ww.def.fallback, host = ww.$ssr(vnode);
+        if (fb != null)
+            host.children = [].concat(typeof fb == 'function' ? fb(wp, h) : fb).map((c) => typeof c == 'object' ? c : { text: String(c) });
+        return processSSRTree(host, context, parentState, uid, path);
+    }
     // Slot: unwrap to children
-    if (sel === 'slot') {
+    if (isSlot(vnode)) {
         const children = vnode.children || [];
         if (children.length === 0)
             return null;
         if (children.length === 1)
-            return processSSRTree(children[0], context, parentState);
+            return processSSRTree(children[0], context, parentState, uid, `${path}.0`);
         return {
             sel: 'div',
             data: {},
-            children: children.map((c) => processSSRTree(c, context, parentState)),
+            children: children.map((c, i) => processSSRTree(c, context, parentState, uid, `${path}.${i}`)),
             text: undefined,
             elm: undefined,
             key: undefined,
         };
     }
     // Sub-component: render recursively
-    const props = vnode.data?.props || {};
-    if (props.sygnalOptions || typeof props.sygnalFactory === 'function') {
-        return renderSubComponent(vnode, context, parentState);
+    vnode.data?.props || {};
+    // (PLAN-4.6: the pragma's `data.c`, the component function)
+    if (typeof vnode.data?.c === 'function') {
+        return renderSubComponent(vnode, context, parentState, childUid(uid, vnode, path));
     }
     // Collection: render each item
     if (sel === 'collection') {
-        return renderCollection(vnode, context, parentState);
+        return renderCollection(vnode, context, parentState, childUid(uid, vnode, path));
+    }
+    // PLAN-5 V-1: a VirtualCollection renders its no-layout window (the first rows) in its container
+    if (sel === 'virtual-collection') {
+        return renderVirtual(vnode, context, parentState, childUid(uid, vnode, path));
     }
     // Switchable: render the active component
     if (sel === 'switchable') {
-        return renderSwitchable(vnode, context, parentState);
+        return renderSwitchable(vnode, context, parentState, childUid(uid, vnode, path));
     }
     // Regular element: recurse into children
     if (vnode.children) {
         if (Array.isArray(vnode.children)) {
             if (vnode.children.length > 0) {
                 vnode.children = vnode.children
-                    .map((c) => processSSRTree(c, context, parentState))
+                    .map((c, i) => processSSRTree(c, context, parentState, uid, `${path}.${i}`))
                     .filter((c) => c != null);
             }
         }
         else if (vnode.children && typeof vnode.children === 'object') {
             // Single child object (text element)
-            vnode.children = processSSRTree(vnode.children, context, parentState);
+            vnode.children = processSSRTree(vnode.children, context, parentState, uid, `${path}.0`);
         }
     }
     return vnode;
 }
 /**
- * Render a sub-component (identified by sygnalOptions or sygnalFactory in props).
+ * Render a sub-component (the pragma's `data.c`: the component function, with its statics).
  */
-function renderSubComponent(vnode, context, parentState) {
-    const props = vnode.data?.props || {};
-    const { sygnalOptions, sygnalFactory, ...childProps } = props;
-    // Get the component definition (view function with static properties)
-    let componentDef;
-    if (sygnalOptions) {
-        componentDef = sygnalOptions.view;
-        // Copy static properties
-        if (!componentDef.initialState && sygnalOptions.initialState) {
-            componentDef = Object.assign(componentDef, {
-                initialState: sygnalOptions.initialState,
-                model: sygnalOptions.model,
-                intent: sygnalOptions.intent,
-                context: sygnalOptions.context,
-                onError: sygnalOptions.onError,
-                calculated: sygnalOptions.calculated,
-            });
-        }
-    }
-    else if (sygnalFactory && sygnalFactory.componentName) {
-        // Factory-created component — we can't easily extract the view from an already-wrapped factory.
-        // Return a placeholder.
-        return {
-            sel: 'div',
-            data: { attrs: { 'data-sygnal-ssr': vnode.sel || 'component' } },
-            children: vnode.children || [],
-            text: undefined,
-            elm: undefined,
-            key: undefined,
-        };
-    }
+function renderSubComponent(vnode, context, parentState, uid) {
+    const childProps = vnode.data?.props || {};
+    const componentDef = vnode.data?.c;
     if (!componentDef || typeof componentDef !== 'function') {
         // Can't render — return children or empty div
         return {
@@ -297,6 +3393,7 @@ function renderSubComponent(vnode, context, parentState) {
         // State passed directly
         childState = stateProp;
     }
+    childState = withResources(componentDef, childState);
     // Build child context
     const childContext = { ...context };
     const componentContext = componentDef.context || {};
@@ -314,7 +3411,7 @@ function renderSubComponent(vnode, context, parentState) {
     const defaultSlotChildren = [];
     const vnodeChildren = vnode.children || [];
     for (const child of vnodeChildren) {
-        if (child && child.sel === 'slot') {
+        if (isSlot(child)) {
             const slotName = child.data?.props?.name || 'default';
             if (!slots[slotName])
                 slots[slotName] = [];
@@ -330,6 +3427,7 @@ function renderSubComponent(vnode, context, parentState) {
             slots.default = [];
         slots.default.push(...defaultSlotChildren);
     }
+    collectHead(componentDef, childState);
     // Call the view function
     let result;
     try {
@@ -339,43 +3437,102 @@ function renderSubComponent(vnode, context, parentState) {
             children: slots.default || vnodeChildren,
             slots,
             context: childContext,
-            peers: {},
-        }, childState, childContext, {});
+            uid: makeUid(uid),
+        });
     }
     catch (err) {
-        if (typeof componentDef.onError === 'function') {
-            const name = componentDef.componentName || componentDef.name || 'Component';
-            try {
-                result = componentDef.onError(err, { componentName: name });
-            }
-            catch (_) {
-                result = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-            }
+        result = viewFailed(componentDef, err, componentDef.componentName || componentDef.name || 'Component');
+    }
+    // Recursively process the rendered sub-tree
+    return processSSRTree(viewOut(result), childContext, childState, uid, 'r');
+}
+/** the Collection's own props (core/hosts/collection.ts OWN): the others go to every item */
+const COLLECTION_OWN = new Set(['of', 'from', 'filter', 'sort', 'idfield', 'className', 'viewTransitionName']);
+/** the VirtualCollection container's props (extra/virtual.ts OWN) */
+const VIRTUAL_OWN = /^(estimateSize|overscan|role|tabIndex|style|id|aria-(label|labelledby|describedby))$/;
+/**
+ * PLAN-5 2-S G-396: the items a Collection shows, as the client's host lists them
+ * (core/hosts/collection.ts arrayCell + list()): `from` a state key (missing or not an array:
+ * none, D178), a `{ get }` lens, or none (the owner's state is the array, or its `value`); then
+ * `filter` (item, index, array) and `sort` (every form sortFn takes); a duplicate key once (D177).
+ * Each entry: [the item, its raw index]
+ */
+function collectionItems(props, parentState) {
+    const { from, filter, sort } = props;
+    let a;
+    if (from === undefined)
+        a = !Array.isArray(parentState) && Array.isArray(parentState?.value) ? parentState.value : parentState;
+    else if (typeof from === 'string')
+        a = parentState?.[from];
+    else if (from && typeof from === 'object' && typeof from.get === 'function') {
+        try {
+            a = from.get(parentState);
         }
-        else {
-            result = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
+        catch (_) {
+            a = undefined;
         }
     }
-    if (!result) {
-        result = { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
+    if (!Array.isArray(a))
+        return [];
+    let idx = a.map((_, i) => i);
+    try {
+        if (typeof filter === 'function')
+            idx = idx.filter((i) => filter(a[i], i, a));
+        const cmp = sort ? sortFn(sort) : undefined;
+        if (cmp)
+            idx.sort((x, y) => cmp(a[x], a[y]));
+    }
+    catch (_) { /* as the client: a throwing filter / sort renders the array as it is */ }
+    const first = new Map(), out = [];
+    for (let i = 0; i < a.length; i++) {
+        const k = keyOf(a[i], i);
+        if (!first.has(k))
+            first.set(k, i);
     }
-    // Recursively process the rendered sub-tree
-    return processSSRTree(result, childContext, childState);
+    for (const i of idx)
+        if (first.get(keyOf(a[i], i)) === i)
+            out.push([a[i], i]);
+    return out;
+}
+/** a component's children split into slots (as renderSubComponent: `<Slot name>` children by name, the rest `default`) */
+function slotsOf(children) {
+    const slots = {};
+    for (const child of children) {
+        const name = isSlot(child) ? child.data?.props?.name || 'default' : 'default';
+        (slots[name] || (slots[name] = [])).push(...(isSlot(child) ? child.children || [] : [child]));
+    }
+    return slots;
 }
 /**
- * Render a Collection by iterating over the state array.
+ * Render a Collection: its items (collectionItems: from, filter, sort), each with the other
+ * props and the Collection's children, as the client's host gives them (G-396). `limit`: only
+ * the first that many (a VirtualCollection's window); `skip`: props that aren't the items'.
+ * 4-H (D229): a fragment of the items (no wrapper element), as the client's.
  */
-function renderCollection(vnode, context, parentState) {
+function renderCollection(vnode, context, parentState, uid, limit, skip, deco) {
     const props = vnode.data?.props || {};
-    const { of: itemComponent, from, className } = props;
-    if (!itemComponent || !from || !parentState) {
-        return { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
-    }
-    const items = parentState[from];
-    if (!Array.isArray(items)) {
-        return { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
-    }
-    const renderedItems = items.map((itemState, index) => {
+    const { of: itemComponent, viewTransitionName: vtn } = props;
+    const frag = (children) => ({ sel: undefined, data: {}, children, text: undefined, elm: undefined, key: undefined });
+    if (!itemComponent || typeof itemComponent !== 'function')
+        return frag([]);
+    let items = collectionItems(props, parentState);
+    items.length;
+    if (limit !== undefined)
+        items = items.slice(0, limit);
+    const itemProps = {};
+    for (const k in props)
+        if (!COLLECTION_OWN.has(k) && !(skip && skip.test(k)) && k !== 'key' && k !== 'children')
+            itemProps[k] = props[k];
+    const kids = vnode.children || [];
+    const slots = slotsOf(kids);
+    const renderedItems = items.map(([raw, index], pos) => {
+        let itemState = raw;
+        // GS-9: the key the client's Collection gives this item
+        const isItemObj = itemState && typeof itemState === 'object' && !Array.isArray(itemState);
+        // PLAN-4.6 G-322: an id-less item's uid part is `_i<index>` (core/cell.ts keyName)
+        const itemUid = uid + '-' + (isItemObj && itemState.id != null ? uidPart(itemState.id) : '_i' + index);
+        // GS-1: an item host's behavior slices (the client reads them as defaults, behaviors.ts)
+        itemState = withUses(itemComponent, itemState);
         // Build context for this item
         const itemContext = { ...context };
         const componentContext = itemComponent.context || {};
@@ -391,45 +3548,70 @@ function renderCollection(vnode, context, parentState) {
         let itemVnode;
         try {
             itemVnode = itemComponent({
+                ...itemProps,
                 state: itemState,
-                children: [],
-                slots: {},
+                children: slots.default || kids,
+                slots,
                 context: itemContext,
-                peers: {},
-            }, itemState, itemContext, {});
+                uid: makeUid(itemUid),
+            });
         }
         catch (err) {
-            if (typeof itemComponent.onError === 'function') {
-                try {
-                    itemVnode = itemComponent.onError(err, { componentName: itemComponent.name || 'CollectionItem' });
-                }
-                catch (_) {
-                    itemVnode = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-                }
-            }
-            else {
-                itemVnode = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-            }
+            itemVnode = viewFailed(itemComponent, err, itemComponent.name || 'CollectionItem');
         }
-        return processSSRTree(itemVnode, itemContext, itemState);
+        const out = processSSRTree(textOr(itemVnode), itemContext, itemState, itemUid, 'r');
+        // PLAN-5 A-1: the names the client's Collection gives a keyed item's root element
+        const named = vtn && isItemObj && itemState.id != null && out?.sel
+            ? { ...out, data: { ...out.data, style: vtStyle(vtn, itemState.id, out.data?.style) } }
+            : out;
+        // a VirtualCollection's row decoration, with the row's position in the list (G-431: counted
+        // before the rows that render nothing are left out, as the client counts them)
+        return deco && named?.sel ? deco(named, pos) : named;
     }).filter((v) => v != null);
-    const containerData = {};
-    if (className) {
-        containerData.props = { className };
+    return frag(renderedItems);
+}
+/**
+ * PLAN-5 V-1: a VirtualCollection on the server: the client's markup (extra/virtual.ts) for the
+ * window it computes without layout, the first 10 rows + overscan, with the spacer as tall as
+ * every row's estimate. The client measures and moves the window once it has layout. G-396: the
+ * rows are the Collection's (from, filter, sort, the other props and the children to every
+ * item); aria-setsize and the spacer count the filtered list.
+ */
+function renderVirtual(vnode, context, parentState, uid) {
+    const p = vnode.data?.props || {}, est = p.estimateSize, size = est > 0 ? est : 32;
+    const n = 10 + (p.overscan >= 0 ? p.overscan : 5);
+    const items = typeof p.of === 'function' ? collectionItems(p, parentState) : [];
+    const role = p.role === undefined ? 'list' : p.role;
+    const rows = renderCollection(vnode, context, parentState, uid, n, VIRTUAL_OWN, (r, i) => {
+        const own = r.data?.attrs?.role || r.data?.props?.role, attrs = { ...r.data?.attrs, 'data-index': i };
+        if (role == 'list' || own)
+            attrs['aria-posinset'] = i + 1, attrs['aria-setsize'] = items.length;
+        if (role == 'list' && !own)
+            attrs.role = 'listitem';
+        return { ...r, data: { ...r.data, attrs } };
+    }).children;
+    const attrs = { tabindex: p.tabIndex ?? 0 };
+    if (role != null)
+        attrs.role = role;
+    for (const k of ['id', 'aria-label', 'aria-labelledby', 'aria-describedby'])
+        if (p[k] != null)
+            attrs[k] = p[k];
+    let total = 0;
+    for (let i = 0; i < items.length; i++) {
+        const s = typeof est == 'function' ? est(items[i][0], i) : size;
+        total += s > 0 ? s : 32;
     }
-    return {
-        sel: 'div',
-        data: containerData,
-        children: renderedItems,
-        text: undefined,
-        elm: undefined,
-        key: undefined,
-    };
+    const div = (data, children) => ({ sel: 'div', data, children, text: undefined, elm: undefined, key: undefined });
+    return div({ props: p.className ? { className: p.className } : {}, attrs, style: { overflowY: 'auto', overflowAnchor: 'none', ...p.style } }, [
+        div({ style: { position: 'relative', width: '100%', height: total + 'px' } }, [
+            div({ style: { position: 'absolute', top: '0', left: '0', width: '100%', transform: 'translateY(0px)' } }, rows),
+        ]),
+    ]);
 }
 /**
  * Render a Switchable by determining the active component from state.
  */
-function renderSwitchable(vnode, context, parentState) {
+function renderSwitchable(vnode, context, parentState, uid) {
     const props = vnode.data?.props || {};
     const { components, active, initial } = props;
     if (!components) {
@@ -456,13 +3638,13 @@ function renderSwitchable(vnode, context, parentState) {
     if (!activeComponent || typeof activeComponent !== 'function') {
         return { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
     }
-    return renderToStringInternal(activeComponent, parentState, context);
+    return renderToStringInternal(activeComponent, parentState, context, uid + '-' + uidPart(activeName));
 }
 /**
  * Internal helper: render a component def to a VNode (not HTML string).
  */
-function renderToStringInternal(componentDef, state, context) {
-    const resolvedState = state !== undefined ? state : componentDef.initialState;
+function renderToStringInternal(componentDef, state, context, uid) {
+    const resolvedState = withResources(componentDef, state !== undefined ? state : componentDef.initialState);
     const componentContext = componentDef.context || {};
     const mergedContext = { ...context };
     for (const key of Object.keys(componentContext)) {
@@ -474,6 +3656,7 @@ function renderToStringInternal(componentDef, state, context) {
             catch (_) { }
         }
     }
+    collectHead(componentDef, resolvedState);
     let vnode;
     try {
         vnode = componentDef({
@@ -481,31 +3664,34 @@ function renderToStringInternal(componentDef, state, context) {
             children: [],
             slots: {},
             context: mergedContext,
-            peers: {},
-        }, resolvedState, mergedContext, {});
+            uid: makeUid(uid),
+        });
     }
     catch (err) {
-        if (typeof componentDef.onError === 'function') {
-            try {
-                vnode = componentDef.onError(err, { componentName: componentDef.name || 'Component' });
-            }
-            catch (_) {
-                vnode = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-            }
-        }
-        else {
-            vnode = { sel: 'div', data: { attrs: { 'data-sygnal-error': '' } }, children: [], text: undefined, elm: undefined, key: undefined };
-        }
-    }
-    if (!vnode) {
-        vnode = { sel: 'div', data: {}, children: [], text: undefined, elm: undefined, key: undefined };
+        vnode = viewFailed(componentDef, err, componentDef.name || 'Component');
     }
-    return processSSRTree(vnode, mergedContext, resolvedState);
+    return processSSRTree(viewOut(vnode), mergedContext, resolvedState, uid, 'r');
 }
+const ws = (t) => t.replace(/[\t\n\f\r ]+/g, ' ').replace(/^ | $/g, '');
+const fieldValue = (data) => data?.props?.value ?? data?.attrs?.value;
+const withoutValue = (data) => {
+    const out = { ...data };
+    if (out.props) {
+        out.props = { ...out.props };
+        delete out.props.value;
+    }
+    if (out.attrs) {
+        out.attrs = { ...out.attrs };
+        delete out.attrs.value;
+    }
+    return out;
+};
+const textOf = (v) => v == null ? '' : typeof v != 'object' ? String(v)
+    : v.text != null ? String(v.text) : Array.isArray(v.children) ? v.children.map(textOf).join('') : '';
 /**
  * Serialize a VNode tree to an HTML string.
  */
-function vnodeToHtml(vnode) {
+function vnodeToHtml(vnode, sv) {
     if (vnode == null)
         return '';
     // Text node
@@ -520,14 +3706,35 @@ function vnodeToHtml(vnode) {
             return escapeHtml(String(vnode.text));
         // Fragment: no selector, but has children — concatenate child HTML
         if (vnode.children && Array.isArray(vnode.children)) {
-            return vnode.children.map((c) => vnodeToHtml(c)).join('');
+            return vnode.children.map((c) => vnodeToHtml(c, sv)).join('');
         }
         return '';
     }
     // Parse selector: tag#id.class1.class2
     const { tag, id, selectorClasses } = parseSelector(sel);
+    let data = vnode.data || {}, content;
+    const value = fieldValue(data);
+    if (tag == 'textarea' && value != null) {
+        data = withoutValue(data);
+        // the HTML parser drops a leading newline (a CR or CRLF is one: G-495), so one is added
+        const t = String(value);
+        content = escapeHtml((t[0] == '\n' || t[0] == '\r' ? '\n' : '') + t);
+    }
+    else if (tag == 'select' && value != null) {
+        data = withoutValue(data);
+        sv = { v: [].concat(value).map(String), m: !!(data.props?.multiple ?? data.attrs?.multiple) };
+    }
+    else if (tag == 'option' && sv && data.props?.selected == null && data.attrs?.selected == null) {
+        if (sv.v.includes(value != null ? String(value) : ws(textOf(vnode)))) {
+            data = { ...data, attrs: { ...data.attrs, selected: true } };
+            if (!sv.m)
+                sv.v = [];
+        }
+    }
+    if (tag != 'select' && tag != 'optgroup' && tag != 'option')
+        sv = undefined;
     // Build attributes from VNode data
-    const attrs = buildAttributes(vnode.data || {}, id, selectorClasses);
+    const attrs = buildAttributes(data, id, selectorClasses, tag.includes('-'));
     // Opening tag
     let html = `<${tag}`;
     for (const [key, val] of attrs) {
@@ -551,14 +3758,17 @@ function vnodeToHtml(vnode) {
     }
     // Children — snabbdom uses `text` for single text children (even when
     // `children` holds a text element object). Prioritize `text` when set.
-    if (vnode.text != null) {
+    if (content !== undefined) {
+        html += content;
+    }
+    else if (vnode.text != null) {
         html += escapeHtml(String(vnode.text));
     }
     else if (vnode.children) {
         // children can be an array or a single text element object
         const kids = Array.isArray(vnode.children) ? vnode.children : [vnode.children];
         for (const child of kids) {
-            html += vnodeToHtml(child);
+            html += vnodeToHtml(child, sv);
         }
     }
     html += `</${tag}>`;
@@ -606,12 +3816,15 @@ function parseSelector(sel) {
 /**
  * Build an ordered list of [attrName, attrValue] from VNode data.
  */
-function buildAttributes(data, selectorId, selectorClasses) {
+// 1-R G-365: camelCase HTML IDL properties whose content attribute is their lowercase name
+const IDL_ATTRS = /^(tabIndex|readOnly|maxLength|minLength|contentEditable|accessKey|inputMode|enterKeyHint|spellCheck|autoFocus|autoComplete|autoCapitalize|autoPlay|noValidate|formAction|formEnctype|formMethod|formNoValidate|formTarget|crossOrigin|referrerPolicy|useMap|isMap|dateTime|colSpan|rowSpan|srcSet|allowFullscreen|playsInline|noModule|popoverTarget|popoverTargetAction|encType)$/;
+const kebab = (k) => k.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase());
+function buildAttributes(data, selectorId, selectorClasses, custom) {
     const result = [];
     const classNames = [...selectorClasses];
     // From data.props (DOM properties like className, htmlFor, etc.)
     if (data.props) {
-        for (const [key, val] of Object.entries(data.props)) {
+        for (let [key, val] of Object.entries(data.props)) {
             if (key === 'className') {
                 if (typeof val === 'string' && val)
                     classNames.push(val);
@@ -620,13 +3833,28 @@ function buildAttributes(data, selectorId, selectorClasses) {
                 result.push(['for', val]);
             }
             else if (key === 'innerHTML' || key === 'textContent') ;
-            else if (key === 'sygnalOptions' || key === 'sygnalFactory') ;
-            else if (typeof val === 'boolean') {
-                if (val)
-                    result.push([key, true]);
-            }
-            else if (val != null) {
-                result.push([key, val]);
+            else if (custom && (typeof val === 'function' || (val && typeof val === 'object'))) ;
+            else {
+                // PLAN-5 D199 / 1-R G-365: a custom element's camelCase property as attributes. A
+                // reflected HTML IDL name gets its attribute (tabIndex → tabindex, readOnly → readonly),
+                // an ARIA reflection its aria-* one (ariaLabel → aria-label). Any other camelCase name is
+                // written twice: kebab-case (withClear → with-clear: Web Awesome / Shoelace's declared
+                // attributes, Stencil's default, sygnal/element's defineElement) and lowercase
+                // (withclear: Lit's and FAST's default attribute name); the element reads the one it
+                // observes and ignores the other
+                const keys = !custom || !/[A-Z]/.test(key) ? [key]
+                    : IDL_ATTRS.test(key) ? [key.toLowerCase()]
+                        : /^aria[A-Z]/.test(key) ? [kebab(key)]
+                            : [kebab(key), key.toLowerCase()];
+                for (const k of keys) {
+                    if (typeof val === 'boolean') {
+                        if (val)
+                            result.push([k, true]);
+                    }
+                    else if (val != null) {
+                        result.push([k, val]);
+                    }
+                }
             }
         }
     }
@@ -683,8 +3911,7 @@ function buildAttributes(data, selectorId, selectorClasses) {
 function looksLikeSygnalComponent(Component) {
     if (typeof Component !== 'function')
         return false;
-    return Boolean(Component.isSygnalComponent ||
-        Component.model ||
+    return Boolean(Component.model ||
         Component.intent ||
         Component.initialState ||
         Component.componentName);
@@ -699,6 +3926,10 @@ function renderToStaticMarkup(Component, props = {}, _slotted, _metadata) {
         const html = renderToString(Component, {
             state: props.initialState || Component.initialState,
             props: { ...props, props },
+            // PLAN-4 GS-11: the app-level error hook (as the client's run() gets)
+            onError,
+            // G-206: a `uid` island prop is its uid root (as on the client), for two islands on a page
+            uid: props.uid,
         });
         return { html, attrs: {} };
     }