marko/dist/html.js

Optimized runtime for Marko templates.

let empty = [], rest = Symbol(), unsafeXMLReg = /[<&]/g, replaceUnsafeXML = (c) => c === "&" ? "&amp;" : "&lt;", escapeXMLStr = (str) => unsafeXMLReg.test(str) ? str.replace(unsafeXMLReg, replaceUnsafeXML) : str, unsafeScriptReg = /<\/script/gi, escapeScriptStr = (str) => unsafeScriptReg.test(str) ? str.replace(unsafeScriptReg, "\\x3C/script") : str, unsafeStyleReg = /<\/style/gi, escapeStyleStr = (str) => unsafeStyleReg.test(str) ? str.replace(unsafeStyleReg, "\\3C/style") : str, unsafeCommentReg = />/g, escapeCommentStr = (str) => unsafeCommentReg.test(str) ? str.replace(unsafeCommentReg, "&gt;") : str, K_SCOPE_ID = Symbol("Scope ID"), kTouchedIterator = Symbol.for("marko.touchedIterator"), { hasOwnProperty: hasOwnProperty$1 } = {}, Generator = (function* () {})().constructor, AsyncGenerator = (async function* () {})().constructor, REGISTRY = /* @__PURE__ */ new WeakMap(), KNOWN_SYMBOLS = (() => {
	let KNOWN_SYMBOLS = /* @__PURE__ */ new Map();
	for (let name of Object.getOwnPropertyNames(Symbol)) {
		let symbol = Symbol[name];
		typeof symbol == "symbol" && KNOWN_SYMBOLS.set(symbol, "Symbol." + name);
	}
	return KNOWN_SYMBOLS;
})(), KNOWN_FUNCTIONS = new Map([
	[AggregateError, "AggregateError"],
	[Array, "Array"],
	[Array.from, "Array.from"],
	[Array.isArray, "Array.isArray"],
	[Array.of, "Array.of"],
	[ArrayBuffer, "ArrayBuffer"],
	[ArrayBuffer.isView, "ArrayBuffer.isView"],
	[Atomics.add, "Atomics.add"],
	[Atomics.and, "Atomics.and"],
	[Atomics.compareExchange, "Atomics.compareExchange"],
	[Atomics.exchange, "Atomics.exchange"],
	[Atomics.isLockFree, "Atomics.isLockFree"],
	[Atomics.load, "Atomics.load"],
	[Atomics.notify, "Atomics.notify"],
	[Atomics.or, "Atomics.or"],
	[Atomics.store, "Atomics.store"],
	[Atomics.sub, "Atomics.sub"],
	[Atomics.wait, "Atomics.wait"],
	[BigInt, "BigInt"],
	[BigInt.asIntN, "BigInt.asIntN"],
	[BigInt.asUintN, "BigInt.asUintN"],
	[BigInt64Array, "BigInt64Array"],
	[BigInt64Array.from, "BigInt64Array.from"],
	[BigInt64Array.of, "BigInt64Array.of"],
	[BigUint64Array, "BigUint64Array"],
	[BigUint64Array.from, "BigUint64Array.from"],
	[BigUint64Array.of, "BigUint64Array.of"],
	[Boolean, "Boolean"],
	[console.assert, "console.assert"],
	[console.clear, "console.clear"],
	[console.count, "console.count"],
	[console.countReset, "console.countReset"],
	[console.debug, "console.debug"],
	[console.dir, "console.dir"],
	[console.dirxml, "console.dirxml"],
	[console.error, "console.error"],
	[console.group, "console.group"],
	[console.groupCollapsed, "console.groupCollapsed"],
	[console.groupEnd, "console.groupEnd"],
	[console.info, "console.info"],
	[console.log, "console.log"],
	[console.table, "console.table"],
	[console.time, "console.time"],
	[console.timeEnd, "console.timeEnd"],
	[console.timeLog, "console.timeLog"],
	[console.timeStamp, "console.timeStamp"],
	[console.trace, "console.trace"],
	[console.warn, "console.warn"],
	[DataView, "DataView"],
	[Date, "Date"],
	[Date.now, "Date.now"],
	[Date.parse, "Date.parse"],
	[Date.UTC, "Date.UTC"],
	[decodeURI, "decodeURI"],
	[decodeURIComponent, "decodeURIComponent"],
	[encodeURI, "encodeURI"],
	[encodeURIComponent, "encodeURIComponent"],
	[Error, "Error"],
	[EvalError, "EvalError"],
	[Float32Array, "Float32Array"],
	[Float32Array.from, "Float32Array.from"],
	[Float32Array.of, "Float32Array.of"],
	[Float64Array, "Float64Array"],
	[Float64Array.from, "Float64Array.from"],
	[Float64Array.of, "Float64Array.of"],
	[Function, "Function"],
	[globalThis.atob, "atob"],
	[globalThis.btoa, "btoa"],
	[globalThis.clearImmediate, "clearImmediate"],
	[globalThis.clearInterval, "clearInterval"],
	[globalThis.clearTimeout, "clearTimeout"],
	[globalThis.crypto?.getRandomValues, "crypto.getRandomValues"],
	[globalThis.crypto?.randomUUID, "crypto.randomUUID"],
	[globalThis.fetch, "fetch"],
	[globalThis.performance?.now, "performance.now"],
	[globalThis.queueMicrotask, "queueMicrotask"],
	[globalThis.setImmediate, "setImmediate"],
	[globalThis.setInterval, "setInterval"],
	[globalThis.setTimeout, "setTimeout"],
	[globalThis.structuredClone, "structuredClone"],
	[globalThis.URL, "URL"],
	[globalThis.URLSearchParams, "URLSearchParams"],
	[globalThis.WritableStream, "WritableStream"],
	[Int16Array, "Int16Array"],
	[Int16Array.from, "Int16Array.from"],
	[Int16Array.of, "Int16Array.of"],
	[Int32Array, "Int32Array"],
	[Int32Array.from, "Int32Array.from"],
	[Int32Array.of, "Int32Array.of"],
	[Int8Array, "Int8Array"],
	[Int8Array.from, "Int8Array.from"],
	[Int8Array.of, "Int8Array.of"],
	[Intl.Collator, "Intl.Collator"],
	[Intl.DateTimeFormat, "Intl.DateTimeFormat"],
	[Intl.DisplayNames, "Intl.DisplayNames"],
	[Intl.getCanonicalLocales, "Intl.getCanonicalLocales"],
	[Intl.ListFormat, "Intl.ListFormat"],
	[Intl.Locale, "Intl.Locale"],
	[Intl.NumberFormat, "Intl.NumberFormat"],
	[Intl.PluralRules, "Intl.PluralRules"],
	[Intl.RelativeTimeFormat, "Intl.RelativeTimeFormat"],
	[Intl.Segmenter, "Intl.Segmenter"],
	[Intl.supportedValuesOf, "Intl.supportedValuesOf"],
	[isFinite, "isFinite"],
	[isNaN, "isNaN"],
	[JSON.parse, "JSON.parse"],
	[JSON.stringify, "JSON.stringify"],
	[Map, "Map"],
	[Map.groupBy, "Map.groupBy"],
	[Math.abs, "Math.abs"],
	[Math.acos, "Math.acos"],
	[Math.acosh, "Math.acosh"],
	[Math.asin, "Math.asin"],
	[Math.asinh, "Math.asinh"],
	[Math.atan, "Math.atan"],
	[Math.atan2, "Math.atan2"],
	[Math.atanh, "Math.atanh"],
	[Math.cbrt, "Math.cbrt"],
	[Math.ceil, "Math.ceil"],
	[Math.clz32, "Math.clz32"],
	[Math.cos, "Math.cos"],
	[Math.cosh, "Math.cosh"],
	[Math.exp, "Math.exp"],
	[Math.expm1, "Math.expm1"],
	[Math.floor, "Math.floor"],
	[Math.fround, "Math.fround"],
	[Math.hypot, "Math.hypot"],
	[Math.imul, "Math.imul"],
	[Math.log, "Math.log"],
	[Math.log10, "Math.log10"],
	[Math.log1p, "Math.log1p"],
	[Math.log2, "Math.log2"],
	[Math.max, "Math.max"],
	[Math.min, "Math.min"],
	[Math.pow, "Math.pow"],
	[Math.random, "Math.random"],
	[Math.round, "Math.round"],
	[Math.sign, "Math.sign"],
	[Math.sin, "Math.sin"],
	[Math.sinh, "Math.sinh"],
	[Math.sqrt, "Math.sqrt"],
	[Math.tan, "Math.tan"],
	[Math.tanh, "Math.tanh"],
	[Math.trunc, "Math.trunc"],
	[Number, "Number"],
	[Number.isFinite, "Number.isFinite"],
	[Number.isInteger, "Number.isInteger"],
	[Number.isNaN, "Number.isNaN"],
	[Number.isSafeInteger, "Number.isSafeInteger"],
	[Number.parseFloat, "Number.parseFloat"],
	[Number.parseInt, "Number.parseInt"],
	[Object, "Object"],
	[Object.assign, "Object.assign"],
	[Object.create, "Object.create"],
	[Object.defineProperties, "Object.defineProperties"],
	[Object.defineProperty, "Object.defineProperty"],
	[Object.entries, "Object.entries"],
	[Object.freeze, "Object.freeze"],
	[Object.fromEntries, "Object.fromEntries"],
	[Object.getOwnPropertyDescriptor, "Object.getOwnPropertyDescriptor"],
	[Object.getOwnPropertyDescriptors, "Object.getOwnPropertyDescriptors"],
	[Object.getOwnPropertyNames, "Object.getOwnPropertyNames"],
	[Object.getOwnPropertySymbols, "Object.getOwnPropertySymbols"],
	[Object.getPrototypeOf, "Object.getPrototypeOf"],
	[Object.is, "Object.is"],
	[Object.isExtensible, "Object.isExtensible"],
	[Object.isFrozen, "Object.isFrozen"],
	[Object.isSealed, "Object.isSealed"],
	[Object.keys, "Object.keys"],
	[Object.preventExtensions, "Object.preventExtensions"],
	[Object.seal, "Object.seal"],
	[Object.setPrototypeOf, "Object.setPrototypeOf"],
	[Object.values, "Object.values"],
	[parseFloat, "parseFloat"],
	[parseInt, "parseInt"],
	[Promise, "Promise"],
	[Proxy, "Proxy"],
	[RangeError, "RangeError"],
	[ReferenceError, "ReferenceError"],
	[Reflect.apply, "Reflect.apply"],
	[Reflect.construct, "Reflect.construct"],
	[Reflect.defineProperty, "Reflect.defineProperty"],
	[Reflect.deleteProperty, "Reflect.deleteProperty"],
	[Reflect.get, "Reflect.get"],
	[Reflect.getOwnPropertyDescriptor, "Reflect.getOwnPropertyDescriptor"],
	[Reflect.getPrototypeOf, "Reflect.getPrototypeOf"],
	[Reflect.has, "Reflect.has"],
	[Reflect.isExtensible, "Reflect.isExtensible"],
	[Reflect.ownKeys, "Reflect.ownKeys"],
	[Reflect.preventExtensions, "Reflect.preventExtensions"],
	[Reflect.set, "Reflect.set"],
	[Reflect.setPrototypeOf, "Reflect.setPrototypeOf"],
	[RegExp, "RegExp"],
	[Set, "Set"],
	[String, "String"],
	[String.fromCharCode, "String.fromCharCode"],
	[String.fromCodePoint, "String.fromCodePoint"],
	[String.raw, "String.raw"],
	[Symbol, "Symbol"],
	[Symbol.for, "Symbol.for"],
	[SyntaxError, "SyntaxError"],
	[TypeError, "TypeError"],
	[Uint16Array, "Uint16Array"],
	[Uint16Array.from, "Uint16Array.from"],
	[Uint16Array.of, "Uint16Array.of"],
	[Uint32Array, "Uint32Array"],
	[Uint32Array.from, "Uint32Array.from"],
	[Uint32Array.of, "Uint32Array.of"],
	[Uint8Array, "Uint8Array"],
	[Uint8Array.from, "Uint8Array.from"],
	[Uint8Array.of, "Uint8Array.of"],
	[Uint8ClampedArray, "Uint8ClampedArray"],
	[Uint8ClampedArray.from, "Uint8ClampedArray.from"],
	[Uint8ClampedArray.of, "Uint8ClampedArray.of"],
	[URIError, "URIError"],
	[WeakMap, "WeakMap"],
	[WeakSet, "WeakSet"]
]), KNOWN_OBJECTS = new Map([
	[Atomics, "Atomics"],
	[console, "console"],
	[globalThis, "globalThis"],
	[globalThis.crypto, "crypto"],
	[Intl, "Intl"],
	[JSON, "JSON"],
	[Math, "Math"],
	[Reflect, "Reflect"]
]), toDelimitedString = function toDelimitedString(val, delimiter, stringify) {
	let str = "", sep = "", part;
	if (val) if (typeof val != "object") str += val;
	else if (Array.isArray(val)) for (let v of val) part = toDelimitedString(v, delimiter, stringify), part && (str += sep + part, sep = delimiter);
	else for (let name in val) part = stringify(name, val[name]), part && (str += sep + part, sep = delimiter);
	return str;
}, $chunk, NOOP$2 = () => {}, kPendingContexts = Symbol("Pending Contexts"), kBranchId = Symbol("Branch Id"), kIsAsync = Symbol("Is Async"), writeScope = (scopeId, partialScope) => {
	let { state } = $chunk.boundary, target = $chunk.serializeState, scope = scopeWithId(state, scopeId), pending = target.writeScopes[scopeId];
	return state.needsMainRuntime = !0, Object.assign(scope, partialScope), pending && pending !== partialScope ? Object.assign(pending, partialScope) : target.writeScopes[scopeId] = partialScope, target.flushScopes = !0, scope;
}, tick = globalThis.setImmediate || globalThis.setTimeout || globalThis.queueMicrotask || ((cb) => Promise.resolve().then(cb)), tickQueue, kSelectedValue = Symbol("selectedValue"), checkedValuesRefs = /* @__PURE__ */ new WeakMap(), singleQuoteAttrReplacements = /'|&(?=#?\w+;)/g, doubleQuoteAttrReplacements = /"|&(?=#?\w+;)/g, needsQuotedAttr = /["'>\s]|&#?\w+;|\/$/g, voidElementsReg = /^(?:area|b(?:ase|r)|col|embed|hr|i(?:mg|nput)|link|meta|param|source|track|wbr)$/, _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, serializeReason) => {
	let shouldResume = serializeReason !== 0, renderer = normalizeDynamicRenderer(tag), state = getState(), branchId = _peek_scope_id(), rendered, result;
	if (typeof renderer == "string") {
		let input = (inputIsArgs ? inputOrArgs[0] : inputOrArgs) || {};
		if (rendered = !0, _scope_id(), _html(`<${renderer}${_attrs(input, "a", branchId, renderer)}>`), !voidElementsReg.test(renderer)) {
			let renderContent = content || normalizeDynamicRenderer(input.content);
			if (renderer === "textarea") _html(_attr_textarea_value(branchId, "a", input.value, input.valueChange));
			else if (renderContent) {
				if (typeof renderContent != "function") throw Error(`Body content is not supported for the \`<${renderer}>\` tag.`);
				renderer === "select" && ("value" in input || "valueChange" in input) ? _attr_select_value(branchId, "a", input.value, input.valueChange, renderContent) : _dynamic_tag(branchId, "a", renderContent, void 0, 0, void 0, serializeReason);
			}
			_html(`</${renderer}>`);
		}
		let childScope = getScopeById(branchId), needsScript = childScope && (childScope.Ia || childScope.Ea);
		needsScript && (writeScope(branchId, { R: renderer }), _script(branchId, "d")), (shouldResume || needsScript) && _html(state.mark("'", scopeId + " " + accessor + " " + branchId));
	} else {
		shouldResume && _html(state.mark("[", ""));
		let render = () => {
			if (renderer) try {
				return _set_serialize_reason(shouldResume && inputOrArgs !== void 0 ? 1 : 0), inputIsArgs ? renderer(...inputOrArgs) : renderer(content ? {
					...inputOrArgs,
					content
				} : inputOrArgs);
			} finally {
				_set_serialize_reason(void 0);
			}
			else if (content) return content();
		};
		result = shouldResume ? withBranchId(branchId, render) : render(), rendered = _peek_scope_id() !== branchId, shouldResume && _html(state.mark("]", scopeId + " " + accessor + (rendered ? " " + branchId : "")));
	}
	return rendered ? shouldResume && writeScope(scopeId, { ["D" + accessor]: renderer?.a || renderer }) : _scope_id(), result;
}, patchDynamicTag = ((originalDynamicTag) => (patch) => {
	_dynamic_tag = (scopeId, accessor, tag, input, content, inputIsArgs, resume) => {
		let patched = patch(tag, scopeId, accessor);
		return patched !== tag && (patched.a = tag), originalDynamicTag(scopeId, accessor, patched, input, content, inputIsArgs, resume);
	};
})(_dynamic_tag), _template = (templateId, renderer, page) => (renderer.render = render, renderer.i = !page, renderer._ = renderer, _content_resume(templateId, renderer)), kAssets = Symbol(), kBlockIndex = Symbol(), kDeferIndex = Symbol(), { hasOwnProperty } = {}, assetFlush, SET_SCOPE_REGISTER_ID = "$C_s", K_TAGS_API_STATE = Symbol(), COMPAT_REGISTRY = /* @__PURE__ */ new WeakMap(), compat = {
	$global,
	fork: _await,
	write: _html,
	writeScript,
	nextScopeId: _scope_id,
	peekNextScopeId: _peek_scope_id,
	isInResumedBranch,
	ensureState($global) {
		let state = $global[K_TAGS_API_STATE] ||= getChunk()?.boundary.state;
		return state || ($global.runtimeId ||= "M", $global.renderId ||= $global.componentIdPrefix || $global.widgetIdPrefix || "_", $global[K_TAGS_API_STATE] = state = new State($global)), state;
	},
	isTagsAPI(fn) {
		return !!fn.a;
	},
	onFlush(fn) {
		let { flushHTML } = Chunk.prototype;
		Chunk.prototype.flushHTML = function() {
			return fn(this), flushHTML.call(this);
		};
	},
	patchDynamicTag,
	writeSetScopeForComponent(branchId, m5c, m5i) {
		writeScope(branchId, {
			m5c,
			m5i
		}), _script(branchId, SET_SCOPE_REGISTER_ID);
	},
	toJSON() {
		return function() {
			let compatRegistered = COMPAT_REGISTRY.get(this);
			if (!compatRegistered) {
				let registered = getRegistered(this);
				if (registered) {
					let scopeId = registered.scope ? getScopeId(registered.scope) : void 0;
					scopeId !== void 0 && _script(scopeId, SET_SCOPE_REGISTER_ID), COMPAT_REGISTRY.set(this, compatRegistered = [registered.id, scopeId]);
				}
			}
			return compatRegistered;
		};
	},
	flushScript($global) {
		let state = this.ensureState($global), boundary = new Boundary(state);
		if (boundary.flush() === 1) throw Error("Cannot serialize promise across tags/class compat layer.");
		return new Chunk(boundary, null, null, state).flushScript().scripts;
	},
	render(renderer, willRerender, classAPIOut, component, input, completeChunks) {
		let state = this.ensureState(classAPIOut.global), boundary = new Boundary(state), head = new Chunk(boundary, null, null, state), normalizedInput = input;
		if ("renderBody" in input) {
			normalizedInput = {};
			for (let key in input) normalizedInput[key === "renderBody" ? "content" : key] = input[key];
		}
		head.render(() => {
			if (willRerender) {
				let scopeId = _peek_scope_id();
				writeScope(scopeId, { m5c: component.id }), _script(scopeId, SET_SCOPE_REGISTER_ID);
			}
			_set_serialize_reason(+!!willRerender);
			try {
				renderer(normalizedInput);
			} finally {
				_set_serialize_reason(void 0);
			}
			let asyncOut = classAPIOut.beginAsync({
				last: !0,
				timeout: -1
			});
			classAPIOut.onLast((next) => {
				(boundary.onNext = () => {
					boundary.signal.aborted ? (asyncOut.error(boundary.signal.reason), boundary.onNext = NOOP) : boundary.count || (boundary.onNext = NOOP, head = head.consume(), asyncOut.write(head.html), asyncOut.script(head.scripts), asyncOut.end(), head.html = head.scripts = "", completeChunks.push(head), next());
				})();
			});
		});
	},
	register,
	registerRenderBody(fn) {
		register("$C_b", fn);
	}
};
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
//#region src/common/attr-tag.ts
function attrTag(attrs) {
	return attrs[Symbol.iterator] = attrTagIterator, attrs[rest] = empty, attrs;
}
function attrTags(first, attrs) {
	return first ? (first[rest] === empty ? first[rest] = [attrs] : first[rest].push(attrs), first) : attrTag(attrs);
}
function* attrTagIterator() {
	yield this, yield* this[rest];
}
//#endregion
//#region src/common/errors.ts
function _el_read_error() {}
function _hoist_read_error() {}
function _assert_hoist(value) {}
//#endregion
//#region src/html/content.ts
function _unescaped(val) {
	return val ? val + "" : val === 0 ? "0" : "";
}
function _escape(val) {
	return val ? escapeXMLStr(val + "") : val === 0 ? "0" : "";
}
function _escape_script(val) {
	return val ? escapeScriptStr(val + "") : val === 0 ? "0" : "";
}
function _escape_style(val) {
	return val ? escapeStyleStr(val + "") : val === 0 ? "0" : "";
}
function _escape_comment(val) {
	return val ? escapeCommentStr(val + "") : val === 0 ? "0" : "";
}
patchIteratorNext(Generator.prototype), patchIteratorNext(AsyncGenerator.prototype);
var State$1 = class {
	ids = 0;
	flush = 0;
	wroteUndefined = !1;
	buf = [];
	strs = /* @__PURE__ */ new Map();
	refs = /* @__PURE__ */ new WeakMap();
	assigned = /* @__PURE__ */ new Set();
	boundary = void 0;
	channel = void 0;
	channelDeps = null;
	mutated = [];
}, Reference = class {
	parent;
	accessor;
	flush;
	pos;
	id;
	assigns = null;
	scopeId = void 0;
	channel = void 0;
	constructor(parent, accessor, flush, pos = null, id = null) {
		this.parent = parent, this.accessor = accessor, this.flush = flush, this.pos = pos, this.id = id;
	}
}, Serializer = class {
	#state = new State$1();
	pending(channel) {
		return hasMatchingMutations(this.#state.mutated, channel?.readyId);
	}
	pendingReadyChannel() {
		for (let mutation of this.#state.mutated) if (mutation.channel?.readyId) return mutation.channel;
	}
	stringifyScopes(flushes, boundary, channel) {
		try {
			return this.#state.boundary = boundary, this.#state.channel = channel, writeScopesRoot(this.#state, flushes);
		} finally {
			this.#state.flush++, this.#state.buf = [];
		}
	}
	written(val) {
		return this.#state.refs.has(val);
	}
	takeChannelDeps() {
		let deps = this.#state.channelDeps;
		return this.#state.channelDeps = null, deps;
	}
	writeCall(value, object, property, channel) {
		this.#state.mutated.push({
			value,
			object,
			property,
			channel
		});
	}
};
function register(id, val, scope) {
	return REGISTRY.set(val, {
		id,
		scope,
		access: "_._" + toAccess(toObjectKey(id))
	}), val;
}
function getRegistered(val) {
	let registered = REGISTRY.get(val);
	if (registered) return {
		id: registered.id,
		scope: registered.scope
	};
}
function writeScopesRoot(state, flushes) {
	let { buf } = state, nextSlotId = -1, fillIndex = -1;
	for (let flush of flushes) {
		let scopeId = flush[0], scope = flush[1], ref = state.refs.get(scope) || newScopeReference(state, scope, scopeId), openIndex = buf.push("") - 1;
		writeObjectProps(state, flush[2], ref) ? (buf[openIndex] = nextSlotId === -1 ? "[" + scopeId + ",{" : (scopeId > nextSlotId ? "," + (scopeId - nextSlotId) : "") + ",{", fillIndex === -1 && (fillIndex = openIndex), nextSlotId = scopeId + 1, buf.push("}")) : buf.pop();
	}
	nextSlotId !== -1 && buf.push("]");
	let extras = "";
	(state.assigned.size || hasChannelMutations(state)) && (extras = ",0)", fillIndex !== -1 && (buf[fillIndex] = "_(" + buf[fillIndex], buf.push(")")), writeAssigned(state));
	let result = extras && "(";
	for (let chunk of buf) result += chunk;
	return result += extras, result ? state.wroteUndefined ? (state.wroteUndefined = !1, "(_,$)=>" + result) : "_=>" + result : "";
}
function writeAssigned(state) {
	let sep = state.buf.length ? "," : "";
	if (state.assigned.size) {
		let buf = "";
		for (let ref of state.assigned) buf += sep + assignsToString(ref.assigns, ref.id), ref.assigns = null, sep = ",";
		state.buf.push(buf), state.assigned = /* @__PURE__ */ new Set();
	}
	if (hasChannelMutations(state)) {
		let remaining = [];
		for (let mutation of state.mutated) {
			if (!mutationMatchesReadyId(mutation, state.channel?.readyId)) {
				remaining.push(mutation);
				continue;
			}
			let hasSeen = state.refs.get(mutation.object)?.id, objectStartIndex = state.buf.push(state.buf.length === 0 ? "" : ",");
			if (writeProp(state, mutation.object, null, "")) {
				let objectRef = state.refs.get(mutation.object);
				objectRef && objectRef.scopeId === void 0 && (objectRef.id ? hasSeen || (state.buf[objectStartIndex] = "(" + state.buf[objectStartIndex], state.buf.push(")")) : (objectRef.id = nextRefAccess(state), state.buf[objectStartIndex] = "(" + objectRef.id + "=" + state.buf[objectStartIndex], state.buf.push(")")));
			} else state.buf.push("void 0");
			let valueStartIndex = state.buf.push(toAccess(toObjectKey(mutation.property)) + "(");
			if (mutation.value !== void 0) if (writeProp(state, mutation.value, null, "")) {
				let valueRef = state.refs.get(mutation.value);
				valueRef && !valueRef.id && valueRef.scopeId === void 0 && (valueRef.id = mutation.valueId || nextRefAccess(state), state.buf[valueStartIndex] = valueRef.id + "=" + state.buf[valueStartIndex]);
			} else state.buf.push("void 0");
			state.buf.push(")");
		}
		state.mutated = remaining, state.assigned.size && writeAssigned(state);
	}
}
function hasChannelMutations(state) {
	return hasMatchingMutations(state.mutated, state.channel?.readyId);
}
function hasMatchingMutations(mutated, readyId) {
	for (let mutation of mutated) if (mutationMatchesReadyId(mutation, readyId)) return !0;
	return !1;
}
function mutationMatchesReadyId(mutation, readyId) {
	return mutation.channel?.readyId ? mutation.channel.readyId === readyId : !readyId;
}
function writeProp(state, val, parent, accessor) {
	switch (typeof val) {
		case "string": return writeString(state, val, parent, accessor);
		case "number": return writeNumber(state, val);
		case "boolean": return writeBoolean(state, val);
		case "bigint": return writeBigInt(state, val);
		case "symbol": return writeSymbol(state, val, parent, accessor);
		case "function": return writeFunction(state, val, parent, accessor);
		case "object": return writeObject(state, val, parent, accessor);
		default: return !1;
	}
}
function writeReferenceOr(state, write, val, parent, accessor) {
	let scopeId = val[K_SCOPE_ID];
	if (scopeId !== void 0) return trackScope(state, val, scopeId), state.buf.push("_(" + scopeId + ")"), !0;
	let ref = state.refs.get(val);
	if (ref) {
		if (!trackChannel(state, ref)) return !1;
		if (parent) {
			if (ref.assigns) return addAssignment(ref, accessId(state, parent) + toAccess(accessor)), !1;
			if (isCircular(parent, ref)) return ensureId(state, ref), state.assigned.add(ref), addAssignment(ref, accessId(state, parent) + toAccess(accessor)), !1;
		}
		return state.buf.push(ensureId(state, ref)), !0;
	}
	let registered = REGISTRY.get(val);
	return registered ? writeRegistered(state, val, parent, accessor, registered) : (state.refs.set(val, ref = new Reference(parent, accessor, state.flush, state.buf.length)), ref.channel = state.channel, write(state, val, ref) ? !0 : (state.refs.delete(val), !1));
}
function trackScope(state, val, scopeId) {
	let ref = state.refs.get(val);
	ref ? trackChannel(state, ref) : newScopeReference(state, val, scopeId);
}
function newScopeReference(state, val, scopeId) {
	let ref = new Reference(null, null, state.flush);
	return ref.scopeId = scopeId, ref.channel = state.channel, state.refs.set(val, ref), ref;
}
function writeRegistered(state, val, parent, accessor, registered) {
	let { scope } = registered;
	if (scope) {
		let ref = new Reference(parent, accessor, state.flush, state.buf.length);
		ref.channel = state.channel, state.refs.set(val, ref);
		let scopeId = scope[K_SCOPE_ID];
		trackScope(state, scope, scopeId), state.buf.push("_(" + scopeId + "," + quote(registered.id, 0) + ")");
	} else state.buf.push(registered.access);
	return !0;
}
function writeString(state, val, parent, accessor) {
	if (val.length > 12) {
		let ref = state.strs.get(val);
		if (ref) {
			if (trackChannel(state, ref)) return state.buf.push(ensureId(state, ref)), !0;
		} else {
			let ref = new Reference(parent, accessor, state.flush, state.buf.length);
			ref.channel = state.channel, state.strs.set(val, ref);
		}
	}
	return state.buf.push(quote(val, 0)), !0;
}
function writeNumber(state, val) {
	return state.buf.push(val + ""), !0;
}
function writeBoolean(state, val) {
	return state.buf.push(val ? "!0" : "!1"), !0;
}
function writeBigInt(state, val) {
	return state.buf.push(val + "n"), !0;
}
function writeFunction(state, val, parent, accessor) {
	let wellKnownFunction = KNOWN_FUNCTIONS.get(val);
	return wellKnownFunction ? (state.buf.push(wellKnownFunction), !0) : writeReferenceOr(state, writeNever, val, parent, accessor);
}
function writeSymbol(state, val, parent, accessor) {
	let wellKnownSymbol = KNOWN_SYMBOLS.get(val);
	if (wellKnownSymbol) return state.buf.push(wellKnownSymbol), !0;
	let key = Symbol.keyFor(val);
	return key === void 0 ? writeReferenceOr(state, writeUnknownSymbol, val, parent, accessor) : (state.buf.push("Symbol.for(" + quote(key, 0) + ")"), !0);
}
function writeUnknownSymbol(state) {
	return state.buf.push("Symbol()"), !0;
}
function writeNever(state, val, ref) {
	return !1;
}
function writeNull(state) {
	return state.buf.push("null"), !0;
}
function writeObject(state, val, parent, accessor) {
	if (val === null) return writeNull(state);
	let wellKnownObject = KNOWN_OBJECTS.get(val);
	return wellKnownObject ? (state.buf.push(wellKnownObject), !0) : writeReferenceOr(state, writeUnknownObject, val, parent, accessor);
}
function writeUnknownObject(state, val, ref) {
	switch (val.constructor) {
		case void 0: return writeNullObject(state, val, ref);
		case Object: return writePlainObject(state, val, ref);
		case Array: return writeArray(state, val, ref);
		case Date: return writeDate(state, val);
		case RegExp: return writeRegExp(state, val);
		case Promise: return writePromise(state, val, ref);
		case Map: return writeMap(state, val, ref);
		case Set: return writeSet(state, val, ref);
		case Generator: return writeGenerator(state, val, ref);
		case AsyncGenerator: return writeAsyncGenerator(state, val, ref);
		case Error:
		case EvalError:
		case RangeError:
		case ReferenceError:
		case SyntaxError:
		case TypeError:
		case URIError: return writeError(state, val, ref);
		case AggregateError: return writeAggregateError(state, val, ref);
		case ArrayBuffer: return writeArrayBuffer(state, val);
		case Int8Array:
		case Uint8Array:
		case Uint8ClampedArray:
		case Int16Array:
		case Uint16Array:
		case Int32Array:
		case Uint32Array:
		case Float32Array:
		case Float64Array: return writeTypedArray(state, val, ref);
		case WeakSet: return writeWeakSet(state);
		case WeakMap: return writeWeakMap(state);
		case globalThis.URL: return writeURL(state, val);
		case globalThis.URLSearchParams: return writeURLSearchParams(state, val);
		case globalThis.Headers: return writeHeaders(state, val);
		case globalThis.FormData: return writeFormData(state, val);
		case globalThis.ReadableStream: return writeReadableStream(state, val, ref);
		case globalThis.Request: return writeRequest(state, val, ref);
		case globalThis.Response: return writeResponse(state, val, ref);
	}
	return !1;
}
function writePlainObject(state, val, ref) {
	return state.buf.push("{"), writeObjectProps(state, val, ref), state.buf.push("}"), !0;
}
function writeArray(state, val, ref) {
	let sep = "[";
	for (let i = 0; i < val.length; i++) {
		let item = val[i];
		state.buf.push(sep), sep = ",", item === void 0 ? (state.wroteUndefined = !0, state.buf.push("$")) : writeProp(state, item, ref, "" + i);
	}
	return sep === "[" ? state.buf.push("[]") : state.buf.push("]"), !0;
}
function writeDate(state, val) {
	return state.buf.push("new Date(" + +val + ")"), !0;
}
function writeRegExp(state, val) {
	return state.buf.push(val + ""), !0;
}
function writePromise(state, val, ref) {
	let { boundary, channel } = state;
	if (!boundary) return !1;
	let pId = nextRefAccess(state), handle = newAsyncHandle(state, ref, pId);
	return state.buf.push("(p=>p=new Promise((f,r)=>" + pId + "={f,r(e){p.catch(_=>0);r(e)}}))()"), val.then((v) => writeAsyncCall(state, boundary, handle, "f", v, channel, pId), (v) => writeAsyncCall(state, boundary, handle, "r", v, channel, pId)), boundary.startAsync(), !0;
}
function newAsyncHandle(state, parent, id) {
	let handle = {}, handleRef = new Reference(parent, null, state.flush, null, id);
	return handleRef.channel = state.channel, state.refs.set(handle, handleRef), handle;
}
function writeMap(state, val, ref) {
	if (!val.size) return state.buf.push("new Map"), !0;
	let items = [], assigns, needsId, i = 0;
	if (val.size < 25) {
		for (let [itemKey, itemValue] of val) itemKey === val && (itemKey = void 0, (assigns ||= []).push("a[" + i + "][0]")), itemValue === val && (itemValue = void 0, (assigns ||= []).push("a[" + i + "][1]")), needsId ||= isDedupedMember(itemKey) || isDedupedMember(itemValue), i = items.push(itemValue === void 0 ? itemKey === void 0 ? [] : [itemKey] : [itemKey, itemValue]);
		writeArrayArg(state, ref, items, assigns && "((m,a)=>(" + assignsToString(assigns, "m") + ",a.forEach(i=>m.set(i[0],i[1])),m))(new Map,", "new Map(", needsId);
	} else {
		for (let [itemKey, itemValue] of val) itemKey === val && (itemKey = 0, (assigns ||= []).push("a[" + i + "]")), itemValue === val && (itemValue = 0, (assigns ||= []).push("a[" + (i + 1) + "]")), needsId ||= isDedupedMember(itemKey) || isDedupedMember(itemValue), i = items.push(itemKey, itemValue);
		writeArrayArg(state, ref, items, assigns && "(a=>a.reduce((m,v,i)=>i%2?m:m.set(v,a[i+1])," + assignsToString(assigns, "new Map") + "))(", "(a=>a.reduce((m,v,i)=>i%2?m:m.set(v,a[i+1]),new Map))(", needsId);
	}
	return !0;
}
function writeSet(state, val, ref) {
	if (!val.size) return state.buf.push("new Set"), !0;
	let items = [], assigns, needsId, i = 0;
	for (let item of val) item === val ? (item = 0, (assigns ||= []).push("i[" + i + "]")) : needsId ||= isDedupedMember(item), i = items.push(item);
	return writeArrayArg(state, ref, items, assigns && "((s,i)=>(" + assignsToString(assigns, "s") + ",i.forEach(i=>s.add(i)),s))(new Set,", "new Set(", needsId), !0;
}
function writeArrayArg(state, ref, items, assignsPrefix, plainPrefix, needsId) {
	if (assignsPrefix || needsId) {
		let arrayRef = new Reference(ref, null, state.flush, null, nextRefAccess(state));
		state.buf.push((assignsPrefix || plainPrefix) + arrayRef.id + "="), writeArray(state, items, arrayRef);
	} else state.buf.push(plainPrefix), writeArray(state, items, new Reference(ref, null, state.flush, state.buf.length));
	state.buf.push(")");
}
function isDedupedMember(val) {
	switch (typeof val) {
		case "object": return val !== null && val[K_SCOPE_ID] === void 0;
		case "function":
		case "symbol": return !0;
		case "string": return val.length > 12;
		default: return !1;
	}
}
function writeArrayBuffer(state, val) {
	let result;
	if (val.byteLength) {
		let view = new Int8Array(val);
		result = hasOnlyZeros(view) ? "new ArrayBuffer(" + val.byteLength + ")" : "new Int8Array(" + typedArrayToInitString(view) + ").buffer";
	} else result = "new ArrayBuffer";
	return state.buf.push(result), !0;
}
function writeTypedArray(state, val, ref) {
	if (val.byteOffset || state.refs.has(val.buffer)) {
		let needsLength = val.byteOffset + val.byteLength < val.buffer.byteLength;
		state.buf.push("new " + val.constructor.name + "("), writeProp(state, val.buffer, ref, "buffer"), state.buf.push((val.byteOffset || needsLength ? "," + val.byteOffset + (needsLength ? "," + val.length : "") : "") + ")");
	} else state.refs.set(val.buffer, new Reference(ref, "buffer", state.flush, null)), state.buf.push("new " + val.constructor.name + (val.length === 0 ? "" : "(" + (hasOnlyZeros(val) ? val.length : typedArrayToInitString(val)) + ")"));
	return !0;
}
function writeWeakSet(state) {
	return state.buf.push("new WeakSet"), !0;
}
function writeWeakMap(state) {
	return state.buf.push("new WeakMap"), !0;
}
function writeError(state, val, ref) {
	let result = "new " + val.constructor.name + "(" + quote(val.message + "", 0);
	return val.cause ? (state.buf.push(result + ",{cause:"), writeProp(state, val.cause, ref, "cause"), state.buf.push("})")) : state.buf.push(result + ")"), !0;
}
function writeAggregateError(state, val, ref) {
	return state.buf.push("new AggregateError("), writeProp(state, val.errors, ref, "errors"), val.message ? state.buf.push("," + quote(val.message + "", 0) + ")") : state.buf.push(")"), !0;
}
function writeURL(state, val) {
	return state.buf.push("new URL(" + quote(val.toString(), 0) + ")"), !0;
}
function writeURLSearchParams(state, val) {
	let str = val.toString();
	return str ? state.buf.push("new URLSearchParams(" + quote(str, 0) + ")") : state.buf.push("new URLSearchParams"), !0;
}
function writeHeaders(state, val) {
	let headers = stringEntriesToProps(val);
	return state.buf.push("new Headers" + (headers ? "({" + headers + "})" : "")), !0;
}
function writeFormData(state, val) {
	let sep = "[", valStr = "";
	for (let [key, value] of val) typeof value == "string" && (valStr += sep + quote(key, 0) + "," + quote(value, 0), sep = ",");
	return sep === "[" ? state.buf.push("new FormData") : state.buf.push(valStr + "].reduce((f,v,i,a)=>i%2&&f.append(a[i-1],v)||f,new FormData)"), !0;
}
function writeRequest(state, val, ref) {
	let sep = "", bodySerialized = !1, hasBody = val.body && !val.bodyUsed && val.duplex === "half";
	state.buf.push("new Request(" + quote(val.url, 0)), hasBody && (state.buf.push(",{body:"), writeProp(state, val.body, ref, "body") ? (state.buf.push(",duplex:\"half\""), sep = ",", bodySerialized = !0) : state.buf.pop());
	let options = "";
	val.cache !== "default" && (options += sep + "cache:" + quote(val.cache, 0), sep = ","), val.credentials !== "same-origin" && (options += sep + "credentials:" + quote(val.credentials, 0), sep = ",");
	let headers = stringEntriesToProps(val.headers);
	return state.refs.set(val.headers, new Reference(ref, "headers", state.flush, null)), headers && (options += sep + "headers:{" + headers + "}", sep = ","), val.integrity && (options += sep + "integrity:" + quote(val.integrity, 0), sep = ","), val.keepalive && (options += sep + "keepalive:true", sep = ","), val.method !== "GET" && (options += sep + "method:" + quote(val.method, 0), sep = ","), val.mode !== "cors" && (options += sep + "mode:" + quote(val.mode, 0), sep = ","), val.redirect !== "follow" && (options += sep + "redirect:" + quote(val.redirect, 0), sep = ","), val.referrer !== "about:client" && (options += sep + "referrer:" + quote(val.referrer, 0), sep = ","), val.referrerPolicy && (options += sep + "referrerPolicy:" + quote(val.referrerPolicy, 0)), state.buf.push(bodySerialized ? options + "})" : options ? ",{" + options + "})" : ")"), !0;
}
function writeResponse(state, val, ref) {
	let sep = "", options = "";
	val.status !== 200 && (options += "status:" + val.status, sep = ","), val.statusText && (options += sep + "statusText:" + quote(val.statusText, 0), sep = ",");
	let headers = stringEntriesToProps(val.headers);
	return state.refs.set(val.headers, new Reference(ref, "headers", state.flush, null)), headers && (options += sep + "headers:{" + headers + "}"), !val.body || val.bodyUsed ? state.buf.push("new Response" + (options ? "(null,{" + options + "})" : "")) : (state.buf.push("new Response("), state.buf.push((writeProp(state, val.body, ref, "body") ? "" : "null") + (options ? ",{" + options + "})" : ")"))), !0;
}
function writeReadableStream(state, val, ref) {
	let { boundary, channel } = state;
	if (!boundary || val.locked) return !1;
	let reader = val.getReader(), iterId = nextRefAccess(state), handle = newAsyncHandle(state, ref, iterId), onFulfilled = ({ value, done }) => {
		done ? writeAsyncCall(state, boundary, handle, "r", value, channel) : boundary.signal.aborted || (reader.read().then(onFulfilled, onRejected), boundary.startAsync(), writeAsyncCall(state, boundary, handle, "f", value, channel));
	}, onRejected = (reason) => {
		writeAsyncCall(state, boundary, handle, "j", reason, channel);
	};
	return state.buf.push("new ReadableStream({start(c){(async(_,f,v,l,i,p=a=>l=new Promise((r,j)=>{f=_.r=r;_.j=j}),a=((_.f=v=>{f(v);a.push(p())}),[p()]))=>{for(i of a)v=await i,i==l?c.close():c.enqueue(v)})(" + iterId + "={}).catch(e=>c.error(e))}})"), reader.read().then(onFulfilled, onRejected), boundary.startAsync(), !0;
}
function writeGenerator(state, iter, ref) {
	if (iter[kTouchedIterator]) return state.buf.push("(async function*(){}())"), !0;
	let sep = "";
	for (state.buf.push("(function*(){");;) {
		let { value, done } = iter.next();
		if (done) {
			value !== void 0 && (state.buf.push(sep + "return "), writeProp(state, value, ref, ""));
			break;
		}
		value === void 0 ? state.buf.push(sep + "yield") : (state.buf.push(sep + "yield "), writeProp(state, value, ref, "")), sep = ";";
	}
	return state.buf.push("})()"), !0;
}
function writeAsyncGenerator(state, iter, ref) {
	if (iter[kTouchedIterator]) return state.buf.push("(async function*(){}())"), !0;
	let { boundary, channel } = state;
	if (!boundary) return !1;
	let iterId = nextRefAccess(state), handle = newAsyncHandle(state, ref, iterId), onFulfilled = ({ value, done }) => {
		done ? writeAsyncCall(state, boundary, handle, "r", value, channel) : boundary.signal.aborted || (iter.next().then(onFulfilled, onRejected), boundary.startAsync(), writeAsyncCall(state, boundary, handle, "f", value, channel));
	}, onRejected = (reason) => {
		writeAsyncCall(state, boundary, handle, "j", reason, channel);
	};
	return state.buf.push("(async function*(_,f,v,l,i,p=a=>l=new Promise((r,j)=>{f=_.r=r;_.j=j}),a=((_.f=v=>{f(v);a.push(p())}),[p()])){for(i of a)v=await i,i!=l&&(yield v);return v})(" + iterId + "={})"), iter.next().then(onFulfilled, onRejected), boundary.startAsync(), !0;
}
function writeNullObject(state, val, ref) {
	return state.buf.push("{"), state.buf.push(writeObjectProps(state, val, ref) + "__proto__:null}"), !0;
}
function writeObjectProps(state, val, ref) {
	let sep = "";
	for (let key in val) if (hasOwnProperty$1.call(val, key)) {
		let escapedKey = toObjectKey(key);
		state.buf.push(sep + escapedKey + ":"), writeProp(state, val[key], ref, escapedKey) ? sep = "," : state.buf.pop();
	}
	if (hasSymbolIterator(val)) {
		let yieldSelf = "", iterArr = [];
		for (let item of val) item === val && !(yieldSelf || iterArr.length) ? yieldSelf = "yield this;" : iterArr.push(item);
		if (iterArr.length) {
			let iterRef = new Reference(ref, null, state.flush, null, nextRefAccess(state));
			state.buf.push(sep + "*[(" + iterRef.id + "="), writeArray(state, iterArr, iterRef), state.buf.push(",Symbol.iterator)](){" + yieldSelf + "yield*" + iterRef.id + "}");
		} else state.buf.push(sep + "*[Symbol.iterator](){" + yieldSelf.slice(0, -1) + "}");
		sep = ",";
	}
	return sep;
}
function writeAsyncCall(state, boundary, handle, method, value, channel, valueId = null) {
	boundary.signal.aborted || (state.mutated.push({
		value,
		object: handle,
		property: method,
		channel,
		valueId
	}), boundary.endAsync());
}
function trackChannel(state, ref) {
	let refReadyId = ref.channel?.readyId;
	if (!refReadyId || refReadyId === state.channel?.readyId) return !0;
	let cur = state.channel?.parent;
	for (; cur;) {
		if (cur.readyId === refReadyId) return (state.channelDeps ||= /* @__PURE__ */ new Set()).add(refReadyId), !0;
		cur = cur.parent;
	}
	return !1;
}
function isCircular(parent, ref) {
	let cur = parent;
	for (; cur;) {
		if (cur === ref) return !0;
		cur = cur.parent;
	}
	return !1;
}
function toObjectKey(name) {
	if (name === "") return "\"\"";
	let startChar = name[0];
	if (isDigit(startChar)) {
		if (startChar === "0") {
			if (name !== "0") return quote(name, 1);
		} else for (let i = 1; i < name.length; i++) if (!isDigit(name[i])) return quote(name, i);
	} else if (isWord(startChar)) {
		for (let i = 1; i < name.length; i++) if (!isWordOrDigit(name[i])) return quote(name, i);
	} else return quote(name, 0);
	return name;
}
function toAccess(accessor) {
	let start = accessor[0];
	return start === "\"" || start >= "0" && start <= "9" ? "[" + accessor + "]" : "." + accessor;
}
function quote(str, startPos) {
	let result = "", lastPos = 0;
	for (let i = startPos; i < str.length; i++) {
		let replacement;
		switch (str[i]) {
			case "\"":
				replacement = "\\\"";
				break;
			case "\\":
				replacement = "\\\\";
				break;
			case "<":
				replacement = "\\x3C";
				break;
			case "\n":
				replacement = "\\n";
				break;
			case "\r":
				replacement = "\\r";
				break;
			case "\u2028":
				replacement = "\\u2028";
				break;
			case "\u2029":
				replacement = "\\u2029";
				break;
			default: continue;
		}
		result += str.slice(lastPos, i) + replacement, lastPos = i + 1;
	}
	return "\"" + (lastPos === startPos ? str : result + str.slice(lastPos)) + "\"";
}
function ensureId(state, ref) {
	return ref.scopeId === void 0 ? ref.id ? (trackChannel(state, ref), ref.id) : assignId(state, ref) : (trackChannel(state, ref), "_(" + ref.scopeId + ")");
}
function accessId(state, ref) {
	let id = ensureId(state, ref);
	return id === ref.id || ref.scopeId !== void 0 ? id : "(" + id + ")";
}
function assignId(state, ref) {
	let { pos } = ref;
	if (ref.id = nextRefAccess(state), pos !== null && ref.flush === state.flush) return pos === 0 ? state.buf[0] = ref.id + "=" + state.buf[0] : state.buf[pos - 1] += ref.id + "=", ref.id;
	ref.channel = state.channel;
	let cur = ref, accessPrevValue = "";
	do {
		accessPrevValue = toAccess(cur.accessor) + accessPrevValue;
		let parent = cur.parent;
		if (parent.id && (trackChannel(state, parent) || !parent.parent)) {
			accessPrevValue = parent.id + accessPrevValue;
			break;
		}
		if (parent.flush === state.flush || parent.scopeId !== void 0) {
			accessPrevValue = accessId(state, parent) + accessPrevValue;
			break;
		}
		cur = parent;
	} while (cur);
	return ref.id + "=" + accessPrevValue;
}
function assignsToString(assigns, value) {
	return assigns.length > 100 ? "($=>(" + assigns.join("=$,") + "=$))(" + value + ")" : assigns.join("=") + "=" + value;
}
function addAssignment(ref, assign) {
	ref.assigns ? ref.assigns.push(assign) : ref.assigns = [assign];
}
function nextRefAccess(state) {
	return "_." + nextId(state);
}
function nextId(state) {
	let c = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789", n = state.ids++, r = c[n % 53];
	for (n = n / 53 | 0; n; n >>>= 6) r += c[n & 63];
	return r;
}
function hasSymbolIterator(value) {
	return Symbol.iterator in value;
}
function stringEntriesToProps(entries) {
	let result = "", sep = "";
	for (let [key, value] of entries) result += sep + toObjectKey(key) + ":" + quote(value, 0), sep = ",";
	return result;
}
function typedArrayToInitString(view) {
	let result = "[", sep = "";
	for (let i = 0; i < view.length; i++) result += sep + view[i], sep = ",";
	return result += "]", result;
}
function hasOnlyZeros(typedArray) {
	for (let i = 0; i < typedArray.length; i++) if (typedArray[i] !== 0) return !1;
	return !0;
}
function isWordOrDigit(char) {
	return isWord(char) || isDigit(char);
}
function isDigit(char) {
	return char >= "0" && char <= "9";
}
function isWord(char) {
	return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "$";
}
function patchIteratorNext(proto) {
	if (proto.next[kTouchedIterator]) return;
	let { next } = proto;
	proto.next = function(value) {
		return this[kTouchedIterator] = 1, next.call(this, value);
	}, proto.next[kTouchedIterator] = !0;
}
//#endregion
//#region src/common/helpers.ts
function stringifyClassObject(name, value) {
	return value ? name : "";
}
function stringifyStyleObject(name, value) {
	return value || value === 0 ? name + ":" + value : "";
}
function isEventHandler(name) {
	return /^on[A-Z-]/.test(name);
}
function getEventHandlerName(name) {
	return name[2] === "-" ? name.slice(3) : name.slice(2).toLowerCase();
}
function isVoid(value) {
	return value == null || value === !1;
}
function isNotVoid(value) {
	return value != null && value !== !1;
}
function normalizeDynamicRenderer(value) {
	if (value) {
		if (typeof value == "string") return value;
		let normalized = value.content || value.default || value;
		if ("a" in normalized) return normalized;
	}
}
//#endregion
//#region src/common/for.ts
function forIn(obj, cb) {
	for (let key in obj) cb(key, obj[key]);
}
function forOf(list, cb) {
	if (list) {
		let i = 0;
		for (let item of list) cb(item, i++);
	}
}
function forTo(to, from, step, cb) {
	let start = from || 0, delta = step || 1;
	for (let steps = (to - start) / delta, i = 0; i <= steps; i++) cb(start + i * delta);
}
function forUntil(until, from, step, cb) {
	let start = from || 0, delta = step || 1;
	for (let steps = (until - start) / delta, i = 0; i < steps; i++) cb(start + i * delta);
}
//#endregion
//#region src/common/opt.ts
function forEach(opt, cb) {
	if (opt) if (Array.isArray(opt)) for (let item of opt) cb(item);
	else cb(opt);
}
function push(opt, item) {
	return opt ? Array.isArray(opt) ? (opt.push(item), opt) : [opt, item] : item;
}
function concat(opt, other) {
	if (!opt) return other;
	if (!other) return opt;
	if (Array.isArray(opt)) {
		if (Array.isArray(other)) for (let item of other) opt.push(item);
		else opt.push(other);
		return opt;
	}
	return Array.isArray(other) ? [opt, ...other] : [opt, other];
}
//#endregion
//#region src/html/for.ts
function forOfBy(by, item, index) {
	return by ? typeof by == "string" ? item[by] : by(item, index) : index;
}
function forInBy(by, name, value) {
	return by ? by(name, value) : name;
}
function forStepBy(by, index) {
	return by ? by(index) : index;
}
//#endregion
//#region src/html/inlined-runtimes.ts
//#endregion
//#region src/html/writer.ts
function getChunk() {
	return $chunk;
}
function getContext(key) {
	return $chunk.context?.[key];
}
function getState() {
	return $chunk.boundary.state;
}
function getScopeId(scope) {
	return scope[K_SCOPE_ID];
}
function _html(html) {
	$chunk.writeHTML(html);
}
function writeScript(script) {
	$chunk.writeScript(script);
}
function writeWaitReady(readyId, renderer, input) {
	let chunk = $chunk, { boundary } = chunk, body = new Chunk(boundary, null, chunk.context, {
		readyId,
		parent: chunk.serializeState,
		resumes: "",
		writeScopes: {},
		flushScopes: !1
	}), bodyEnd = body.render(renderer, input);
	body === bodyEnd ? (chunk.writeHTML(body.html), body.deferOwnReady(), chunk.deferredReady = push(chunk.deferredReady, body)) : (bodyEnd.next = $chunk = chunk.fork(boundary, chunk.next), chunk.next = body);
}
function _script(scopeId, registryId) {
	($chunk.serializeState.readyId || $chunk.context?.[kIsAsync]) && _resume_branch(scopeId), $chunk.boundary.state.needsMainRuntime = !0, $chunk.writeEffect(scopeId, registryId);
}
function _attr_content(nodeAccessor, scopeId, content, serializeReason) {
	let shouldResume = serializeReason !== 0, render = normalizeServerRender(content), branchId = _peek_scope_id();
	render && (shouldResume ? withBranchId(branchId, render) : render()), _peek_scope_id() === branchId ? _scope_id() : shouldResume && writeScope(scopeId, {
		["A" + nodeAccessor]: writeScope(branchId, {}),
		["D" + nodeAccessor]: render?.a
	});
}
function normalizeServerRender(value) {
	let renderer = normalizeDynamicRenderer(value);
	if (renderer && typeof renderer == "function") return renderer;
}
function withContext(key, value, cb, cbValue) {
	let ctx = $chunk.context ||= { [kPendingContexts]: 0 }, prev = ctx[key];
	ctx[kPendingContexts]++, ctx[key] = value;
	try {
		return cb(cbValue);
	} finally {
		ctx[kPendingContexts]--, ctx[key] = prev;
	}
}
function _var(parentScopeId, scopeOffsetAccessor, childScopeId, registryId, nodeAccessor) {
	writeScopePassive(parentScopeId, { [scopeOffsetAccessor]: _scope_id() });
	let childScope = writeScopePassive(childScopeId, { T: _resume({}, registryId, parentScopeId) });
	nodeAccessor !== void 0 && writeScope(parentScopeId, { ["A" + nodeAccessor]: childScope });
}
function writeScopePassive(scopeId, partialScope) {
	let target = $chunk.serializeState, scope = _scope_with_id(scopeId), passive = target.passiveScopes ||= {};
	return Object.assign(scope, partialScope), passive[scopeId] = Object.assign(passive[scopeId] || {}, partialScope), scope;
}
function _resume(val, id, scopeId) {
	return register(id, val, scopeId === void 0 ? void 0 : _scope_with_id(scopeId));
}
function _id() {
	let state = $chunk.boundary.state, { $global } = state;
	return "s" + $global.runtimeId + $global.renderId + (state.tagId++).toString(36);
}
function _scope_id() {
	return $chunk.boundary.state.scopeId++;
}
function _peek_scope_id() {
	return $chunk.boundary.state.scopeId;
}
function getScopeById(scopeId) {
	if (scopeId !== void 0) return $chunk.boundary.state.scopes.get(scopeId);
}
function _set_serialize_reason(reason) {
	$chunk.boundary.state.serializeReason = reason;
}
function _scope_reason() {
	let reason = $chunk.boundary.state.serializeReason;
	return $chunk.boundary.state.serializeReason = void 0, reason;
}
function _serialize_if(condition, key) {
	return condition && (condition === 1 || condition[key]) ? 1 : void 0;
}
function _serialize_guard(condition, key) {
	return _serialize_if(condition, key) || 0;
}
function _el_resume(scopeId, accessor, shouldResume) {
	if (shouldResume === 0) return "";
	let { state } = $chunk.boundary;
	return state.needsMainRuntime = !0, state.mark("*", scopeId + " " + accessor);
}
function _sep(shouldResume) {
	return shouldResume === 0 ? ""