marko 6.0.165 → 6.0.166

package/dist/debug/dom.js

@@ -1,2705 +1,1892 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/dom.ts
-var dom_exports = {};
-__export(dom_exports, {
-  $signal: () => $signal,
-  $signalReset: () => $signalReset,
-  _assert_hoist: () => _assert_hoist,
-  _assert_init: () => _assert_init,
-  _attr: () => _attr,
-  _attr_class: () => _attr_class,
-  _attr_class_item: () => _attr_class_item,
-  _attr_class_items: () => _attr_class_items,
-  _attr_content: () => _attr_content,
-  _attr_details_open: () => _attr_details_or_dialog_open,
-  _attr_details_open_default: () => _attr_details_or_dialog_open_default,
-  _attr_details_open_script: () => _attr_details_or_dialog_open_script,
-  _attr_dialog_open: () => _attr_details_or_dialog_open,
-  _attr_dialog_open_default: () => _attr_details_or_dialog_open_default,
-  _attr_dialog_open_script: () => _attr_details_or_dialog_open_script,
-  _attr_input_checked: () => _attr_input_checked,
-  _attr_input_checkedValue: () => _attr_input_checkedValue,
-  _attr_input_checkedValue_default: () => _attr_input_checkedValue_default,
-  _attr_input_checkedValue_script: () => _attr_input_checkedValue_script,
-  _attr_input_checked_default: () => _attr_input_checked_default,
-  _attr_input_checked_script: () => _attr_input_checked_script,
-  _attr_input_value: () => _attr_input_value,
-  _attr_input_value_default: () => _attr_input_value_default,
-  _attr_input_value_script: () => _attr_input_value_script,
-  _attr_nonce: () => _attr_nonce,
-  _attr_select_value: () => _attr_select_value,
-  _attr_select_value_default: () => _attr_select_value_default,
-  _attr_select_value_script: () => _attr_select_value_script,
-  _attr_style: () => _attr_style,
-  _attr_style_item: () => _attr_style_item,
-  _attr_style_items: () => _attr_style_items,
-  _attr_textarea_value: () => _attr_input_value,
-  _attr_textarea_value_default: () => _attr_input_value_default,
-  _attr_textarea_value_script: () => _attr_input_value_script,
-  _attrs: () => _attrs,
-  _attrs_content: () => _attrs_content,
-  _attrs_partial: () => _attrs_partial,
-  _attrs_partial_content: () => _attrs_partial_content,
-  _attrs_script: () => _attrs_script,
-  _await_content: () => _await_content,
-  _await_promise: () => _await_promise,
-  _call: () => _call,
-  _child_setup: () => _child_setup,
-  _closure: () => _closure,
-  _closure_get: () => _closure_get,
-  _const: () => _const,
-  _content: () => _content,
-  _content_closures: () => _content_closures,
-  _content_resume: () => _content_resume,
-  _dynamic_tag: () => _dynamic_tag,
-  _el: () => _el,
-  _el_read: () => _el_read,
-  _enable_catch: () => _enable_catch,
-  _for_closure: () => _for_closure,
-  _for_in: () => _for_in,
-  _for_of: () => _for_of,
-  _for_to: () => _for_to,
-  _for_until: () => _for_until,
-  _hoist: () => _hoist,
-  _hoist_resume: () => _hoist_resume,
-  _html: () => _html,
-  _id: () => _id,
-  _if: () => _if,
-  _if_closure: () => _if_closure,
-  _let: () => _let,
-  _lifecycle: () => _lifecycle,
-  _on: () => _on,
-  _or: () => _or,
-  _resume: () => _resume,
-  _resume_dynamic_tag: () => _resume_dynamic_tag,
-  _return: () => _return,
-  _return_change: () => _return_change,
-  _script: () => _script,
-  _template: () => _template,
-  _text: () => _text,
-  _text_content: () => _text_content,
-  _to_text: () => _to_text,
-  _try: () => _try,
-  _var: () => _var,
-  _var_change: () => _var_change,
-  _var_resume: () => _var_resume,
-  attrTag: () => attrTag,
-  attrTags: () => attrTags,
-  compat: () => compat,
-  forIn: () => forIn,
-  forOf: () => forOf,
-  forTo: () => forTo,
-  forUntil: () => forUntil,
-  init: () => init,
-  initEmbedded: () => initEmbedded,
-  run: () => run
-});
-module.exports = __toCommonJS(dom_exports);
-
-// src/common/attr-tag.ts
-var empty = [];
-var rest = true ? /* @__PURE__ */ Symbol("Attribute Tag") : /* @__PURE__ */ Symbol();
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/common/attr-tag.ts
+const empty = [];
+const rest = Symbol("Attribute Tag");
 function attrTag(attrs) {
-  attrs[Symbol.iterator] = attrTagIterator;
-  attrs[rest] = empty;
-  return attrs;
+	attrs[Symbol.iterator] = attrTagIterator;
+	attrs[rest] = empty;
+	return attrs;
 }
 function attrTags(first, attrs) {
-  if (first) {
-    if (first[rest] === empty) {
-      first[rest] = [attrs];
-    } else {
-      first[rest].push(attrs);
-    }
-    return first;
-  }
-  return attrTag(attrs);
+	if (first) {
+		if (first[rest] === empty) first[rest] = [attrs];
+		else first[rest].push(attrs);
+		return first;
+	}
+	return attrTag(attrs);
 }
 function* attrTagIterator() {
-  yield this;
-  yield* this[rest];
+	yield this;
+	yield* this[rest];
 }
-
-// src/common/errors.ts
+//#endregion
+//#region src/common/errors.ts
 function _el_read_error() {
-  if (true) {
-    throw new Error(
-      "Element references can only be read in scripts and event handlers."
-    );
-  }
+	throw new Error("Element references can only be read in scripts and event handlers.");
 }
 function _hoist_read_error() {
-  if (true) {
-    throw new Error(
-      "Hoisted values can only be read in scripts and event handlers."
-    );
-  }
+	throw new Error("Hoisted values can only be read in scripts and event handlers.");
 }
 function _assert_hoist(value) {
-  if (typeof value !== "function") {
-    throw new Error(
-      `Hoisted values must be functions, received type "${typeof value}".`
-    );
-  }
+	if (typeof value !== "function") throw new Error(`Hoisted values must be functions, received type "${typeof value}".`);
 }
 function _assert_init(scope, accessor) {
-  if (scope["#Creating" /* Creating */] || !(accessor in scope)) {
-    try {
-      __UNINITIALIZED__;
-      const __UNINITIALIZED__ = 1;
-    } catch (err) {
-      err.message = err.message.replaceAll("__UNINITIALIZED__", accessor);
-      throw err;
-    }
-    throw new ReferenceError(
-      `Cannot access "${accessor}" before initialization.`
-    );
-  }
-  return scope[accessor];
+	if (scope["#Creating"] || !(accessor in scope)) throw new ReferenceError(`Cannot access "${accessor}" before initialization.`);
+	return scope[accessor];
 }
 function assertExclusiveAttrs(attrs, onError = throwErr) {
-  if (attrs) {
-    let exclusiveAttrs;
-    if (attrs.checkedChange) {
-      (exclusiveAttrs ||= []).push("checkedChange");
-    }
-    if (attrs.checkedValue) {
-      (exclusiveAttrs ||= []).push("checkedValue");
-      if (attrs.checked) {
-        exclusiveAttrs.push("checked");
-      }
-    } else if (attrs.checkedValueChange) {
-      (exclusiveAttrs ||= []).push("checkedValueChange");
-      if (attrs.checked) {
-        exclusiveAttrs.push("checked");
-      }
-    }
-    if (attrs.valueChange) {
-      (exclusiveAttrs ||= []).push("valueChange");
-    }
-    if (exclusiveAttrs && exclusiveAttrs.length > 1) {
-      onError(
-        `The attributes ${joinWithAnd(exclusiveAttrs)} are mutually exclusive.`
-      );
-    }
-  }
+	if (attrs) {
+		let exclusiveAttrs;
+		if (attrs.checkedChange) (exclusiveAttrs ||= []).push("checkedChange");
+		if (attrs.checkedValue) {
+			(exclusiveAttrs ||= []).push("checkedValue");
+			if (attrs.checked) exclusiveAttrs.push("checked");
+		} else if (attrs.checkedValueChange) {
+			(exclusiveAttrs ||= []).push("checkedValueChange");
+			if (attrs.checked) exclusiveAttrs.push("checked");
+		}
+		if (attrs.valueChange) (exclusiveAttrs ||= []).push("valueChange");
+		if (exclusiveAttrs && exclusiveAttrs.length > 1) onError(`The attributes ${joinWithAnd(exclusiveAttrs)} are mutually exclusive.`);
+	}
 }
 function assertValidTagName(tagName) {
-  if (!/^[a-z][a-z0-9._-]*$/i.test(tagName)) {
-    throw new Error(
-      `Invalid tag name: "${tagName}". Tag names must start with a letter and contain only letters, numbers, periods, hyphens, and underscores.`
-    );
-  }
+	if (!/^[a-z][a-z0-9._-]*$/i.test(tagName)) throw new Error(`Invalid tag name: "${tagName}". Tag names must start with a letter and contain only letters, numbers, periods, hyphens, and underscores.`);
 }
 function throwErr(msg) {
-  throw new Error(msg);
+	throw new Error(msg);
 }
 function joinWithAnd(a) {
-  switch (a.length) {
-    case 0:
-      return "";
-    case 1:
-      return a[0];
-    case 2:
-      return `${a[0]} and ${a[1]}`;
-    default:
-      return `${a.slice(0, -1).join(", ")}, and ${a[a.length - 1]}`;
-  }
-}
-
-// src/common/for.ts
+	switch (a.length) {
+		case 0: return "";
+		case 1: return a[0];
+		case 2: return `${a[0]} and ${a[1]}`;
+		default: return `${a.slice(0, -1).join(", ")}, and ${a[a.length - 1]}`;
+	}
+}
+//#endregion
+//#region src/common/for.ts
 function forIn(obj, cb) {
-  for (const key in obj) {
-    cb(key, obj[key]);
-  }
+	for (const key in obj) cb(key, obj[key]);
 }
 function forOf(list, cb) {
-  if (list) {
-    let i = 0;
-    for (const item of list) {
-      cb(item, i++);
-    }
-  }
+	if (list) {
+		let i = 0;
+		for (const item of list) cb(item, i++);
+	}
 }
 function forTo(to, from, step, cb) {
-  const start = from || 0;
-  const delta = step || 1;
-  for (let steps = (to - start) / delta, i = 0; i <= steps; i++) {
-    cb(start + i * delta);
-  }
+	const start = from || 0;
+	const delta = step || 1;
+	for (let steps = (to - start) / delta, i = 0; i <= steps; i++) cb(start + i * delta);
 }
 function forUntil(until, from, step, cb) {
-  const start = from || 0;
-  const delta = step || 1;
-  for (let steps = (until - start) / delta, i = 0; i < steps; i++) {
-    cb(start + i * delta);
-  }
-}
-
-// src/common/helpers.ts
-var htmlAttrNameReg = /^[^a-z_]|[^a-z0-9._:-]/i;
-function _call(fn, v) {
-  fn(v);
-  return v;
+	const start = from || 0;
+	const delta = step || 1;
+	for (let steps = (until - start) / delta, i = 0; i < steps; i++) cb(start + i * delta);
 }
-function classValue(classValue2) {
-  return toDelimitedString(classValue2, " ", stringifyClassObject);
+//#endregion
+//#region src/common/helpers.ts
+const htmlAttrNameReg = /^[^a-z_]|[^a-z0-9._:-]/i;
+function _call(fn, v) {
+	fn(v);
+	return v;
 }
 function stringifyClassObject(name, value) {
-  return value ? name : "";
-}
-function styleValue(styleValue2) {
-  return toDelimitedString(styleValue2, ";", stringifyStyleObject);
+	return value ? name : "";
 }
 function stringifyStyleObject(name, value) {
-  return value || value === 0 ? name + ":" + value : "";
-}
-function toDelimitedString(val, delimiter, stringify) {
-  let str = "";
-  let sep = "";
-  let part;
-  if (val) {
-    if (typeof val !== "object") {
-      str += val;
-    } else if (Array.isArray(val)) {
-      for (const v of val) {
-        part = toDelimitedString(v, delimiter, stringify);
-        if (part) {
-          str += sep + part;
-          sep = delimiter;
-        }
-      }
-    } else {
-      for (const name in val) {
-        part = stringify(name, val[name]);
-        if (part) {
-          str += sep + part;
-          sep = delimiter;
-        }
-      }
-    }
-  }
-  return str;
-}
+	return value || value === 0 ? name + ":" + value : "";
+}
+const toDelimitedString = function toDelimitedString(val, delimiter, stringify) {
+	let str = "";
+	let sep = "";
+	let part;
+	if (val) if (typeof val !== "object") str += val;
+	else if (Array.isArray(val)) for (const v of val) {
+		part = toDelimitedString(v, delimiter, stringify);
+		if (part) {
+			str += sep + part;
+			sep = delimiter;
+		}
+	}
+	else for (const name in val) {
+		part = stringify(name, val[name]);
+		if (part) {
+			str += sep + part;
+			sep = delimiter;
+		}
+	}
+	return str;
+};
 function isEventHandler(name) {
-  return /^on[A-Z-]/.test(name);
+	return /^on[A-Z-]/.test(name);
 }
 function getEventHandlerName(name) {
-  return name[2] === "-" ? name.slice(3) : name.slice(2).toLowerCase();
+	return name[2] === "-" ? name.slice(3) : name.slice(2).toLowerCase();
 }
 function normalizeDynamicRenderer(value) {
-  if (value) {
-    if (typeof value === "string") return value;
-    const normalized = value.content || value.default || value;
-    if (/* @__KEY__ */ "___id" in normalized) {
-      return normalized;
-    }
-  }
-}
-
-// src/common/meta.ts
-var DEFAULT_RUNTIME_ID = "M";
-var DEFAULT_RENDER_ID = "_";
-var DYNAMIC_TAG_SCRIPT_REGISTER_ID = true ? "_dynamicTagScript" : "d";
-
-// src/common/opt.ts
+	if (value) {
+		if (typeof value === "string") return value;
+		const normalized = value.content || value.default || value;
+		if ("id" in normalized) return normalized;
+	}
+}
+//#endregion
+//#region src/common/meta.ts
+const DYNAMIC_TAG_SCRIPT_REGISTER_ID = "_dynamicTagScript";
+//#endregion
+//#region src/common/opt.ts
 function toArray(opt) {
-  return opt ? Array.isArray(opt) ? opt : [opt] : [];
+	return opt ? Array.isArray(opt) ? opt : [opt] : [];
 }
 function push(opt, item) {
-  return opt ? Array.isArray(opt) ? (opt.push(item), opt) : [opt, item] : item;
+	return opt ? Array.isArray(opt) ? (opt.push(item), opt) : [opt, item] : item;
 }
-
-// src/dom/event.ts
-var defaultDelegator = createDelegator();
+//#endregion
+//#region src/dom/event.ts
+const defaultDelegator = /* @__PURE__ */ createDelegator();
 function _on(element, type, handler) {
-  if (element["$" + type] === void 0) {
-    defaultDelegator(element, type, handleDelegated);
-  }
-  element["$" + type] = handler || null;
+	if (element["$" + type] === void 0) defaultDelegator(element, type, handleDelegated);
+	element["$" + type] = handler || null;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function createDelegator() {
-  const kEvents = /* @__PURE__ */ Symbol();
-  return function ensureDelegated(node, type, handler) {
-    ((node = node.getRootNode())[kEvents] ||= {})[type] ||= (node.addEventListener(type, handler, true), 1);
-  };
+	const kEvents = Symbol();
+	return function ensureDelegated(node, type, handler) {
+		((node = node.getRootNode())[kEvents] ||= {})[type] ||= (node.addEventListener(type, handler, true), 1);
+	};
 }
 function handleDelegated(ev) {
-  let target = !rendering && ev.target;
-  if (true) {
-    Object.defineProperty(ev, "currentTarget", {
-      configurable: true,
-      get() {
-        console.error(
-          "Event.currentTarget is not supported in Marko's delegated events. Instead use an element reference or the second parameter of the event handler."
-        );
-        return null;
-      }
-    });
-  }
-  while (target) {
-    target["$" + ev.type]?.(ev, target);
-    target = ev.bubbles && !ev.cancelBubble && target.parentNode;
-  }
-  if (true) {
-    delete ev.currentTarget;
-  }
-}
-
-// src/dom/resolve-cursor-position.ts
-var R = /[^\p{L}\p{N}]/gu;
-function resolveCursorPosition(inputType2, initialPosition, initialValue, updatedValue) {
-  if (
-    // If initial position is null or false then
-    // either this node is not the active element
-    // or does not support selection ranges.
-    (initialPosition || initialPosition === 0) && (initialPosition !== initialValue.length || // short regex to match input types that delete backwards
-    /kw/.test(inputType2))
-  ) {
-    const before = initialValue.slice(0, initialPosition);
-    const after = initialValue.slice(initialPosition);
-    if (updatedValue.startsWith(before)) return initialPosition;
-    if (updatedValue.endsWith(after)) return updatedValue.length - after.length;
-    let count = before.replace(R, "").length;
-    let pos = 0;
-    while (count && updatedValue[pos]) {
-      if (updatedValue[pos++].replace(R, "")) count--;
-    }
-    return pos;
-  }
-  return -1;
-}
-
-// src/dom/parse-html.ts
-var parsers = {};
+	let target = !rendering && ev.target;
+	Object.defineProperty(ev, "currentTarget", {
+		configurable: true,
+		get() {
+			console.error("Event.currentTarget is not supported in Marko's delegated events. Instead use an element reference or the second parameter of the event handler.");
+			return null;
+		}
+	});
+	while (target) {
+		target["$" + ev.type]?.(ev, target);
+		target = ev.bubbles && !ev.cancelBubble && target.parentNode;
+	}
+	delete ev.currentTarget;
+}
+//#endregion
+//#region src/dom/resolve-cursor-position.ts
+const R = /[^\p{L}\p{N}]/gu;
+function resolveCursorPosition(inputType, initialPosition, initialValue, updatedValue) {
+	if ((initialPosition || initialPosition === 0) && (initialPosition !== initialValue.length || /kw/.test(inputType))) {
+		const before = initialValue.slice(0, initialPosition);
+		const after = initialValue.slice(initialPosition);
+		if (updatedValue.startsWith(before)) return initialPosition;
+		if (updatedValue.endsWith(after)) return updatedValue.length - after.length;
+		let count = before.replace(R, "").length;
+		let pos = 0;
+		while (count && updatedValue[pos]) if (updatedValue[pos++].replace(R, "")) count--;
+		return pos;
+	}
+	return -1;
+}
+//#endregion
+//#region src/dom/parse-html.ts
+const parsers = {};
 function parseHTML(html, ns) {
-  const parser = parsers[ns] ||= document.createElementNS(ns, "template");
-  parser.innerHTML = html;
-  return parser.content || parser;
+	const parser = parsers[ns] ||= document.createElementNS(ns, "template");
+	parser.innerHTML = html;
+	return parser.content || parser;
 }
-
-// src/dom/scope.ts
-var nextScopeId = 1e6;
+//#endregion
+//#region src/dom/scope.ts
+let nextScopeId = 1e6;
 function createScope($global, closestBranch) {
-  const scope = {
-    ["#Id" /* Id */]: nextScopeId++,
-    ["#Creating" /* Creating */]: 1,
-    ["#ClosestBranch" /* ClosestBranch */]: closestBranch,
-    ["$global" /* Global */]: $global
-  };
-  pendingScopes.push(scope);
-  return scope;
+	const scope = {
+		["#Id"]: nextScopeId++,
+		["#Creating"]: 1,
+		["#ClosestBranch"]: closestBranch,
+		["$global"]: $global
+	};
+	pendingScopes.push(scope);
+	return scope;
 }
 function skipScope() {
-  return nextScopeId++;
+	return nextScopeId++;
 }
 function findBranchWithKey(scope, key) {
-  let branch = scope["#ClosestBranch" /* ClosestBranch */];
-  while (branch && branch[key] == null) {
-    branch = branch["#ParentBranch" /* ParentBranch */];
-  }
-  return branch;
+	let branch = scope["#ClosestBranch"];
+	while (branch && branch[key] == null) branch = branch["#ParentBranch"];
+	return branch;
 }
 function destroyBranch(branch) {
-  branch["#ParentBranch" /* ParentBranch */]?.["#BranchScopes" /* BranchScopes */]?.delete(
-    branch
-  );
-  destroyNestedScopes(branch);
+	branch["#ParentBranch"]?.["#BranchScopes"]?.delete(branch);
+	destroyNestedScopes(branch);
 }
 function destroyScope(scope) {
-  if (!scope["#Destroyed" /* Destroyed */]) {
-    destroyNestedScopes(scope);
-    resetControllers(scope);
-  }
-}
-function destroyNestedScopes(scope) {
-  scope["#Destroyed" /* Destroyed */] = 1;
-  scope["#BranchScopes" /* BranchScopes */]?.forEach(destroyNestedScopes);
-  scope["#AbortScopes" /* AbortScopes */]?.forEach(resetControllers);
-}
+	if (!scope["#Destroyed"]) {
+		destroyNestedScopes(scope);
+		resetControllers(scope);
+	}
+}
+const destroyNestedScopes = function destroyNestedScopes(scope) {
+	scope["#Destroyed"] = 1;
+	scope["#BranchScopes"]?.forEach(destroyNestedScopes);
+	scope["#AbortScopes"]?.forEach(resetControllers);
+};
 function resetControllers(scope) {
-  for (const id in scope["#AbortControllers" /* AbortControllers */]) {
-    $signalReset(scope, id);
-  }
+	for (const id in scope["#AbortControllers"]) $signalReset(scope, id);
 }
 function removeAndDestroyBranch(branch) {
-  destroyBranch(branch);
-  removeChildNodes(
-    branch["#StartNode" /* StartNode */],
-    branch["#EndNode" /* EndNode */]
-  );
+	destroyBranch(branch);
+	removeChildNodes(branch["#StartNode"], branch["#EndNode"]);
 }
 function insertBranchBefore(branch, parentNode, nextSibling) {
-  insertChildNodes(
-    parentNode,
-    nextSibling,
-    branch["#StartNode" /* StartNode */],
-    branch["#EndNode" /* EndNode */]
-  );
+	insertChildNodes(parentNode, nextSibling, branch["#StartNode"], branch["#EndNode"]);
 }
 function tempDetachBranch(branch) {
-  const fragment = new DocumentFragment();
-  fragment.namespaceURI = branch["#StartNode" /* StartNode */].parentNode.namespaceURI;
-  insertChildNodes(
-    fragment,
-    null,
-    branch["#StartNode" /* StartNode */],
-    branch["#EndNode" /* EndNode */]
-  );
-}
-
-// src/dom/schedule.ts
-var runTask;
-var isScheduled;
-var channel;
+	const fragment = new DocumentFragment();
+	fragment.namespaceURI = branch["#StartNode"].parentNode.namespaceURI;
+	insertChildNodes(fragment, null, branch["#StartNode"], branch["#EndNode"]);
+}
+//#endregion
+//#region src/dom/schedule.ts
+let runTask;
+let isScheduled;
+let channel;
 function schedule() {
-  if (!isScheduled) {
-    if (true) {
-      if (console.createTask) {
-        const task = console.createTask("queue");
-        runTask = () => task.run(run);
-      } else {
-        runTask = run;
-      }
-    }
-    isScheduled = 1;
-    queueMicrotask(flushAndWaitFrame);
-  }
+	if (!isScheduled) {
+		if (console.createTask) {
+			const task = console.createTask("queue");
+			runTask = () => task.run(run);
+		} else runTask = run;
+		isScheduled = 1;
+		queueMicrotask(flushAndWaitFrame);
+	}
 }
 function flushAndWaitFrame() {
-  if (true) {
-    runTask();
-  } else {
-    run();
-  }
-  requestAnimationFrame(triggerMacroTask);
+	runTask();
+	requestAnimationFrame(triggerMacroTask);
 }
 function triggerMacroTask() {
-  if (!channel) {
-    channel = new MessageChannel();
-    channel.port1.onmessage = () => {
-      isScheduled = 0;
-      if (true) {
-        const run2 = runTask;
-        runTask = void 0;
-        run2();
-      } else {
-        run();
-      }
-    };
-  }
-  channel.port2.postMessage(0);
-}
-
-// src/dom/signals.ts
+	if (!channel) {
+		channel = new MessageChannel();
+		channel.port1.onmessage = () => {
+			isScheduled = 0;
+			{
+				const run = runTask;
+				runTask = void 0;
+				run();
+			}
+		};
+	}
+	channel.port2.postMessage(0);
+}
+//#endregion
+//#region src/dom/signals.ts
 function _let(id, fn) {
-  const valueAccessor = true ? id.slice(0, id.lastIndexOf("/")) : decodeAccessor(id);
-  const valueChangeAccessor = "TagVariableChange:" /* TagVariableChange */ + valueAccessor;
-  if (true) {
-    id = +id.slice(id.lastIndexOf("/") + 1);
-  }
-  return (scope, value, valueChange) => {
-    if (rendering) {
-      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value || scope["#Creating" /* Creating */]) {
-        scope[valueAccessor] = value;
-        fn?.(scope);
-      }
-    } else if (scope[valueChangeAccessor]) {
-      scope[valueChangeAccessor](value);
-    } else if (scope[valueAccessor] !== (scope[valueAccessor] = value) && fn) {
-      schedule();
-      queueRender(scope, fn, id);
-    }
-    return value;
-  };
+	const valueAccessor = id.slice(0, id.lastIndexOf("/"));
+	const valueChangeAccessor = "TagVariableChange:" + valueAccessor;
+	id = +id.slice(id.lastIndexOf("/") + 1);
+	return (scope, value, valueChange) => {
+		if (rendering) {
+			if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value || scope["#Creating"]) {
+				scope[valueAccessor] = value;
+				fn?.(scope);
+			}
+		} else if (scope[valueChangeAccessor]) scope[valueChangeAccessor](value);
+		else if (scope[valueAccessor] !== (scope[valueAccessor] = value) && fn) {
+			schedule();
+			queueRender(scope, fn, id);
+		}
+		return value;
+	};
 }
 function _const(valueAccessor, fn) {
-  if (false) valueAccessor = decodeAccessor(valueAccessor);
-  return (scope, value) => {
-    if (!(valueAccessor in scope) || scope[valueAccessor] !== value) {
-      scope[valueAccessor] = value;
-      fn?.(scope);
-    }
-  };
-}
-function _or(id, fn, defaultPending = 1, scopeIdAccessor = "#Id" /* Id */) {
-  if (false) {
-    scopeIdAccessor = decodeAccessor(scopeIdAccessor);
-  }
-  return (scope) => {
-    if (scope["#Creating" /* Creating */]) {
-      if (id in scope) {
-        if (!--scope[id]) {
-          fn(scope);
-        }
-      } else {
-        scope[id] = defaultPending;
-      }
-    } else {
-      queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
-    }
-  };
+	return (scope, value) => {
+		if (!(valueAccessor in scope) || scope[valueAccessor] !== value) {
+			scope[valueAccessor] = value;
+			fn?.(scope);
+		}
+	};
+}
+function _or(id, fn, defaultPending = 1, scopeIdAccessor = "#Id") {
+	return (scope) => {
+		if (scope["#Creating"]) if (id in scope) {
+			if (!--scope[id]) fn(scope);
+		} else scope[id] = defaultPending;
+		else queueRender(scope, fn, id, 0, scope[scopeIdAccessor]);
+	};
 }
 function _for_closure(ownerLoopNodeAccessor, fn) {
-  if (false)
-    ownerLoopNodeAccessor = decodeAccessor(ownerLoopNodeAccessor);
-  const scopeAccessor = "BranchScopes:" /* BranchScopes */ + ownerLoopNodeAccessor;
-  const ownerSignal = (ownerScope) => {
-    const scopes = toArray(ownerScope[scopeAccessor]);
-    if (scopes.length) {
-      queueRender(
-        ownerScope,
-        () => {
-          for (const scope of scopes) {
-            if (!scope["#Creating" /* Creating */] && !scope["#Destroyed" /* Destroyed */]) {
-              fn(scope);
-            }
-          }
-        },
-        -1,
-        0,
-        scopes[0]["#Id" /* Id */]
-      );
-    }
-  };
-  ownerSignal._ = fn;
-  return ownerSignal;
+	const scopeAccessor = "BranchScopes:" + ownerLoopNodeAccessor;
+	const ownerSignal = (ownerScope) => {
+		const scopes = toArray(ownerScope[scopeAccessor]);
+		if (scopes.length) queueRender(ownerScope, () => {
+			for (const scope of scopes) if (!scope["#Creating"] && !scope["#Destroyed"]) fn(scope);
+		}, -1, 0, scopes[0]["#Id"]);
+	};
+	ownerSignal._ = fn;
+	return ownerSignal;
 }
 function _if_closure(ownerConditionalNodeAccessor, branch, fn) {
-  if (false)
-    ownerConditionalNodeAccessor = decodeAccessor(
-      ownerConditionalNodeAccessor
-    );
-  const scopeAccessor = "BranchScopes:" /* BranchScopes */ + ownerConditionalNodeAccessor;
-  const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
-  const ownerSignal = (scope) => {
-    const ifScope = scope[scopeAccessor];
-    if (ifScope && !ifScope["#Creating" /* Creating */] && (scope[branchAccessor] || 0) === branch) {
-      queueRender(ifScope, fn, -1);
-    }
-  };
-  ownerSignal._ = fn;
-  return ownerSignal;
+	const scopeAccessor = "BranchScopes:" + ownerConditionalNodeAccessor;
+	const branchAccessor = "ConditionalRenderer:" + ownerConditionalNodeAccessor;
+	const ownerSignal = (scope) => {
+		const ifScope = scope[scopeAccessor];
+		if (ifScope && !ifScope["#Creating"] && (scope[branchAccessor] || 0) === branch) queueRender(ifScope, fn, -1);
+	};
+	ownerSignal._ = fn;
+	return ownerSignal;
 }
 function subscribeToScopeSet(ownerScope, accessor, scope) {
-  const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
-  if (!subscribers.has(scope)) {
-    subscribers.add(scope);
-    $signal(scope, -1).addEventListener(
-      "abort",
-      () => ownerScope[accessor].delete(scope)
-    );
-  }
+	const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
+	if (!subscribers.has(scope)) {
+		subscribers.add(scope);
+		$signal(scope, -1).addEventListener("abort", () => ownerScope[accessor].delete(scope));
+	}
 }
 function _closure(...closureSignals) {
-  const [{ ___scopeInstancesAccessor, ___signalIndexAccessor }] = closureSignals;
-  for (let i = closureSignals.length; i--; ) {
-    closureSignals[i].___index = i;
-  }
-  return (scope) => {
-    if (scope[___scopeInstancesAccessor]) {
-      for (const childScope of scope[___scopeInstancesAccessor]) {
-        if (!childScope["#Creating" /* Creating */]) {
-          queueRender(
-            childScope,
-            closureSignals[childScope[___signalIndexAccessor] || 0],
-            -1
-          );
-        }
-      }
-    }
-  };
+	const [firstSignal] = closureSignals;
+	const scopeInstances = firstSignal["scopeInstancesAccessor"];
+	const signalIndex = firstSignal["signalIndexAccessor"];
+	for (let i = closureSignals.length; i--;) closureSignals[i]["index"] = i;
+	return (scope) => {
+		if (scope[scopeInstances]) {
+			for (const childScope of scope[scopeInstances]) if (!childScope["#Creating"]) queueRender(childScope, closureSignals[childScope[signalIndex] || 0], -1);
+		}
+	};
 }
 function _closure_get(valueAccessor, fn, getOwnerScope, resumeId) {
-  if (false) valueAccessor = decodeAccessor(valueAccessor);
-  const closureSignal = ((scope) => {
-    scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
-    fn(scope);
-    subscribeToScopeSet(
-      getOwnerScope ? getOwnerScope(scope) : scope["_" /* Owner */],
-      closureSignal.___scopeInstancesAccessor,
-      scope
-    );
-  });
-  closureSignal.___scopeInstancesAccessor = "ClosureScopes:" /* ClosureScopes */ + valueAccessor;
-  closureSignal.___signalIndexAccessor = "ClosureSignalIndex:" /* ClosureSignalIndex */ + valueAccessor;
-  resumeId && _resume(resumeId, closureSignal);
-  return closureSignal;
+	const closureSignal = ((scope) => {
+		scope[closureSignal["signalIndexAccessor"]] = closureSignal["index"];
+		fn(scope);
+		subscribeToScopeSet(getOwnerScope ? getOwnerScope(scope) : scope["_"], closureSignal["scopeInstancesAccessor"], scope);
+	});
+	closureSignal["scopeInstancesAccessor"] = "ClosureScopes:" + valueAccessor;
+	closureSignal["signalIndexAccessor"] = "ClosureSignalIndex:" + valueAccessor;
+	resumeId && _resume(resumeId, closureSignal);
+	return closureSignal;
 }
 function _child_setup(setup) {
-  setup._ = (scope, owner) => {
-    scope["_" /* Owner */] = owner;
-    queueRender(scope, setup, -1);
-  };
-  return setup;
+	setup._ = (scope, owner) => {
+		scope["_"] = owner;
+		queueRender(scope, setup, -1);
+	};
+	return setup;
 }
 function _var(scope, childAccessor, signal) {
-  scope[true ? childAccessor : decodeAccessor(childAccessor)]["#TagVariable" /* TagVariable */] = (value) => signal(scope, value);
+	scope[childAccessor]["#TagVariable"] = (value) => signal(scope, value);
 }
-var _return = (scope, value) => scope["#TagVariable" /* TagVariable */]?.(value);
+const _return = (scope, value) => scope["#TagVariable"]?.(value);
 function _return_change(scope, changeHandler) {
-  if (changeHandler) {
-    scope["#TagVariableChange" /* TagVariableChange */] = changeHandler;
-  }
-}
-var _var_change = true ? (scope, value, name = "This") => {
-  if (typeof scope["#TagVariableChange" /* TagVariableChange */] !== "function") {
-    throw new TypeError(`${name} is a readonly tag variable.`);
-  }
-  scope["#TagVariableChange" /* TagVariableChange */](value);
-} : (scope, value) => scope["#TagVariableChange" /* TagVariableChange */]?.(value);
-var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
-function _id({ ["$global" /* Global */]: $global }) {
-  const id = tagIdsByGlobal.get($global) || 0;
-  tagIdsByGlobal.set($global, id + 1);
-  return "c" + $global.runtimeId + $global.renderId + id.toString(36);
+	if (changeHandler) scope["#TagVariableChange"] = changeHandler;
+}
+const _var_change = (scope, value, name = "This") => {
+	if (typeof scope["#TagVariableChange"] !== "function") throw new TypeError(`${name} is a readonly tag variable.`);
+	scope["#TagVariableChange"](value);
+};
+const tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
+function _id({ ["$global"]: $global }) {
+	const id = tagIdsByGlobal.get($global) || 0;
+	tagIdsByGlobal.set($global, id + 1);
+	return "c" + $global.runtimeId + $global.renderId + id.toString(36);
 }
 function _script(id, fn) {
-  _resume(id, fn);
-  return (scope) => {
-    queueEffect(scope, fn);
-  };
+	_resume(id, fn);
+	return (scope) => {
+		queueEffect(scope, fn);
+	};
 }
 function _el_read(value) {
-  if (rendering) {
-    _el_read_error();
-  }
-  return value;
+	if (rendering) _el_read_error();
+	return value;
 }
 function* traverse(scope, path, i = path.length - 1) {
-  if (rendering) {
-    _hoist_read_error();
-  }
-  if (scope) {
-    if (Symbol.iterator in scope) {
-      for (const childScope of scope.values()) {
-        yield* traverse(childScope, path, i);
-      }
-    } else {
-      const item = scope[path[i]];
-      if (i) {
-        yield* traverse(item, path, i - 1);
-      } else {
-        yield typeof item === "function" ? item() : item;
-      }
-    }
-  }
+	if (rendering) _hoist_read_error();
+	if (scope) if (Symbol.iterator in scope) for (const childScope of scope.values()) yield* traverse(childScope, path, i);
+	else {
+		const item = scope[path[i]];
+		if (i) yield* traverse(item, path, i - 1);
+		else yield typeof item === "function" ? item() : item;
+	}
 }
 function _hoist(...path) {
-  if (false)
-    path = path.map((p) => typeof p === "string" ? p : decodeAccessor(p));
-  return (scope) => {
-    const fn = () => traverse(scope, path).next().value;
-    fn[Symbol.iterator] = () => traverse(scope, path);
-    return fn;
-  };
+	return (scope) => {
+		const fn = () => traverse(scope, path).next().value;
+		fn[Symbol.iterator] = () => traverse(scope, path);
+		return fn;
+	};
 }
 function _hoist_resume(id, ...path) {
-  return _resume(id, _hoist(...path));
+	return _resume(id, _hoist(...path));
 }
-
-// src/dom/walker.ts
-var walker = /* @__PURE__ */ document.createTreeWalker(document);
+//#endregion
+//#region src/dom/walker.ts
+const walker = /* @__PURE__ */ document.createTreeWalker(document);
 function walk(startNode, walkCodes, branch) {
-  walker.currentNode = startNode;
-  walkInternal(0, walkCodes, branch);
-}
-function walkInternal(currentWalkIndex, walkCodes, scope) {
-  let value;
-  let currentMultiplier;
-  let storedMultiplier = 0;
-  let currentScopeIndex = 0;
-  for (; currentWalkIndex < walkCodes.length; ) {
-    value = walkCodes.charCodeAt(currentWalkIndex++);
-    currentMultiplier = storedMultiplier;
-    storedMultiplier = 0;
-    if (value === 32 /* Get */) {
-      const node = walker.currentNode;
-      scope[true ? getDebugKey(currentScopeIndex++, node) : decodeAccessor2(currentScopeIndex++)] = node;
-    } else if (value === 37 /* Replace */ || value === 49 /* DynamicTagWithVar */) {
-      walker.currentNode.replaceWith(
-        walker.currentNode = scope[true ? getDebugKey(currentScopeIndex++, "#text") : decodeAccessor2(currentScopeIndex++)] = new Text()
-      );
-      if (value === 49 /* DynamicTagWithVar */) {
-        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : decodeAccessor2(currentScopeIndex++)] = skipScope();
-      }
-    } else if (value === 38 /* EndChild */) {
-      return currentWalkIndex;
-    } else if (value === 47 /* BeginChild */ || value === 48 /* BeginChildWithVar */) {
-      currentWalkIndex = walkInternal(
-        currentWalkIndex,
-        walkCodes,
-        scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : decodeAccessor2(currentScopeIndex++)] = createScope(
-          scope["$global" /* Global */],
-          scope["#ClosestBranch" /* ClosestBranch */]
-        )
-      );
-      if (value === 48 /* BeginChildWithVar */) {
-        scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : decodeAccessor2(currentScopeIndex++)] = skipScope();
-      }
-    } else if (value < 91 /* NextEnd */ + 1) {
-      value = 20 /* Next */ * currentMultiplier + value - 67 /* Next */;
-      while (value--) {
-        walker.nextNode();
-      }
-    } else if (value < 106 /* OverEnd */ + 1) {
-      value = 10 /* Over */ * currentMultiplier + value - 97 /* Over */;
-      while (value--) {
-        walker.nextSibling();
-      }
-    } else if (value < 116 /* OutEnd */ + 1) {
-      value = 10 /* Out */ * currentMultiplier + value - 107 /* Out */;
-      while (value--) {
-        walker.parentNode();
-      }
-      walker.nextSibling();
-    } else {
-      if (value < 117 /* Multiplier */ || value > 126 /* MultiplierEnd */) {
-        throw new Error(`Unknown walk code: ${value}`);
-      }
-      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value - 117 /* Multiplier */;
-    }
-  }
-}
+	walker.currentNode = startNode;
+	walkInternal(0, walkCodes, branch);
+}
+const walkInternal = function walkInternal(currentWalkIndex, walkCodes, scope) {
+	let value;
+	let currentMultiplier;
+	let storedMultiplier = 0;
+	let currentScopeIndex = 0;
+	for (; currentWalkIndex < walkCodes.length;) {
+		value = walkCodes.charCodeAt(currentWalkIndex++);
+		currentMultiplier = storedMultiplier;
+		storedMultiplier = 0;
+		if (value === 32) {
+			const node = walker.currentNode;
+			scope[getDebugKey(currentScopeIndex++, node)] = node;
+		} else if (value === 37 || value === 49) {
+			walker.currentNode.replaceWith(walker.currentNode = scope[getDebugKey(currentScopeIndex++, "#text")] = new Text());
+			if (value === 49) scope[getDebugKey(currentScopeIndex++, "#scopeOffset")] = skipScope();
+		} else if (value === 38) return currentWalkIndex;
+		else if (value === 47 || value === 48) {
+			currentWalkIndex = walkInternal(currentWalkIndex, walkCodes, scope[getDebugKey(currentScopeIndex++, "#childScope")] = createScope(scope["$global"], scope["#ClosestBranch"]));
+			if (value === 48) scope[getDebugKey(currentScopeIndex++, "#scopeOffset")] = skipScope();
+		} else if (value < 92) {
+			value = 20 * currentMultiplier + value - 67;
+			while (value--) walker.nextNode();
+		} else if (value < 107) {
+			value = 10 * currentMultiplier + value - 97;
+			while (value--) walker.nextSibling();
+		} else if (value < 117) {
+			value = 10 * currentMultiplier + value - 107;
+			while (value--) walker.parentNode();
+			walker.nextSibling();
+		} else {
+			if (value < 117 || value > 126) throw new Error(`Unknown walk code: ${value}`);
+			storedMultiplier = currentMultiplier * 10 + value - 117;
+		}
+	}
+};
 function getDebugKey(index, node) {
-  if (typeof node === "string") {
-    return `${node}/${index}`;
-  } else if (node.nodeType === 3 /* Text */) {
-    return `#text/${index}`;
-  } else if (node.nodeType === 8 /* Comment */) {
-    return `#comment/${index}`;
-  } else if (node.nodeType === 1 /* Element */) {
-    return `#${node.tagName.toLowerCase()}/${index}`;
-  }
-  return index;
-}
-
-// src/dom/renderer.ts
+	if (typeof node === "string") return `${node}/${index}`;
+	else if (node.nodeType === 3) return `#text/${index}`;
+	else if (node.nodeType === 8) return `#comment/${index}`;
+	else if (node.nodeType === 1) return `#${node.tagName.toLowerCase()}/${index}`;
+	return index;
+}
+//#endregion
+//#region src/dom/renderer.ts
 function createBranch($global, renderer, parentScope, parentNode) {
-  const branch = createScope($global);
-  branch["_" /* Owner */] = renderer.___owner || parentScope;
-  setParentBranch(branch, parentScope?.["#ClosestBranch" /* ClosestBranch */]);
-  if (true) {
-    branch["#Renderer" /* Renderer */] = renderer;
-  }
-  renderer.___clone?.(
-    branch,
-    parentNode.namespaceURI
-  );
-  return branch;
+	const branch = createScope($global);
+	branch["_"] = renderer["owner"] || parentScope;
+	setParentBranch(branch, parentScope?.["#ClosestBranch"]);
+	branch["#Renderer"] = renderer;
+	renderer["clone"]?.(branch, parentNode.namespaceURI);
+	return branch;
 }
 function setParentBranch(branch, parentBranch) {
-  if (parentBranch) {
-    branch["#ParentBranch" /* ParentBranch */] = parentBranch;
-    (parentBranch["#BranchScopes" /* BranchScopes */] ||= /* @__PURE__ */ new Set()).add(branch);
-  }
-  branch["#ClosestBranch" /* ClosestBranch */] = branch;
+	if (parentBranch) {
+		branch["#ParentBranch"] = parentBranch;
+		(parentBranch["#BranchScopes"] ||= /* @__PURE__ */ new Set()).add(branch);
+	}
+	branch["#ClosestBranch"] = branch;
 }
 function createAndSetupBranch($global, renderer, parentScope, parentNode) {
-  return setupBranch(
-    renderer,
-    createBranch($global, renderer, parentScope, parentNode)
-  );
+	return setupBranch(renderer, createBranch($global, renderer, parentScope, parentNode));
 }
 function setupBranch(renderer, branch) {
-  if (renderer.___setup) {
-    queueRender(branch, renderer.___setup, -1);
-  }
-  return branch;
+	if (renderer["setup"]) queueRender(branch, renderer["setup"], -1);
+	return branch;
 }
 function _content(id, template, walks, setup, params, dynamicScopesAccessor) {
-  walks = walks ? walks.replace(/[^\0-1]+$/, "") : "";
-  setup = setup ? setup._ || setup : void 0;
-  params ||= void 0;
-  const clone = template ? (branch, ns) => {
-    ((cloneCache[ns] ||= {})[template] ||= createCloneableHTML(
-      template,
-      ns
-    ))(branch, walks);
-  } : (branch) => {
-    walk(
-      branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = new Text(),
-      walks,
-      branch
-    );
-  };
-  return (owner) => {
-    return {
-      ___id: id,
-      ___clone: clone,
-      ___owner: owner,
-      ___setup: setup,
-      ___params: params,
-      ___accessor: dynamicScopesAccessor
-    };
-  };
+	walks = walks ? walks.replace(/[^\0-1]+$/, "") : "";
+	setup = setup ? setup._ || setup : void 0;
+	params ||= void 0;
+	const clone = template ? (branch, ns) => {
+		((cloneCache[ns] ||= {})[template] ||= createCloneableHTML(template, ns))(branch, walks);
+	} : (branch) => {
+		walk(branch["#StartNode"] = branch["#EndNode"] = new Text(), walks, branch);
+	};
+	return (owner) => {
+		return {
+			["id"]: id,
+			["clone"]: clone,
+			["owner"]: owner,
+			["setup"]: setup,
+			["params"]: params,
+			["accessor"]: dynamicScopesAccessor
+		};
+	};
 }
 function _content_resume(id, template, walks, setup, params, dynamicScopesAccessor) {
-  return _resume(
-    id,
-    _content(id, template, walks, setup, params, dynamicScopesAccessor)
-  );
+	return _resume(id, _content(id, template, walks, setup, params, dynamicScopesAccessor));
 }
 function _content_closures(renderer, closureFns) {
-  const closureSignals = {};
-  for (const key in closureFns) {
-    closureSignals[key] = _const(true ? key : +key, closureFns[key]);
-  }
-  return (owner, closureValues) => {
-    const instance = renderer(owner);
-    instance.___localClosures = closureSignals;
-    instance.___localClosureValues = closureValues;
-    return instance;
-  };
-}
-var cloneCache = {};
+	const closureSignals = {};
+	for (const key in closureFns) closureSignals[key] = _const(key, closureFns[key]);
+	return (owner, closureValues) => {
+		const instance = renderer(owner);
+		instance["localClosures"] = closureSignals;
+		instance["localClosureValues"] = closureValues;
+		return instance;
+	};
+}
+const cloneCache = {};
 function createCloneableHTML(html, ns) {
-  const { firstChild, lastChild } = parseHTML(html, ns);
-  const parent = document.createElementNS(ns, "t");
-  insertChildNodes(parent, null, firstChild, lastChild);
-  return firstChild === lastChild && firstChild.nodeType < 8 /* Comment */ ? (branch, walks) => {
-    walk(
-      branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = firstChild.cloneNode(true),
-      walks,
-      branch
-    );
-  } : (branch, walks) => {
-    const clone = parent.cloneNode(true);
-    walk(clone.firstChild, walks, branch);
-    branch["#StartNode" /* StartNode */] = clone.firstChild;
-    branch["#EndNode" /* EndNode */] = clone.lastChild;
-  };
-}
-
-// src/dom/resume.ts
-var registeredValues = {};
-var curRuntimeId;
-var readyLookup;
-var branchesEnabled;
-var embedEnabled;
+	const { firstChild, lastChild } = parseHTML(html, ns);
+	const parent = document.createElementNS(ns, "t");
+	insertChildNodes(parent, null, firstChild, lastChild);
+	return firstChild === lastChild && firstChild.nodeType < 8 ? (branch, walks) => {
+		walk(branch["#StartNode"] = branch["#EndNode"] = firstChild.cloneNode(true), walks, branch);
+	} : (branch, walks) => {
+		const clone = parent.cloneNode(true);
+		walk(clone.firstChild, walks, branch);
+		branch["#StartNode"] = clone.firstChild;
+		branch["#EndNode"] = clone.lastChild;
+	};
+}
+//#endregion
+//#region src/dom/resume.ts
+const registeredValues = {};
+let curRuntimeId;
+let readyLookup;
+let branchesEnabled;
+let embedEnabled;
 function enableBranches() {
-  branchesEnabled = 1;
+	branchesEnabled = 1;
 }
-var ready = /* @__PURE__ */ ((_) => (id) => {
-  readyLookup[id]?.();
-  readyLookup[id] = 1;
+const ready = /* @__PURE__ */ ((_) => (id) => {
+	readyLookup[id]?.();
+	readyLookup[id] = 1;
 })(readyLookup = {});
 function initEmbedded(readyId, runtimeId) {
-  embedEnabled = 1;
-  ready(readyId);
-  init(runtimeId);
-  new MutationObserver(() => {
-    const renders = self[curRuntimeId];
-    for (const renderId in renders) {
-      const { s, n } = renders[renderId];
-      if (n && !n.isConnected) {
-        delete renders[renderId];
-        for (const id in s) {
-          destroyScope(s[id]);
-        }
-      }
-    }
-  }).observe(document.body, { childList: true, subtree: true });
-}
-function init(runtimeId = DEFAULT_RUNTIME_ID) {
-  if (curRuntimeId) {
-    if (true) {
-      if (curRuntimeId !== runtimeId) {
-        throw new Error(
-          `Marko initialized multiple times with different $global.runtimeId's of ${JSON.stringify(runtimeId)} and ${JSON.stringify(curRuntimeId)}.`
-        );
-      }
-    }
-    return;
-  }
-  curRuntimeId = runtimeId;
-  let resumeRender;
-  const renders = self[runtimeId];
-  const defineRuntime = (desc) => Object.defineProperty(self, runtimeId, desc);
-  const initRuntime = (renders2) => {
-    defineRuntime({
-      value: resumeRender = ((renderId) => {
-        const render = resumeRender[renderId] = renders2[renderId] || renders2(renderId);
-        const walk2 = render.w;
-        const scopeLookup = render.s = {};
-        const getScope = (id) => scopeLookup[id] ||= { ["#Id" /* Id */]: +id };
-        const serializeContext = {
-          _: registeredValues
-        };
-        const visitBranches = branchesEnabled && /* @__PURE__ */ ((branchScopesStack = [], branchStarts = [], orphanBranches = [], curBranchScopes) => {
-          return (branchId, branch, endedBranches, accessor, singleNode, parent = visit.parentNode, startVisit = visit, i = orphanBranches.length) => {
-            if (visitType !== "[" /* BranchStart */) {
-              visitScope[nextToken(
-                /* read accessor */
-              )] = visitType === ")" /* BranchEndOnlyChildInParent */ || visitType === "}" /* BranchEndSingleNodeOnlyChildInParent */ ? parent : visit;
-              accessor = "BranchScopes:" /* BranchScopes */ + lastToken;
-              singleNode = visitType !== "]" /* BranchEnd */ && visitType !== ")" /* BranchEndOnlyChildInParent */;
-              nextToken(
-                /* read optional first branchId */
-              );
-            }
-            while (branchId = +lastToken) {
-              (endedBranches ||= []).push(
-                branch = getScope(branchId)
-              );
-              setParentBranch(branch, branch["#ClosestBranch" /* ClosestBranch */]);
-              if (branch["#AwaitCounter" /* AwaitCounter */] = render.p?.[branchId]) {
-                branch["#AwaitCounter" /* AwaitCounter */].m = render.m;
-              }
-              if (singleNode) {
-                while (startVisit.previousSibling && ~visits.indexOf(
-                  startVisit = startVisit.previousSibling
-                )) ;
-                branch["#EndNode" /* EndNode */] = branch["#StartNode" /* StartNode */] = startVisit;
-                if (visitType === "'" /* BranchEndNativeTag */) {
-                  branch[true ? getDebugKey(0, startVisit) : "a"] = startVisit;
-                }
-              } else {
-                curBranchScopes = push(curBranchScopes, branch);
-                if (accessor) {
-                  visitScope[accessor] = curBranchScopes;
-                  curBranchScopes = branchScopesStack.pop();
-                }
-                startVisit = branchStarts.pop();
-                if (parent !== startVisit.parentNode) {
-                  parent.prepend(startVisit);
-                }
-                branch["#StartNode" /* StartNode */] = startVisit;
-                branch["#EndNode" /* EndNode */] = visit.previousSibling === startVisit ? startVisit : parent.insertBefore(new Text(), visit);
-              }
-              while (i && orphanBranches[--i]["#Id" /* Id */] > branchId) {
-                setParentBranch(orphanBranches.pop(), branch);
-              }
-              nextToken(
-                /* read optional next branchId */
-              );
-            }
-            if (endedBranches) {
-              orphanBranches.push(...endedBranches);
-              if (singleNode) {
-                visitScope[accessor] = endedBranches.length > 1 ? endedBranches.reverse() : endedBranches[0];
-              }
-            }
-            if (visitType === "[" /* BranchStart */) {
-              if (!endedBranches) {
-                branchScopesStack.push(curBranchScopes);
-                curBranchScopes = void 0;
-              }
-              branchStarts.push(visit);
-            }
-          };
-        })();
-        const nextToken = () => lastToken = visitText.slice(
-          lastTokenIndex,
-          (lastTokenIndex = visitText.indexOf(" ", lastTokenIndex) + 1 || visitText.length + 1) - 1
-        );
-        let $global;
-        let lastEffect;
-        let visits;
-        let resumes;
-        let visit;
-        let visitText;
-        let visitType;
-        let visitScope;
-        let lastToken;
-        let lastTokenIndex;
-        let lastScopeId = 0;
-        if (true) {
-          if (render.m) {
-            throw new Error(
-              `Marko rendered multiple times with $global.runtimeId as ${JSON.stringify(runtimeId)} and $global.renderId as ${JSON.stringify(renderId)}. Ensure each render into a page has a unique $global.renderId.`
-            );
-          }
-        }
-        render.m = (effects = []) => {
-          if (readyLookup) {
-            for (const readyId in render.b) {
-              if (readyLookup[readyId] !== 1) {
-                readyLookup[readyId] = /* @__PURE__ */ ((prev) => () => {
-                  render.m();
-                  prev?.();
-                })(readyLookup[readyId]);
-                return effects;
-              }
-            }
-            render.b = 0;
-          }
-          for (const serialized of resumes = render.r || []) {
-            if (typeof serialized === "string") {
-              lastTokenIndex = 0;
-              visitText = serialized;
-              while (nextToken()) {
-                if (/\D/.test(lastToken)) {
-                  lastEffect = registeredValues[lastToken];
-                } else {
-                  effects.push(lastEffect, getScope(lastToken));
-                }
-              }
-            } else {
-              for (const scope of serialized(serializeContext)) {
-                if (!$global) {
-                  $global = scope || {};
-                  $global.runtimeId = runtimeId;
-                  $global.renderId = renderId;
-                } else if (typeof scope === "number") {
-                  lastScopeId += scope;
-                } else {
-                  scopeLookup[scope["#Id" /* Id */] = ++lastScopeId] = scope;
-                  scope["$global" /* Global */] = $global;
-                  if (branchesEnabled) {
-                    scope["#ClosestBranch" /* ClosestBranch */] = getScope(
-                      scope["#ClosestBranchId" /* ClosestBranchId */]
-                    );
-                  }
-                }
-              }
-            }
-          }
-          for (visit of visits = render.v) {
-            lastTokenIndex = render.i.length;
-            visitText = visit.data;
-            visitType = visitText[lastTokenIndex++];
-            visitScope = getScope(nextToken(
-              /* read scope id */
-            ));
-            if (visitType === "*" /* Node */) {
-              const prev = visit.previousSibling;
-              visitScope[nextToken(
-                /* read accessor */
-              )] = prev && (prev.nodeType < 8 || prev.data) ? prev : visit.parentNode.insertBefore(new Text(), visit);
-            } else if (branchesEnabled) {
-              visitBranches();
-            }
-          }
-          if (embedEnabled) {
-            render.n ||= visit?.parentNode.insertBefore(
-              new Text(),
-              visit.nextSibling
-            );
-          }
-          visits.length = resumes.length = 0;
-          return effects;
-        };
-        render.w = () => {
-          walk2();
-          runResumeEffects(render);
-        };
-        return render;
-      })
-    });
-  };
-  if (renders) {
-    initRuntime(renders);
-    for (const renderId in renders) {
-      runResumeEffects(resumeRender(renderId));
-    }
-  } else {
-    defineRuntime({
-      configurable: true,
-      set: initRuntime
-    });
-  }
-}
-var isResuming;
+	embedEnabled = 1;
+	ready(readyId);
+	init(runtimeId);
+	new MutationObserver(() => {
+		const renders = self[curRuntimeId];
+		for (const renderId in renders) {
+			const { s, n } = renders[renderId];
+			if (n && !n.isConnected) {
+				delete renders[renderId];
+				for (const id in s) destroyScope(s[id]);
+			}
+		}
+	}).observe(document.body, {
+		childList: true,
+		subtree: true
+	});
+}
+function init(runtimeId = "M") {
+	if (curRuntimeId) {
+		if (curRuntimeId !== runtimeId) throw new Error(`Marko initialized multiple times with different $global.runtimeId's of ${JSON.stringify(runtimeId)} and ${JSON.stringify(curRuntimeId)}.`);
+		return;
+	}
+	curRuntimeId = runtimeId;
+	let resumeRender;
+	const renders = self[runtimeId];
+	const defineRuntime = (desc) => Object.defineProperty(self, runtimeId, desc);
+	const initRuntime = (renders) => {
+		defineRuntime({ value: resumeRender = ((renderId) => {
+			const render = resumeRender[renderId] = renders[renderId] || renders(renderId);
+			const walk = render.w;
+			const scopeLookup = render.s = {};
+			const getScope = (id) => scopeLookup[id] ||= { ["#Id"]: +id };
+			const serializeContext = { _: registeredValues };
+			const visitBranches = branchesEnabled && ((branchScopesStack = [], branchStarts = [], orphanBranches = [], curBranchScopes) => {
+				return (branchId, branch, endedBranches, accessor, singleNode, parent = visit.parentNode, startVisit = visit, i = orphanBranches.length) => {
+					if (visitType !== "[") {
+						visitScope[nextToken()] = visitType === ")" || visitType === "}" ? parent : visit;
+						accessor = "BranchScopes:" + lastToken;
+						singleNode = visitType !== "]" && visitType !== ")";
+						nextToken();
+					}
+					while (branchId = +lastToken) {
+						(endedBranches ||= []).push(branch = getScope(branchId));
+						setParentBranch(branch, branch["#ClosestBranch"]);
+						if (branch["#AwaitCounter"] = render.p?.[branchId]) branch["#AwaitCounter"].m = render.m;
+						if (singleNode) {
+							while (startVisit.previousSibling && ~visits.indexOf(startVisit = startVisit.previousSibling));
+							branch["#EndNode"] = branch["#StartNode"] = startVisit;
+							if (visitType === "'") branch[getDebugKey(0, startVisit)] = startVisit;
+						} else {
+							curBranchScopes = push(curBranchScopes, branch);
+							if (accessor) {
+								visitScope[accessor] = curBranchScopes;
+								curBranchScopes = branchScopesStack.pop();
+							}
+							startVisit = branchStarts.pop();
+							if (parent !== startVisit.parentNode) parent.prepend(startVisit);
+							branch["#StartNode"] = startVisit;
+							branch["#EndNode"] = visit.previousSibling === startVisit ? startVisit : parent.insertBefore(new Text(), visit);
+						}
+						while (i && orphanBranches[--i]["#Id"] > branchId) setParentBranch(orphanBranches.pop(), branch);
+						nextToken();
+					}
+					if (endedBranches) {
+						orphanBranches.push(...endedBranches);
+						if (singleNode) visitScope[accessor] = endedBranches.length > 1 ? endedBranches.reverse() : endedBranches[0];
+					}
+					if (visitType === "[") {
+						if (!endedBranches) {
+							branchScopesStack.push(curBranchScopes);
+							curBranchScopes = void 0;
+						}
+						branchStarts.push(visit);
+					}
+				};
+			})();
+			const nextToken = () => lastToken = visitText.slice(lastTokenIndex, (lastTokenIndex = visitText.indexOf(" ", lastTokenIndex) + 1 || visitText.length + 1) - 1);
+			let $global;
+			let lastEffect;
+			let visits;
+			let resumes;
+			let visit;
+			let visitText;
+			let visitType;
+			let visitScope;
+			let lastToken;
+			let lastTokenIndex;
+			let lastScopeId = 0;
+			if (render.m) throw new Error(`Marko rendered multiple times with $global.runtimeId as ${JSON.stringify(runtimeId)} and $global.renderId as ${JSON.stringify(renderId)}. Ensure each render into a page has a unique $global.renderId.`);
+			render.m = (effects = []) => {
+				if (readyLookup) {
+					for (const readyId in render.b) if (readyLookup[readyId] !== 1) {
+						readyLookup[readyId] = ((prev) => () => {
+							render.m();
+							prev?.();
+						})(readyLookup[readyId]);
+						return effects;
+					}
+					render.b = 0;
+				}
+				for (const serialized of resumes = render.r || []) if (typeof serialized === "string") {
+					lastTokenIndex = 0;
+					visitText = serialized;
+					while (nextToken()) if (/\D/.test(lastToken)) lastEffect = registeredValues[lastToken];
+					else effects.push(lastEffect, getScope(lastToken));
+				} else for (const scope of serialized(serializeContext)) if (!$global) {
+					$global = scope || {};
+					$global.runtimeId = runtimeId;
+					$global.renderId = renderId;
+				} else if (typeof scope === "number") lastScopeId += scope;
+				else {
+					scopeLookup[scope["#Id"] = ++lastScopeId] = scope;
+					scope["$global"] = $global;
+					if (branchesEnabled) scope["#ClosestBranch"] = getScope(scope["#ClosestBranchId"]);
+				}
+				for (visit of visits = render.v) {
+					lastTokenIndex = render.i.length;
+					visitText = visit.data;
+					visitType = visitText[lastTokenIndex++];
+					visitScope = getScope(nextToken());
+					if (visitType === "*") {
+						const prev = visit.previousSibling;
+						visitScope[nextToken()] = prev && (prev.nodeType < 8 || prev.data) ? prev : visit.parentNode.insertBefore(new Text(), visit);
+					} else if (branchesEnabled) visitBranches();
+				}
+				if (embedEnabled) render.n ||= visit?.parentNode.insertBefore(new Text(), visit.nextSibling);
+				visits.length = resumes.length = 0;
+				return effects;
+			};
+			render.w = () => {
+				walk();
+				runResumeEffects(render);
+			};
+			return render;
+		}) });
+	};
+	if (renders) {
+		initRuntime(renders);
+		for (const renderId in renders) runResumeEffects(resumeRender(renderId));
+	} else defineRuntime({
+		configurable: true,
+		set: initRuntime
+	});
+}
+let isResuming;
 function runResumeEffects(render) {
-  try {
-    isResuming = 1;
-    runEffects(render.m(), 1);
-  } finally {
-    isResuming = 0;
-  }
+	try {
+		isResuming = 1;
+		runEffects(render.m(), 1);
+	} finally {
+		isResuming = 0;
+	}
 }
 function getRegisteredWithScope(id, scope) {
-  const val = registeredValues[id];
-  return scope ? val(scope) : val;
+	const val = registeredValues[id];
+	return scope ? val(scope) : val;
 }
 function _resume(id, obj) {
-  return registeredValues[id] = obj;
+	return registeredValues[id] = obj;
 }
 function _var_resume(id, signal) {
-  _resume(id, (scope) => (value) => signal(scope, value));
-  return signal;
+	_resume(id, (scope) => (value) => signal(scope, value));
+	return signal;
 }
 function _el(id, accessor) {
-  if (true) {
-    return _resume(id, (scope) => () => _el_read(scope[accessor]));
-  } else {
-    accessor = decodeAccessor3(accessor);
-    return _resume(id, (scope) => () => scope[accessor]);
-  }
-}
-
-// src/dom/controllable.ts
-var inputType = "";
-var controllableDelegate = createDelegator();
+	return _resume(id, (scope) => () => _el_read(scope[accessor]));
+}
+//#endregion
+//#region src/dom/controllable.ts
+let inputType = "";
+const controllableDelegate = /* @__PURE__ */ createDelegator();
 function _attr_input_checked_default(scope, nodeAccessor, checked) {
-  const el = scope[nodeAccessor];
-  const normalizedChecked = normalizeBoolProp(checked);
-  if (el.defaultChecked !== normalizedChecked) {
-    const restoreValue = scope["#Creating" /* Creating */] ? normalizedChecked : el.checked;
-    el.defaultChecked = normalizedChecked;
-    if (restoreValue !== normalizedChecked) {
-      el.checked = restoreValue;
-    }
-  }
+	const el = scope[nodeAccessor];
+	const normalizedChecked = normalizeBoolProp(checked);
+	if (el.defaultChecked !== normalizedChecked) {
+		const restoreValue = scope["#Creating"] ? normalizedChecked : el.checked;
+		el.defaultChecked = normalizedChecked;
+		if (restoreValue !== normalizedChecked) el.checked = restoreValue;
+	}
 }
 function _attr_input_checked(scope, nodeAccessor, checked, checkedChange) {
-  const el = scope[nodeAccessor];
-  const normalizedChecked = normalizeBoolProp(checked);
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = checkedChange;
-  scope["ControlledType:" /* ControlledType */ + nodeAccessor] = checkedChange ? 0 /* InputChecked */ : 5 /* None */;
-  if (checkedChange && !scope["#Creating" /* Creating */]) {
-    el.checked = normalizedChecked;
-  } else {
-    _attr_input_checked_default(scope, nodeAccessor, normalizedChecked);
-  }
+	const el = scope[nodeAccessor];
+	const normalizedChecked = normalizeBoolProp(checked);
+	scope["ControlledHandler:" + nodeAccessor] = checkedChange;
+	scope["ControlledType:" + nodeAccessor] = checkedChange ? 0 : 5;
+	if (checkedChange && !scope["#Creating"]) el.checked = normalizedChecked;
+	else _attr_input_checked_default(scope, nodeAccessor, normalizedChecked);
 }
 function _attr_input_checked_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  syncControllableFormInput(el, hasCheckboxChanged, () => {
-    const checkedChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
-    if (checkedChange) {
-      const newValue = el.checked;
-      el.checked = !newValue;
-      checkedChange(newValue);
-      run();
-    }
-  });
+	const el = scope[nodeAccessor];
+	syncControllableFormInput(el, hasCheckboxChanged, () => {
+		const checkedChange = scope["ControlledHandler:" + nodeAccessor];
+		if (checkedChange) {
+			const newValue = el.checked;
+			el.checked = !newValue;
+			checkedChange(newValue);
+			run();
+		}
+	});
 }
 function _attr_input_checkedValue_default(scope, nodeAccessor, checkedValue, value) {
-  const multiple = Array.isArray(checkedValue);
-  const normalizedValue = normalizeStrProp(value);
-  const normalizedCheckedValue = multiple ? checkedValue.map(normalizeStrProp) : normalizeStrProp(checkedValue);
-  _attr(scope[nodeAccessor], "value", normalizedValue);
-  _attr_input_checked_default(
-    scope,
-    nodeAccessor,
-    multiple ? normalizedCheckedValue.includes(normalizedValue) : normalizedValue === normalizedCheckedValue
-  );
+	const multiple = Array.isArray(checkedValue);
+	const normalizedValue = normalizeStrProp(value);
+	const normalizedCheckedValue = multiple ? checkedValue.map(normalizeStrProp) : normalizeStrProp(checkedValue);
+	_attr(scope[nodeAccessor], "value", normalizedValue);
+	_attr_input_checked_default(scope, nodeAccessor, multiple ? normalizedCheckedValue.includes(normalizedValue) : normalizedValue === normalizedCheckedValue);
 }
 function _attr_input_checkedValue(scope, nodeAccessor, checkedValue, checkedValueChange, value) {
-  const el = scope[nodeAccessor];
-  const multiple = Array.isArray(checkedValue);
-  const normalizedValue = normalizeStrProp(value);
-  const normalizedCheckedValue = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = multiple ? checkedValue.map(normalizeStrProp) : normalizeStrProp(checkedValue);
-  _attr(el, "value", normalizedValue);
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = checkedValueChange;
-  scope["ControlledType:" /* ControlledType */ + nodeAccessor] = checkedValueChange ? 1 /* InputCheckedValue */ : 5 /* None */;
-  if (checkedValueChange && !scope["#Creating" /* Creating */]) {
-    el.checked = multiple ? normalizedCheckedValue.includes(normalizedValue) : normalizedValue === normalizedCheckedValue;
-  } else {
-    _attr_input_checkedValue_default(
-      scope,
-      nodeAccessor,
-      normalizedCheckedValue,
-      normalizedValue
-    );
-  }
+	const el = scope[nodeAccessor];
+	const multiple = Array.isArray(checkedValue);
+	const normalizedValue = normalizeStrProp(value);
+	const normalizedCheckedValue = scope["ControlledValue:" + nodeAccessor] = multiple ? checkedValue.map(normalizeStrProp) : normalizeStrProp(checkedValue);
+	_attr(el, "value", normalizedValue);
+	scope["ControlledHandler:" + nodeAccessor] = checkedValueChange;
+	scope["ControlledType:" + nodeAccessor] = checkedValueChange ? 1 : 5;
+	if (checkedValueChange && !scope["#Creating"]) el.checked = multiple ? normalizedCheckedValue.includes(normalizedValue) : normalizedValue === normalizedCheckedValue;
+	else _attr_input_checkedValue_default(scope, nodeAccessor, normalizedCheckedValue, normalizedValue);
 }
 function _attr_input_checkedValue_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  if (isResuming && el.defaultChecked) {
-    if (scope["ControlledValue:" /* ControlledValue */ + nodeAccessor]) {
-      scope["ControlledValue:" /* ControlledValue */ + nodeAccessor].push(
-        el.value
-      );
-    } else {
-      scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = el.value;
-    }
-  }
-  syncControllableFormInput(el, hasCheckboxChanged, () => {
-    const checkedValueChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
-    if (checkedValueChange) {
-      const oldValue = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
-      const newValue = Array.isArray(oldValue) ? updateList(oldValue, el.value, el.checked) : el.checked ? el.value : void 0;
-      if (el.name && el.type[0] === "r") {
-        for (const radio of el.getRootNode().querySelectorAll(
-          `[type=radio][name=${CSS.escape(el.name)}]`
-        )) {
-          if (radio.form === el.form) {
-            radio.checked = Array.isArray(oldValue) ? oldValue.includes(radio.value) : oldValue === radio.value;
-          }
-        }
-      } else {
-        el.checked = !el.checked;
-      }
-      checkedValueChange(newValue);
-      run();
-    }
-  });
+	const el = scope[nodeAccessor];
+	if (isResuming && el.defaultChecked) if (scope["ControlledValue:" + nodeAccessor]) scope["ControlledValue:" + nodeAccessor].push(el.value);
+	else scope["ControlledValue:" + nodeAccessor] = el.value;
+	syncControllableFormInput(el, hasCheckboxChanged, () => {
+		const checkedValueChange = scope["ControlledHandler:" + nodeAccessor];
+		if (checkedValueChange) {
+			const oldValue = scope["ControlledValue:" + nodeAccessor];
+			const newValue = Array.isArray(oldValue) ? updateList(oldValue, el.value, el.checked) : el.checked ? el.value : void 0;
+			if (el.name && el.type[0] === "r") {
+				for (const radio of el.getRootNode().querySelectorAll(`[type=radio][name=${CSS.escape(el.name)}]`)) if (radio.form === el.form) radio.checked = Array.isArray(oldValue) ? oldValue.includes(radio.value) : oldValue === radio.value;
+			} else el.checked = !el.checked;
+			checkedValueChange(newValue);
+			run();
+		}
+	});
 }
 function _attr_input_value_default(scope, nodeAccessor, value) {
-  const el = scope[nodeAccessor];
-  const normalizedValue = normalizeStrProp(value);
-  if (el.defaultValue !== normalizedValue) {
-    const restoreValue = scope["#Creating" /* Creating */] ? normalizedValue : el.value;
-    el.defaultValue = normalizedValue;
-    setInputValue(el, restoreValue);
-  }
+	const el = scope[nodeAccessor];
+	const normalizedValue = normalizeStrProp(value);
+	if (el.defaultValue !== normalizedValue) {
+		const restoreValue = scope["#Creating"] ? normalizedValue : el.value;
+		el.defaultValue = normalizedValue;
+		setInputValue(el, restoreValue);
+	}
 }
 function _attr_input_value(scope, nodeAccessor, value, valueChange) {
-  const el = scope[nodeAccessor];
-  const normalizedValue = normalizeStrProp(value);
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = valueChange;
-  scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = normalizedValue;
-  scope["ControlledType:" /* ControlledType */ + nodeAccessor] = valueChange ? 2 /* InputValue */ : 5 /* None */;
-  if (valueChange && !scope["#Creating" /* Creating */]) {
-    setInputValue(el, normalizedValue);
-  } else {
-    _attr_input_value_default(scope, nodeAccessor, normalizedValue);
-  }
+	const el = scope[nodeAccessor];
+	const normalizedValue = normalizeStrProp(value);
+	scope["ControlledHandler:" + nodeAccessor] = valueChange;
+	scope["ControlledValue:" + nodeAccessor] = normalizedValue;
+	scope["ControlledType:" + nodeAccessor] = valueChange ? 2 : 5;
+	if (valueChange && !scope["#Creating"]) setInputValue(el, normalizedValue);
+	else _attr_input_value_default(scope, nodeAccessor, normalizedValue);
 }
 function _attr_input_value_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  if (isResuming) {
-    scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = el.defaultValue;
-  }
-  syncControllableFormInput(el, hasValueChanged, (ev) => {
-    const valueChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
-    if (valueChange) {
-      inputType = ev?.inputType;
-      valueChange(el.value);
-      run();
-      setInputValue(el, scope["ControlledValue:" /* ControlledValue */ + nodeAccessor]);
-      inputType = "";
-    }
-  });
+	const el = scope[nodeAccessor];
+	if (isResuming) scope["ControlledValue:" + nodeAccessor] = el.defaultValue;
+	syncControllableFormInput(el, hasValueChanged, (ev) => {
+		const valueChange = scope["ControlledHandler:" + nodeAccessor];
+		if (valueChange) {
+			inputType = ev?.inputType;
+			valueChange(el.value);
+			run();
+			setInputValue(el, scope["ControlledValue:" + nodeAccessor]);
+			inputType = "";
+		}
+	});
 }
 function setInputValue(el, value) {
-  if (el.value !== value) {
-    const updatedPosition = resolveCursorPosition(
-      inputType,
-      el.getRootNode().activeElement === el && el.selectionStart,
-      el.value,
-      el.value = value
-    );
-    if (~updatedPosition) {
-      el.setSelectionRange(updatedPosition, updatedPosition);
-    }
-  }
+	if (el.value !== value) {
+		const updatedPosition = resolveCursorPosition(inputType, el.getRootNode().activeElement === el && el.selectionStart, el.value, el.value = value);
+		if (~updatedPosition) el.setSelectionRange(updatedPosition, updatedPosition);
+	}
 }
 function _attr_select_value_default(scope, nodeAccessor, value) {
-  let restoreValue;
-  const el = scope[nodeAccessor];
-  const existing = !scope["#Creating" /* Creating */];
-  const multiple = Array.isArray(value);
-  const normalizedValue = multiple ? value.map(normalizeStrProp) : normalizeStrProp(value);
-  pendingEffects.unshift(() => {
-    for (const opt of el.options) {
-      const selected = multiple ? normalizedValue.includes(opt.value) : opt.value === normalizedValue;
-      if (opt.defaultSelected !== selected) {
-        if (existing) {
-          restoreValue ??= getSelectValue(el, multiple);
-        }
-        opt.defaultSelected = selected;
-      }
-    }
-    if (restoreValue !== void 0) {
-      setSelectValue(el, restoreValue, multiple);
-    }
-  }, scope);
+	let restoreValue;
+	const el = scope[nodeAccessor];
+	const existing = !scope["#Creating"];
+	const multiple = Array.isArray(value);
+	const normalizedValue = multiple ? value.map(normalizeStrProp) : normalizeStrProp(value);
+	pendingEffects.unshift(() => {
+		for (const opt of el.options) {
+			const selected = multiple ? normalizedValue.includes(opt.value) : opt.value === normalizedValue;
+			if (opt.defaultSelected !== selected) {
+				if (existing) restoreValue ??= getSelectValue(el, multiple);
+				opt.defaultSelected = selected;
+			}
+		}
+		if (restoreValue !== void 0) setSelectValue(el, restoreValue, multiple);
+	}, scope);
 }
 function _attr_select_value(scope, nodeAccessor, value, valueChange) {
-  const el = scope[nodeAccessor];
-  const existing = !scope["#Creating" /* Creating */];
-  const multiple = Array.isArray(value);
-  const normalizedValue = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = multiple ? value.map(normalizeStrProp) : normalizeStrProp(value);
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = valueChange;
-  scope["ControlledType:" /* ControlledType */ + nodeAccessor] = valueChange ? 3 /* SelectValue */ : 5 /* None */;
-  if (valueChange && existing) {
-    pendingEffects.unshift(
-      () => setSelectValue(el, normalizedValue, multiple),
-      scope
-    );
-  } else {
-    _attr_select_value_default(scope, nodeAccessor, normalizedValue);
-  }
+	const el = scope[nodeAccessor];
+	const existing = !scope["#Creating"];
+	const multiple = Array.isArray(value);
+	const normalizedValue = scope["ControlledValue:" + nodeAccessor] = multiple ? value.map(normalizeStrProp) : normalizeStrProp(value);
+	scope["ControlledHandler:" + nodeAccessor] = valueChange;
+	scope["ControlledType:" + nodeAccessor] = valueChange ? 3 : 5;
+	if (valueChange && existing) pendingEffects.unshift(() => setSelectValue(el, normalizedValue, multiple), scope);
+	else _attr_select_value_default(scope, nodeAccessor, normalizedValue);
 }
 function _attr_select_value_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  const onChange = () => {
-    const valueChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
-    if (valueChange) {
-      const oldValue = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
-      const multiple = Array.isArray(oldValue);
-      const newValue = getSelectValue(el, multiple);
-      setSelectValue(el, oldValue, multiple);
-      valueChange(newValue);
-      run();
-    }
-  };
-  if (isResuming) {
-    if (el.multiple) {
-      scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = [];
-      for (const opt of el.options) {
-        if (opt.defaultSelected) {
-          scope["ControlledValue:" /* ControlledValue */ + nodeAccessor].push(opt.value);
-        }
-      }
-    } else {
-      scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = "";
-      for (const opt of el.options) {
-        if (opt.defaultSelected) {
-          scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = opt.value;
-          break;
-        }
-      }
-    }
-  }
-  syncControllableFormInput(el, hasSelectChanged, onChange);
-  new MutationObserver(() => {
-    const value = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
-    if (Array.isArray(value) ? value.length !== el.selectedOptions.length || value.some((value2, i) => value2 != el.selectedOptions[i].value) : el.value !== value) {
-      onChange();
-    }
-  }).observe(el, { childList: true, subtree: true });
+	const el = scope[nodeAccessor];
+	const onChange = () => {
+		const valueChange = scope["ControlledHandler:" + nodeAccessor];
+		if (valueChange) {
+			const oldValue = scope["ControlledValue:" + nodeAccessor];
+			const multiple = Array.isArray(oldValue);
+			const newValue = getSelectValue(el, multiple);
+			setSelectValue(el, oldValue, multiple);
+			valueChange(newValue);
+			run();
+		}
+	};
+	if (isResuming) if (el.multiple) {
+		scope["ControlledValue:" + nodeAccessor] = [];
+		for (const opt of el.options) if (opt.defaultSelected) scope["ControlledValue:" + nodeAccessor].push(opt.value);
+	} else {
+		scope["ControlledValue:" + nodeAccessor] = "";
+		for (const opt of el.options) if (opt.defaultSelected) {
+			scope["ControlledValue:" + nodeAccessor] = opt.value;
+			break;
+		}
+	}
+	syncControllableFormInput(el, hasSelectChanged, onChange);
+	new MutationObserver(() => {
+		const value = scope["ControlledValue:" + nodeAccessor];
+		if (Array.isArray(value) ? value.length !== el.selectedOptions.length || value.some((value, i) => value != el.selectedOptions[i].value) : el.value !== value) onChange();
+	}).observe(el, {
+		childList: true,
+		subtree: true
+	});
 }
 function setSelectValue(el, value, multiple) {
-  if (multiple) {
-    for (const opt of el.options) {
-      opt.selected = value.includes(opt.value);
-    }
-  } else {
-    el.value = value;
-  }
+	if (multiple) for (const opt of el.options) opt.selected = value.includes(opt.value);
+	else el.value = value;
 }
 function getSelectValue(el, multiple) {
-  return multiple ? Array.from(el.selectedOptions, (opt) => opt.value) : el.value;
+	return multiple ? Array.from(el.selectedOptions, (opt) => opt.value) : el.value;
 }
 function _attr_details_or_dialog_open_default(scope, nodeAccessor, open) {
-  if (scope["#Creating" /* Creating */]) {
-    scope[nodeAccessor].open = normalizeBoolProp(open);
-  }
+	if (scope["#Creating"]) scope[nodeAccessor].open = normalizeBoolProp(open);
 }
 function _attr_details_or_dialog_open(scope, nodeAccessor, open, openChange) {
-  const normalizedOpen = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = normalizeBoolProp(open);
-  scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = openChange;
-  scope["ControlledType:" /* ControlledType */ + nodeAccessor] = openChange ? 4 /* DetailsOrDialogOpen */ : 5 /* None */;
-  if (openChange && !scope["#Creating" /* Creating */]) {
-    scope[nodeAccessor].open = normalizedOpen;
-  } else {
-    _attr_details_or_dialog_open_default(scope, nodeAccessor, normalizedOpen);
-  }
+	const normalizedOpen = scope["ControlledValue:" + nodeAccessor] = normalizeBoolProp(open);
+	scope["ControlledHandler:" + nodeAccessor] = openChange;
+	scope["ControlledType:" + nodeAccessor] = openChange ? 4 : 5;
+	if (openChange && !scope["#Creating"]) scope[nodeAccessor].open = normalizedOpen;
+	else _attr_details_or_dialog_open_default(scope, nodeAccessor, normalizedOpen);
 }
 function _attr_details_or_dialog_open_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  new MutationObserver(() => {
-    const openChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
-    if (openChange && el.open === !scope["ControlledValue:" /* ControlledValue */ + nodeAccessor]) {
-      const newValue = el.open;
-      el.open = !newValue;
-      openChange(newValue);
-      run();
-    }
-  }).observe(el, { attributes: true, attributeFilter: ["open"] });
+	const el = scope[nodeAccessor];
+	new MutationObserver(() => {
+		const openChange = scope["ControlledHandler:" + nodeAccessor];
+		if (openChange && el.open === !scope["ControlledValue:" + nodeAccessor]) {
+			const newValue = el.open;
+			el.open = !newValue;
+			openChange(newValue);
+			run();
+		}
+	}).observe(el, {
+		attributes: true,
+		attributeFilter: ["open"]
+	});
 }
 function syncControllableFormInput(el, hasChanged, onChange) {
-  el._ = onChange;
-  controllableDelegate(el, "input", handleChange);
-  if (el.form) {
-    controllableDelegate(el.form, "reset", handleFormReset);
-  }
-  if (isResuming && hasChanged(el)) {
-    queueMicrotask(onChange);
-  }
+	el._ = onChange;
+	controllableDelegate(el, "input", handleChange);
+	if (el.form) controllableDelegate(el.form, "reset", handleFormReset);
+	if (isResuming && hasChanged(el)) queueMicrotask(onChange);
 }
 function handleChange(ev) {
-  ev.target._?.(ev);
+	ev.target._?.(ev);
 }
 function handleFormReset(ev) {
-  const handlers = [];
-  for (const el of ev.target.elements) {
-    if (el._ && hasFormElementChanged(el)) {
-      handlers.push(el._);
-    }
-  }
-  requestAnimationFrame(() => {
-    if (!ev.defaultPrevented) {
-      for (const change of handlers) {
-        change();
-      }
-    }
-  });
+	const handlers = [];
+	for (const el of ev.target.elements) if (el._ && hasFormElementChanged(el)) handlers.push(el._);
+	requestAnimationFrame(() => {
+		if (!ev.defaultPrevented) for (const change of handlers) change();
+	});
 }
 function hasValueChanged(el) {
-  return el.value !== el.defaultValue;
+	return el.value !== el.defaultValue;
 }
 function hasCheckboxChanged(el) {
-  return el.checked !== el.defaultChecked;
+	return el.checked !== el.defaultChecked;
 }
 function hasSelectChanged(el) {
-  for (const opt of el.options) {
-    if (opt.selected !== opt.defaultSelected) {
-      return true;
-    }
-  }
+	for (const opt of el.options) if (opt.selected !== opt.defaultSelected) return true;
 }
 function hasFormElementChanged(el) {
-  return el.options ? hasSelectChanged(el) : hasValueChanged(el) || hasCheckboxChanged(el);
+	return el.options ? hasSelectChanged(el) : hasValueChanged(el) || hasCheckboxChanged(el);
 }
 function normalizeStrProp(value) {
-  return normalizeAttrValue(value) || "";
+	return normalizeAttrValue(value) || "";
 }
 function normalizeBoolProp(value) {
-  return value != null && value !== false;
+	return value != null && value !== false;
 }
-function updateList(arr, val, push2) {
-  const index = arr.indexOf(val);
-  return (push2 ? !~index && [...arr, val] : ~index && arr.slice(0, index).concat(arr.slice(index + 1))) || arr;
+function updateList(arr, val, push) {
+	const index = arr.indexOf(val);
+	return (push ? !~index && [...arr, val] : ~index && arr.slice(0, index).concat(arr.slice(index + 1))) || arr;
 }
-
-// src/dom/dom.ts
+//#endregion
+//#region src/dom/dom.ts
 function _to_text(value) {
-  return value || value === 0 ? value + "" : "";
+	return value || value === 0 ? value + "" : "";
 }
 function _attr(element, name, value) {
-  setAttribute(element, name, normalizeAttrValue(value));
+	setAttribute(element, name, normalizeAttrValue(value));
 }
 function setAttribute(element, name, value) {
-  if (element.getAttribute(name) != value) {
-    if (value === void 0) {
-      element.removeAttribute(name);
-    } else {
-      element.setAttribute(name, value);
-    }
-  }
+	if (element.getAttribute(name) != value) if (value === void 0) element.removeAttribute(name);
+	else element.setAttribute(name, value);
 }
 function _attr_class(element, value) {
-  setAttribute(element, "class", classValue(value) || void 0);
+	setAttribute(element, "class", toDelimitedString(value, " ", stringifyClassObject) || void 0);
 }
 function _attr_class_items(element, items) {
-  for (const key in items) {
-    _attr_class_item(element, key, items[key]);
-  }
+	for (const key in items) _attr_class_item(element, key, items[key]);
 }
 function _attr_class_item(element, name, value) {
-  element.classList.toggle(name, !!value);
+	element.classList.toggle(name, !!value);
 }
 function _attr_style(element, value) {
-  setAttribute(element, "style", styleValue(value) || void 0);
+	setAttribute(element, "style", toDelimitedString(value, ";", stringifyStyleObject) || void 0);
 }
 function _attr_style_items(element, items) {
-  for (const key in items) {
-    _attr_style_item(element, key, items[key]);
-  }
+	for (const key in items) _attr_style_item(element, key, items[key]);
 }
 function _attr_style_item(element, name, value) {
-  element.style.setProperty(name, _to_text(value));
+	element.style.setProperty(name, _to_text(value));
 }
 function _attr_nonce(scope, nodeAccessor) {
-  _attr(scope[nodeAccessor], "nonce", scope["$global" /* Global */].cspNonce);
+	_attr(scope[nodeAccessor], "nonce", scope["$global"].cspNonce);
 }
 function _text(node, value) {
-  const normalizedValue = _to_text(value);
-  if (node.data !== normalizedValue) {
-    node.data = normalizedValue;
-  }
+	const normalizedValue = _to_text(value);
+	if (node.data !== normalizedValue) node.data = normalizedValue;
 }
 function _text_content(node, value) {
-  const normalizedValue = _to_text(value);
-  if (node.textContent !== normalizedValue) {
-    node.textContent = normalizedValue;
-  }
+	const normalizedValue = _to_text(value);
+	if (node.textContent !== normalizedValue) node.textContent = normalizedValue;
 }
 function _attrs(scope, nodeAccessor, nextAttrs) {
-  const el = scope[nodeAccessor];
-  for (let i = el.attributes.length; i--; ) {
-    const { name } = el.attributes.item(i);
-    if (!(nextAttrs && (name in nextAttrs || hasAttrAlias(el, name, nextAttrs)))) {
-      el.removeAttribute(name);
-    }
-  }
-  if (true) {
-    assertExclusiveAttrs(nextAttrs);
-  }
-  attrsInternal(scope, nodeAccessor, nextAttrs);
+	const el = scope[nodeAccessor];
+	for (let i = el.attributes.length; i--;) {
+		const { name } = el.attributes.item(i);
+		if (!(nextAttrs && (name in nextAttrs || hasAttrAlias(el, name, nextAttrs)))) el.removeAttribute(name);
+	}
+	assertExclusiveAttrs(nextAttrs);
+	attrsInternal(scope, nodeAccessor, nextAttrs);
 }
 function _attrs_content(scope, nodeAccessor, nextAttrs) {
-  _attrs(scope, nodeAccessor, nextAttrs);
-  _attr_content(scope, nodeAccessor, nextAttrs?.content);
+	_attrs(scope, nodeAccessor, nextAttrs);
+	_attr_content(scope, nodeAccessor, nextAttrs?.content);
 }
 function hasAttrAlias(element, attr, nextAttrs) {
-  return attr === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
+	return attr === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
 }
 function _attrs_partial(scope, nodeAccessor, nextAttrs, skip) {
-  const el = scope[nodeAccessor];
-  const partial = {};
-  for (let i = el.attributes.length; i--; ) {
-    const { name } = el.attributes.item(i);
-    if (!skip[name] && !(nextAttrs && name in nextAttrs)) {
-      el.removeAttribute(name);
-    }
-  }
-  for (const name in nextAttrs) {
-    const key = isEventHandler(name) ? `on-${getEventHandlerName(name)}` : name;
-    if (!skip[key]) partial[key] = nextAttrs[name];
-  }
-  if (true) {
-    assertExclusiveAttrs({ ...nextAttrs, ...skip });
-  }
-  attrsInternal(scope, nodeAccessor, partial);
+	const el = scope[nodeAccessor];
+	const partial = {};
+	for (let i = el.attributes.length; i--;) {
+		const { name } = el.attributes.item(i);
+		if (!skip[name] && !(nextAttrs && name in nextAttrs)) el.removeAttribute(name);
+	}
+	for (const name in nextAttrs) {
+		const key = isEventHandler(name) ? `on-${getEventHandlerName(name)}` : name;
+		if (!skip[key]) partial[key] = nextAttrs[name];
+	}
+	assertExclusiveAttrs({
+		...nextAttrs,
+		...skip
+	});
+	attrsInternal(scope, nodeAccessor, partial);
 }
 function _attrs_partial_content(scope, nodeAccessor, nextAttrs, skip) {
-  _attrs_partial(scope, nodeAccessor, nextAttrs, skip);
-  _attr_content(scope, nodeAccessor, nextAttrs?.content);
+	_attrs_partial(scope, nodeAccessor, nextAttrs, skip);
+	_attr_content(scope, nodeAccessor, nextAttrs?.content);
 }
 function attrsInternal(scope, nodeAccessor, nextAttrs) {
-  const el = scope[nodeAccessor];
-  let events;
-  let skip;
-  switch (el.tagName) {
-    case "INPUT":
-      if ("checked" in nextAttrs || "checkedChange" in nextAttrs) {
-        _attr_input_checked(
-          scope,
-          nodeAccessor,
-          nextAttrs.checked,
-          nextAttrs.checkedChange
-        );
-      } else if ("checkedValue" in nextAttrs || "checkedValueChange" in nextAttrs) {
-        _attr_input_checkedValue(
-          scope,
-          nodeAccessor,
-          nextAttrs.checkedValue,
-          nextAttrs.checkedValueChange,
-          nextAttrs.value
-        );
-      } else if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        _attr_input_value(
-          scope,
-          nodeAccessor,
-          nextAttrs.value,
-          nextAttrs.valueChange
-        );
-      } else {
-        break;
-      }
-      skip = /^(?:value|checked(?:Value)?)(?:Change)?$/;
-      break;
-    case "SELECT":
-      if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        _attr_select_value(
-          scope,
-          nodeAccessor,
-          nextAttrs.value,
-          nextAttrs.valueChange
-        );
-        skip = /^value(?:Change)?$/;
-      }
-      break;
-    case "TEXTAREA":
-      if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        _attr_input_value(
-          scope,
-          nodeAccessor,
-          nextAttrs.value,
-          nextAttrs.valueChange
-        );
-        skip = /^value(?:Change)?$/;
-      }
-      break;
-    case "DETAILS":
-    case "DIALOG":
-      if ("open" in nextAttrs || "openChange" in nextAttrs) {
-        _attr_details_or_dialog_open(
-          scope,
-          nodeAccessor,
-          nextAttrs.open,
-          nextAttrs.openChange
-        );
-        skip = /^open(?:Change)?$/;
-      }
-      break;
-  }
-  for (const name in nextAttrs) {
-    const value = nextAttrs[name];
-    switch (name) {
-      case "class":
-        _attr_class(el, value);
-        break;
-      case "style":
-        _attr_style(el, value);
-        break;
-      default: {
-        if (true) {
-          if (htmlAttrNameReg.test(name)) {
-            throw new Error(`Invalid attribute name: ${JSON.stringify(name)}`);
-          }
-        }
-        if (isEventHandler(name)) {
-          (events ||= scope["EventAttributes:" /* EventAttributes */ + nodeAccessor] = {})[getEventHandlerName(name)] = value;
-        } else if (!(skip?.test(name) || name === "content" && el.tagName !== "META")) {
-          _attr(el, name, value);
-        }
-        break;
-      }
-    }
-  }
+	const el = scope[nodeAccessor];
+	let events;
+	let skip;
+	switch (el.tagName) {
+		case "INPUT":
+			if ("checked" in nextAttrs || "checkedChange" in nextAttrs) _attr_input_checked(scope, nodeAccessor, nextAttrs.checked, nextAttrs.checkedChange);
+			else if ("checkedValue" in nextAttrs || "checkedValueChange" in nextAttrs) _attr_input_checkedValue(scope, nodeAccessor, nextAttrs.checkedValue, nextAttrs.checkedValueChange, nextAttrs.value);
+			else if ("value" in nextAttrs || "valueChange" in nextAttrs) _attr_input_value(scope, nodeAccessor, nextAttrs.value, nextAttrs.valueChange);
+			else break;
+			skip = /^(?:value|checked(?:Value)?)(?:Change)?$/;
+			break;
+		case "SELECT":
+			if ("value" in nextAttrs || "valueChange" in nextAttrs) {
+				_attr_select_value(scope, nodeAccessor, nextAttrs.value, nextAttrs.valueChange);
+				skip = /^value(?:Change)?$/;
+			}
+			break;
+		case "TEXTAREA":
+			if ("value" in nextAttrs || "valueChange" in nextAttrs) {
+				_attr_input_value(scope, nodeAccessor, nextAttrs.value, nextAttrs.valueChange);
+				skip = /^value(?:Change)?$/;
+			}
+			break;
+		case "DETAILS":
+		case "DIALOG":
+			if ("open" in nextAttrs || "openChange" in nextAttrs) {
+				_attr_details_or_dialog_open(scope, nodeAccessor, nextAttrs.open, nextAttrs.openChange);
+				skip = /^open(?:Change)?$/;
+			}
+			break;
+	}
+	for (const name in nextAttrs) {
+		const value = nextAttrs[name];
+		switch (name) {
+			case "class":
+				_attr_class(el, value);
+				break;
+			case "style":
+				_attr_style(el, value);
+				break;
+			default:
+				if (htmlAttrNameReg.test(name)) throw new Error(`Invalid attribute name: ${JSON.stringify(name)}`);
+				if (isEventHandler(name)) (events ||= scope["EventAttributes:" + nodeAccessor] = {})[getEventHandlerName(name)] = value;
+				else if (!(skip?.test(name) || name === "content" && el.tagName !== "META")) _attr(el, name, value);
+				break;
+		}
+	}
 }
 function _attr_content(scope, nodeAccessor, value) {
-  const content = normalizeClientRender(value);
-  if (scope["ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor] !== (scope["ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor] = content?.___id)) {
-    setConditionalRenderer(scope, nodeAccessor, content, createAndSetupBranch);
-    if (content?.___accessor) {
-      subscribeToScopeSet(
-        content.___owner,
-        content.___accessor,
-        scope["BranchScopes:" /* BranchScopes */ + nodeAccessor]
-      );
-    }
-  }
-  for (const accessor in content?.___localClosures) {
-    content.___localClosures[accessor](
-      scope["BranchScopes:" /* BranchScopes */ + nodeAccessor],
-      content.___localClosureValues[accessor]
-    );
-  }
+	const content = normalizeClientRender(value);
+	if (scope["ConditionalRenderer:" + nodeAccessor] !== (scope["ConditionalRenderer:" + nodeAccessor] = content?.["id"])) {
+		setConditionalRenderer(scope, nodeAccessor, content, createAndSetupBranch);
+		if (content?.["accessor"]) subscribeToScopeSet(content["owner"], content["accessor"], scope["BranchScopes:" + nodeAccessor]);
+	}
+	for (const accessor in content?.["localClosures"]) content["localClosures"][accessor](scope["BranchScopes:" + nodeAccessor], content["localClosureValues"][accessor]);
 }
 function _attrs_script(scope, nodeAccessor) {
-  const el = scope[nodeAccessor];
-  const events = scope["EventAttributes:" /* EventAttributes */ + nodeAccessor];
-  switch (scope["ControlledType:" /* ControlledType */ + nodeAccessor]) {
-    case 0 /* InputChecked */:
-      _attr_input_checked_script(scope, nodeAccessor);
-      break;
-    case 1 /* InputCheckedValue */:
-      _attr_input_checkedValue_script(scope, nodeAccessor);
-      break;
-    case 2 /* InputValue */:
-      _attr_input_value_script(scope, nodeAccessor);
-      break;
-    case 3 /* SelectValue */:
-      _attr_select_value_script(scope, nodeAccessor);
-      break;
-    case 4 /* DetailsOrDialogOpen */:
-      _attr_details_or_dialog_open_script(scope, nodeAccessor);
-      break;
-  }
-  for (const name in events) {
-    _on(el, name, events[name]);
-  }
+	const el = scope[nodeAccessor];
+	const events = scope["EventAttributes:" + nodeAccessor];
+	switch (scope["ControlledType:" + nodeAccessor]) {
+		case 0:
+			_attr_input_checked_script(scope, nodeAccessor);
+			break;
+		case 1:
+			_attr_input_checkedValue_script(scope, nodeAccessor);
+			break;
+		case 2:
+			_attr_input_value_script(scope, nodeAccessor);
+			break;
+		case 3:
+			_attr_select_value_script(scope, nodeAccessor);
+			break;
+		case 4:
+			_attr_details_or_dialog_open_script(scope, nodeAccessor);
+			break;
+	}
+	for (const name in events) _on(el, name, events[name]);
 }
 function _html(scope, value, accessor) {
-  const firstChild = scope[accessor];
-  const parentNode = firstChild.parentNode;
-  const lastChild = scope["DynamicHTMLLastChild:" /* DynamicHTMLLastChild */ + accessor] || firstChild;
-  const newContent = parseHTML(
-    _to_text(value),
-    parentNode.namespaceURI
-  );
-  insertChildNodes(
-    parentNode,
-    firstChild,
-    scope[accessor] = newContent.firstChild || newContent.appendChild(new Text()),
-    scope["DynamicHTMLLastChild:" /* DynamicHTMLLastChild */ + accessor] = newContent.lastChild
-  );
-  removeChildNodes(firstChild, lastChild);
+	const firstChild = scope[accessor];
+	const parentNode = firstChild.parentNode;
+	const lastChild = scope["DynamicHTMLLastChild:" + accessor] || firstChild;
+	const newContent = parseHTML(_to_text(value), parentNode.namespaceURI);
+	insertChildNodes(parentNode, firstChild, scope[accessor] = newContent.firstChild || newContent.appendChild(new Text()), scope["DynamicHTMLLastChild:" + accessor] = newContent.lastChild);
+	removeChildNodes(firstChild, lastChild);
 }
 function normalizeClientRender(value) {
-  const renderer = normalizeDynamicRenderer(value);
-  if (renderer) {
-    if (renderer.___id) {
-      return renderer;
-    } else if (true) {
-      throw new Error(
-        `Invalid \`content\` attribute. Received ${typeof value}`
-      );
-    }
-  }
+	const renderer = normalizeDynamicRenderer(value);
+	if (renderer) if (renderer["id"]) return renderer;
+	else throw new Error(`Invalid \`content\` attribute. Received ${typeof value}`);
 }
 function normalizeAttrValue(value) {
-  if (value || value === 0) {
-    return value === true ? "" : value + "";
-  }
+	if (value || value === 0) return value === true ? "" : value + "";
 }
 function _lifecycle(scope, thisObj, index = 0) {
-  const accessor = "Lifecycle:" /* Lifecycle */ + index;
-  const instance = scope[accessor];
-  if (instance) {
-    Object.assign(instance, thisObj);
-    instance.onUpdate?.();
-  } else {
-    scope[accessor] = thisObj;
-    thisObj.onMount?.();
-    $signal(scope, accessor).onabort = () => thisObj.onDestroy?.();
-  }
+	const accessor = "Lifecycle:" + index;
+	const instance = scope[accessor];
+	if (instance) {
+		Object.assign(instance, thisObj);
+		instance.onUpdate?.();
+	} else {
+		scope[accessor] = thisObj;
+		thisObj.onMount?.();
+		$signal(scope, accessor).onabort = () => thisObj.onDestroy?.();
+	}
 }
 function removeChildNodes(startNode, endNode) {
-  const stop = endNode.nextSibling;
-  let current = startNode;
-  while (current !== stop) {
-    const next = current.nextSibling;
-    current.remove();
-    current = next;
-  }
+	const stop = endNode.nextSibling;
+	let current = startNode;
+	while (current !== stop) {
+		const next = current.nextSibling;
+		current.remove();
+		current = next;
+	}
 }
 function insertChildNodes(parentNode, referenceNode, startNode, endNode) {
-  parentNode.insertBefore(toInsertNode(startNode, endNode), referenceNode);
+	parentNode.insertBefore(toInsertNode(startNode, endNode), referenceNode);
 }
 function toInsertNode(startNode, endNode) {
-  if (startNode === endNode) return startNode;
-  const parent = new DocumentFragment();
-  const stop = endNode.nextSibling;
-  let current = startNode;
-  while (current !== stop) {
-    const next = current.nextSibling;
-    parent.appendChild(current);
-    current = next;
-  }
-  return parent;
-}
-
-// src/dom/control-flow.ts
+	if (startNode === endNode) return startNode;
+	const parent = new DocumentFragment();
+	const stop = endNode.nextSibling;
+	let current = startNode;
+	while (current !== stop) {
+		const next = current.nextSibling;
+		parent.appendChild(current);
+		current = next;
+	}
+	return parent;
+}
+//#endregion
+//#region src/dom/control-flow.ts
 function _await_promise(nodeAccessor, params) {
-  if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
-  const promiseAccessor = "Promise:" /* Promise */ + nodeAccessor;
-  const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-  _enable_catch();
-  return (scope, promise) => {
-    let awaitBranch = scope[branchAccessor];
-    const tryBranch = findBranchWithKey(scope, "#PlaceholderContent" /* PlaceholderContent */) || awaitBranch;
-    let awaitCounter = tryBranch["#AwaitCounter" /* AwaitCounter */];
-    if (!awaitCounter?.i) {
-      awaitCounter = tryBranch["#AwaitCounter" /* AwaitCounter */] = {
-        i: 0,
-        c() {
-          if (--awaitCounter.i) return 1;
-          if (tryBranch === scope[branchAccessor]) {
-            if (scope[nodeAccessor].parentNode) {
-              scope[nodeAccessor].replaceWith(
-                scope[branchAccessor]["#StartNode" /* StartNode */].parentNode
-              );
-            }
-          } else {
-            const placeholderBranch = tryBranch["#PlaceholderBranch" /* PlaceholderBranch */];
-            if (placeholderBranch) {
-              tryBranch["#PlaceholderBranch" /* PlaceholderBranch */] = 0;
-              placeholderBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
-                tryBranch["#StartNode" /* StartNode */].parentNode,
-                placeholderBranch["#StartNode" /* StartNode */]
-              );
-              removeAndDestroyBranch(placeholderBranch);
-            }
-          }
-          queueEffect(tryBranch, (scope2) => {
-            const pendingEffects2 = scope2["#PendingEffects" /* PendingEffects */];
-            if (pendingEffects2) {
-              scope2["#PendingEffects" /* PendingEffects */] = [];
-              runEffects(pendingEffects2, 1);
-            }
-          });
-        }
-      };
-    }
-    placeholderShown.add(pendingEffects);
-    if (!scope[promiseAccessor]) {
-      if (awaitBranch) {
-        awaitBranch["#PendingRenders" /* PendingRenders */] ||= [];
-      }
-      if (!awaitCounter.i++) {
-        requestAnimationFrame(
-          () => awaitCounter.i && runEffects(
-            prepareEffects(
-              () => queueRender(
-                tryBranch === awaitBranch ? scope : tryBranch,
-                () => {
-                  if (tryBranch["#PlaceholderContent" /* PlaceholderContent */]) {
-                    insertBranchBefore(
-                      tryBranch["#PlaceholderBranch" /* PlaceholderBranch */] = createAndSetupBranch(
-                        scope["$global" /* Global */],
-                        tryBranch["#PlaceholderContent" /* PlaceholderContent */],
-                        tryBranch["_" /* Owner */],
-                        tryBranch["#StartNode" /* StartNode */].parentNode
-                      ),
-                      tryBranch["#StartNode" /* StartNode */].parentNode,
-                      tryBranch["#StartNode" /* StartNode */]
-                    );
-                    tempDetachBranch(tryBranch);
-                  } else if (!awaitBranch["#DetachedAwait" /* DetachedAwait */]) {
-                    awaitBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
-                      scope[nodeAccessor],
-                      awaitBranch["#StartNode" /* StartNode */]
-                    );
-                    tempDetachBranch(tryBranch);
-                  }
-                },
-                -1
-              )
-            )
-          )
-        );
-      }
-    }
-    const thisPromise = scope[promiseAccessor] = promise.then(
-      (data) => {
-        if (thisPromise === scope[promiseAccessor]) {
-          const referenceNode = scope[nodeAccessor];
-          scope[promiseAccessor] = 0;
-          queueMicrotask(run);
-          queueRender(
-            scope,
-            () => {
-              if ((awaitBranch = scope[branchAccessor])["#DetachedAwait" /* DetachedAwait */]) {
-                pendingScopes.push(awaitBranch);
-                setupBranch(
-                  awaitBranch["#DetachedAwait" /* DetachedAwait */],
-                  awaitBranch
-                );
-                awaitBranch["#DetachedAwait" /* DetachedAwait */] = 0;
-                insertBranchBefore(
-                  awaitBranch,
-                  scope[nodeAccessor].parentNode,
-                  scope[nodeAccessor]
-                );
-                referenceNode.remove();
-              }
-              params?.(awaitBranch, [data]);
-              const pendingRenders2 = awaitBranch["#PendingRenders" /* PendingRenders */];
-              awaitBranch["#PendingRenders" /* PendingRenders */] = 0;
-              pendingRenders2?.forEach(queuePendingRender);
-              placeholderShown.add(pendingEffects);
-              awaitCounter.c();
-              if (awaitCounter.m) {
-                const fnScopes = /* @__PURE__ */ new Map();
-                const effects = awaitCounter.m();
-                for (let i = 0; i < pendingEffects.length; ) {
-                  const fn = pendingEffects[i++];
-                  let scopes = fnScopes.get(fn);
-                  if (!scopes) {
-                    fnScopes.set(fn, scopes = /* @__PURE__ */ new Set());
-                  }
-                  scopes.add(pendingEffects[i++]);
-                }
-                for (let i = 0; i < effects.length; ) {
-                  const fn = effects[i++];
-                  const scope2 = effects[i++];
-                  if (!fnScopes.get(fn)?.has(scope2)) {
-                    queueEffect(scope2, fn);
-                  }
-                }
-              }
-            },
-            -1
-          );
-        }
-      },
-      (error) => {
-        if (thisPromise === scope[promiseAccessor]) {
-          awaitCounter.i = scope[promiseAccessor] = 0;
-          schedule();
-          queueRender(scope, renderCatch, -1, error);
-        }
-      }
-    );
-  };
+	const promiseAccessor = "Promise:" + nodeAccessor;
+	const branchAccessor = "BranchScopes:" + nodeAccessor;
+	_enable_catch();
+	return (scope, promise) => {
+		let awaitBranch = scope[branchAccessor];
+		const tryBranch = findBranchWithKey(scope, "#PlaceholderContent") || awaitBranch;
+		let awaitCounter = tryBranch["#AwaitCounter"];
+		if (!awaitCounter?.i) awaitCounter = tryBranch["#AwaitCounter"] = {
+			i: 0,
+			c() {
+				if (--awaitCounter.i) return 1;
+				if (tryBranch === scope[branchAccessor]) {
+					if (scope[nodeAccessor].parentNode) scope[nodeAccessor].replaceWith(scope[branchAccessor]["#StartNode"].parentNode);
+				} else {
+					const placeholderBranch = tryBranch["#PlaceholderBranch"];
+					if (placeholderBranch) {
+						tryBranch["#PlaceholderBranch"] = 0;
+						placeholderBranch["#StartNode"].parentNode.insertBefore(tryBranch["#StartNode"].parentNode, placeholderBranch["#StartNode"]);
+						removeAndDestroyBranch(placeholderBranch);
+					}
+				}
+				queueEffect(tryBranch, (scope) => {
+					const pendingEffects = scope["#PendingEffects"];
+					if (pendingEffects) {
+						scope["#PendingEffects"] = [];
+						runEffects(pendingEffects, 1);
+					}
+				});
+			}
+		};
+		placeholderShown.add(pendingEffects);
+		if (!scope[promiseAccessor]) {
+			if (awaitBranch) awaitBranch["#PendingRenders"] ||= [];
+			if (!awaitCounter.i++) requestAnimationFrame(() => awaitCounter.i && runEffects(prepareEffects(() => queueRender(tryBranch === awaitBranch ? scope : tryBranch, () => {
+				if (tryBranch["#PlaceholderContent"]) {
+					insertBranchBefore(tryBranch["#PlaceholderBranch"] = createAndSetupBranch(scope["$global"], tryBranch["#PlaceholderContent"], tryBranch["_"], tryBranch["#StartNode"].parentNode), tryBranch["#StartNode"].parentNode, tryBranch["#StartNode"]);
+					tempDetachBranch(tryBranch);
+				} else if (!awaitBranch["#DetachedAwait"]) {
+					awaitBranch["#StartNode"].parentNode.insertBefore(scope[nodeAccessor], awaitBranch["#StartNode"]);
+					tempDetachBranch(tryBranch);
+				}
+			}, -1))));
+		}
+		const thisPromise = scope[promiseAccessor] = promise.then((data) => {
+			if (thisPromise === scope[promiseAccessor]) {
+				const referenceNode = scope[nodeAccessor];
+				scope[promiseAccessor] = 0;
+				queueMicrotask(run);
+				queueRender(scope, () => {
+					if ((awaitBranch = scope[branchAccessor])["#DetachedAwait"]) {
+						pendingScopes.push(awaitBranch);
+						setupBranch(awaitBranch["#DetachedAwait"], awaitBranch);
+						awaitBranch["#DetachedAwait"] = 0;
+						insertBranchBefore(awaitBranch, scope[nodeAccessor].parentNode, scope[nodeAccessor]);
+						referenceNode.remove();
+					}
+					params?.(awaitBranch, [data]);
+					const pendingRenders = awaitBranch["#PendingRenders"];
+					awaitBranch["#PendingRenders"] = 0;
+					pendingRenders?.forEach(queuePendingRender);
+					placeholderShown.add(pendingEffects);
+					awaitCounter.c();
+					if (awaitCounter.m) {
+						const fnScopes = /* @__PURE__ */ new Map();
+						const effects = awaitCounter.m();
+						for (let i = 0; i < pendingEffects.length;) {
+							const fn = pendingEffects[i++];
+							let scopes = fnScopes.get(fn);
+							if (!scopes) fnScopes.set(fn, scopes = /* @__PURE__ */ new Set());
+							scopes.add(pendingEffects[i++]);
+						}
+						for (let i = 0; i < effects.length;) {
+							const fn = effects[i++];
+							const scope = effects[i++];
+							if (!fnScopes.get(fn)?.has(scope)) queueEffect(scope, fn);
+						}
+					}
+				}, -1);
+			}
+		}, (error) => {
+			if (thisPromise === scope[promiseAccessor]) {
+				awaitCounter.i = scope[promiseAccessor] = 0;
+				schedule();
+				queueRender(scope, renderCatch, -1, error);
+			}
+		});
+	};
 }
 function _await_content(nodeAccessor, template, walks, setup) {
-  if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
-  const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-  const renderer = _content("", template, walks, setup)();
-  return (scope) => {
-    (scope[branchAccessor] = createBranch(
-      scope["$global" /* Global */],
-      renderer,
-      scope,
-      scope[nodeAccessor].parentNode
-    ))["#DetachedAwait" /* DetachedAwait */] = renderer;
-    pendingScopes.pop();
-  };
+	const branchAccessor = "BranchScopes:" + nodeAccessor;
+	const renderer = _content("", template, walks, setup)();
+	return (scope) => {
+		(scope[branchAccessor] = createBranch(scope["$global"], renderer, scope, scope[nodeAccessor].parentNode))["#DetachedAwait"] = renderer;
+		pendingScopes.pop();
+	};
 }
 function _try(nodeAccessor, template, walks, setup) {
-  if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
-  const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-  const renderer = _content("", template, walks, setup)();
-  return (scope, input) => {
-    if (!scope[branchAccessor]) {
-      setConditionalRenderer(
-        scope,
-        nodeAccessor,
-        renderer,
-        createAndSetupBranch
-      );
-    }
-    const branch = scope[branchAccessor];
-    if (branch) {
-      branch["#BranchAccessor" /* BranchAccessor */] = nodeAccessor;
-      branch["#CatchContent" /* CatchContent */] = input.catch && (normalizeDynamicRenderer(input.catch) || 0);
-      branch["#PlaceholderContent" /* PlaceholderContent */] = normalizeDynamicRenderer(
-        input.placeholder
-      );
-    }
-  };
+	const branchAccessor = "BranchScopes:" + nodeAccessor;
+	const renderer = _content("", template, walks, setup)();
+	return (scope, input) => {
+		if (!scope[branchAccessor]) setConditionalRenderer(scope, nodeAccessor, renderer, createAndSetupBranch);
+		const branch = scope[branchAccessor];
+		if (branch) {
+			branch["#BranchAccessor"] = nodeAccessor;
+			branch["#CatchContent"] = input.catch && (normalizeDynamicRenderer(input.catch) || 0);
+			branch["#PlaceholderContent"] = normalizeDynamicRenderer(input.placeholder);
+		}
+	};
 }
 function renderCatch(scope, error) {
-  const tryWithCatch = findBranchWithKey(scope, "#CatchContent" /* CatchContent */);
-  if (!tryWithCatch) {
-    throw error;
-  } else {
-    const owner = tryWithCatch["_" /* Owner */];
-    const placeholderBranch = tryWithCatch["#PlaceholderBranch" /* PlaceholderBranch */];
-    if (placeholderBranch) {
-      if (tryWithCatch["#AwaitCounter" /* AwaitCounter */])
-        tryWithCatch["#AwaitCounter" /* AwaitCounter */].i = 0;
-      owner["BranchScopes:" /* BranchScopes */ + tryWithCatch["#BranchAccessor" /* BranchAccessor */]] = placeholderBranch;
-      destroyBranch(tryWithCatch);
-    }
-    caughtError.add(pendingEffects);
-    setConditionalRenderer(
-      owner,
-      tryWithCatch["#BranchAccessor" /* BranchAccessor */],
-      tryWithCatch["#CatchContent" /* CatchContent */],
-      createAndSetupBranch
-    );
-    tryWithCatch["#CatchContent" /* CatchContent */]?.___params?.(
-      owner["BranchScopes:" /* BranchScopes */ + tryWithCatch["#BranchAccessor" /* BranchAccessor */]],
-      [error]
-    );
-  }
+	const tryWithCatch = findBranchWithKey(scope, "#CatchContent");
+	if (!tryWithCatch) throw error;
+	else {
+		const owner = tryWithCatch["_"];
+		const placeholderBranch = tryWithCatch["#PlaceholderBranch"];
+		if (placeholderBranch) {
+			if (tryWithCatch["#AwaitCounter"]) tryWithCatch["#AwaitCounter"].i = 0;
+			owner["BranchScopes:" + tryWithCatch["#BranchAccessor"]] = placeholderBranch;
+			destroyBranch(tryWithCatch);
+		}
+		caughtError.add(pendingEffects);
+		setConditionalRenderer(owner, tryWithCatch["#BranchAccessor"], tryWithCatch["#CatchContent"], createAndSetupBranch);
+		tryWithCatch["#CatchContent"]?.["params"]?.(owner["BranchScopes:" + tryWithCatch["#BranchAccessor"]], [error]);
+	}
 }
 function _if(nodeAccessor, ...branchesArgs) {
-  if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
-  const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
-  const branches = [];
-  let i = 0;
-  while (i < branchesArgs.length) {
-    branches.push(
-      _content(
-        "",
-        branchesArgs[i++],
-        branchesArgs[i++],
-        branchesArgs[i++]
-      )()
-    );
-  }
-  enableBranches();
-  return (scope, newBranch) => {
-    if (newBranch !== scope[branchAccessor]) {
-      setConditionalRenderer(
-        scope,
-        nodeAccessor,
-        branches[scope[branchAccessor] = newBranch],
-        createAndSetupBranch
-      );
-    }
-  };
+	const branchAccessor = "ConditionalRenderer:" + nodeAccessor;
+	const branches = [];
+	let i = 0;
+	while (i < branchesArgs.length) branches.push(_content("", branchesArgs[i++], branchesArgs[i++], branchesArgs[i++])());
+	enableBranches();
+	return (scope, newBranch) => {
+		if (newBranch !== scope[branchAccessor]) setConditionalRenderer(scope, nodeAccessor, branches[scope[branchAccessor] = newBranch], createAndSetupBranch);
+	};
 }
 function patchDynamicTag(fn) {
-  _dynamic_tag = fn(_dynamic_tag);
-}
-var _dynamic_tag = function dynamicTag(nodeAccessor, getContent, getTagVar, inputIsArgs) {
-  if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
-  const childScopeAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-  const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
-  enableBranches();
-  return (scope, newRenderer, getInput) => {
-    const normalizedRenderer = normalizeDynamicRenderer(newRenderer);
-    if (scope[rendererAccessor] !== (scope[rendererAccessor] = normalizedRenderer?.___id || normalizedRenderer) || getContent && !(normalizedRenderer || scope[childScopeAccessor])) {
-      setConditionalRenderer(
-        scope,
-        nodeAccessor,
-        normalizedRenderer || (getContent ? getContent(scope) : void 0),
-        createBranchWithTagNameOrRenderer
-      );
-      if (getTagVar) {
-        scope[childScopeAccessor]["#TagVariable" /* TagVariable */] = (value) => getTagVar()(scope, value);
-      }
-      if (typeof normalizedRenderer === "string") {
-        if (getContent) {
-          const content = getContent(scope);
-          setConditionalRenderer(
-            scope[childScopeAccessor],
-            true ? `#${normalizedRenderer}/0` : "a",
-            content,
-            createAndSetupBranch
-          );
-          if (content.___accessor) {
-            subscribeToScopeSet(
-              content.___owner,
-              content.___accessor,
-              scope[childScopeAccessor]["BranchScopes:" /* BranchScopes */ + (true ? `#${normalizedRenderer}/0` : "a")]
-            );
-          }
-        }
-      } else if (normalizedRenderer?.___accessor) {
-        subscribeToScopeSet(
-          normalizedRenderer.___owner,
-          normalizedRenderer.___accessor,
-          scope[childScopeAccessor]
-        );
-      }
-    }
-    if (normalizedRenderer) {
-      const childScope = scope[childScopeAccessor];
-      const args = getInput?.();
-      if (typeof normalizedRenderer === "string") {
-        (getContent ? _attrs : _attrs_content)(
-          childScope,
-          true ? `#${normalizedRenderer}/0` : "a",
-          (inputIsArgs ? args[0] : args) || {}
-        );
-        if (childScope["EventAttributes:" /* EventAttributes */ + (true ? `#${normalizedRenderer}/0` : "a")] || childScope["ControlledHandler:" /* ControlledHandler */ + (true ? `#${normalizedRenderer}/0` : "a")]) {
-          queueEffect(childScope, dynamicTagScript);
-        }
-      } else {
-        for (const accessor in normalizedRenderer.___localClosures) {
-          normalizedRenderer.___localClosures[accessor](
-            childScope,
-            normalizedRenderer.___localClosureValues[accessor]
-          );
-        }
-        if (normalizedRenderer.___params) {
-          if (inputIsArgs) {
-            normalizedRenderer.___params(
-              childScope,
-              normalizedRenderer._ ? args[0] : args
-            );
-          } else {
-            const inputWithContent = getContent ? { ...args, content: getContent(scope) } : args || {};
-            normalizedRenderer.___params(
-              childScope,
-              normalizedRenderer._ ? inputWithContent : [inputWithContent]
-            );
-          }
-        }
-      }
-    }
-  };
+	_dynamic_tag = fn(_dynamic_tag);
+}
+let _dynamic_tag = function dynamicTag(nodeAccessor, getContent, getTagVar, inputIsArgs) {
+	const childScopeAccessor = "BranchScopes:" + nodeAccessor;
+	const rendererAccessor = "ConditionalRenderer:" + nodeAccessor;
+	enableBranches();
+	return (scope, newRenderer, getInput) => {
+		const normalizedRenderer = normalizeDynamicRenderer(newRenderer);
+		if (scope[rendererAccessor] !== (scope[rendererAccessor] = normalizedRenderer?.["id"] || normalizedRenderer) || getContent && !(normalizedRenderer || scope[childScopeAccessor])) {
+			setConditionalRenderer(scope, nodeAccessor, normalizedRenderer || (getContent ? getContent(scope) : void 0), createBranchWithTagNameOrRenderer);
+			if (getTagVar) scope[childScopeAccessor]["#TagVariable"] = (value) => getTagVar()(scope, value);
+			if (typeof normalizedRenderer === "string") {
+				if (getContent) {
+					const content = getContent(scope);
+					setConditionalRenderer(scope[childScopeAccessor], `#${normalizedRenderer}/0`, content, createAndSetupBranch);
+					if (content["accessor"]) subscribeToScopeSet(content["owner"], content["accessor"], scope[childScopeAccessor][`BranchScopes:#${normalizedRenderer}/0`]);
+				}
+			} else if (normalizedRenderer?.["accessor"]) subscribeToScopeSet(normalizedRenderer["owner"], normalizedRenderer["accessor"], scope[childScopeAccessor]);
+		}
+		if (normalizedRenderer) {
+			const childScope = scope[childScopeAccessor];
+			const args = getInput?.();
+			if (typeof normalizedRenderer === "string") {
+				(getContent ? _attrs : _attrs_content)(childScope, `#${normalizedRenderer}/0`, (inputIsArgs ? args[0] : args) || {});
+				if (childScope[`EventAttributes:#${normalizedRenderer}/0`] || childScope[`ControlledHandler:#${normalizedRenderer}/0`]) queueEffect(childScope, dynamicTagScript);
+			} else {
+				for (const accessor in normalizedRenderer["localClosures"]) normalizedRenderer["localClosures"][accessor](childScope, normalizedRenderer["localClosureValues"][accessor]);
+				if (normalizedRenderer["params"]) if (inputIsArgs) normalizedRenderer["params"](childScope, normalizedRenderer._ ? args[0] : args);
+				else {
+					const inputWithContent = getContent ? {
+						...args,
+						content: getContent(scope)
+					} : args || {};
+					normalizedRenderer["params"](childScope, normalizedRenderer._ ? inputWithContent : [inputWithContent]);
+				}
+			}
+		}
+	};
 };
 function _resume_dynamic_tag() {
-  _resume(DYNAMIC_TAG_SCRIPT_REGISTER_ID, dynamicTagScript);
+	_resume(DYNAMIC_TAG_SCRIPT_REGISTER_ID, dynamicTagScript);
 }
 function dynamicTagScript(branch) {
-  _attrs_script(
-    branch,
-    true ? `#${branch["#Renderer" /* Renderer */]}/0` : "a"
-  );
-}
-function setConditionalRenderer(scope, nodeAccessor, newRenderer, createBranch2) {
-  const referenceNode = scope[nodeAccessor];
-  const prevBranch = scope["BranchScopes:" /* BranchScopes */ + nodeAccessor];
-  const parentNode = referenceNode.nodeType > 1 /* Element */ ? (prevBranch?.["#StartNode" /* StartNode */] || referenceNode).parentNode : referenceNode;
-  const newBranch = scope["BranchScopes:" /* BranchScopes */ + nodeAccessor] = newRenderer && createBranch2(scope["$global" /* Global */], newRenderer, scope, parentNode);
-  if (referenceNode === parentNode) {
-    if (prevBranch) {
-      destroyBranch(prevBranch);
-      referenceNode.textContent = "";
-    }
-    if (newBranch) {
-      insertBranchBefore(newBranch, parentNode, null);
-    }
-  } else if (prevBranch) {
-    if (newBranch) {
-      insertBranchBefore(
-        newBranch,
-        parentNode,
-        prevBranch["#StartNode" /* StartNode */]
-      );
-    } else {
-      parentNode.insertBefore(
-        referenceNode,
-        prevBranch["#StartNode" /* StartNode */]
-      );
-    }
-    removeAndDestroyBranch(prevBranch);
-  } else if (newBranch) {
-    insertBranchBefore(newBranch, parentNode, referenceNode);
-    referenceNode.remove();
-  }
-}
-var _for_of = loop(([all, by = bySecondArg], cb) => {
-  if (typeof by === "string") {
-    forOf(
-      all,
-      (item, i) => cb(item[by], [item, i])
-    );
-  } else {
-    forOf(all, (item, i) => cb(by(item, i), [item, i]));
-  }
+	_attrs_script(branch, `#${branch["#Renderer"]}/0`);
+}
+function setConditionalRenderer(scope, nodeAccessor, newRenderer, createBranch) {
+	const referenceNode = scope[nodeAccessor];
+	const prevBranch = scope["BranchScopes:" + nodeAccessor];
+	const parentNode = referenceNode.nodeType > 1 ? (prevBranch?.["#StartNode"] || referenceNode).parentNode : referenceNode;
+	const newBranch = scope["BranchScopes:" + nodeAccessor] = newRenderer && createBranch(scope["$global"], newRenderer, scope, parentNode);
+	if (referenceNode === parentNode) {
+		if (prevBranch) {
+			destroyBranch(prevBranch);
+			referenceNode.textContent = "";
+		}
+		if (newBranch) insertBranchBefore(newBranch, parentNode, null);
+	} else if (prevBranch) {
+		if (newBranch) insertBranchBefore(newBranch, parentNode, prevBranch["#StartNode"]);
+		else parentNode.insertBefore(referenceNode, prevBranch["#StartNode"]);
+		removeAndDestroyBranch(prevBranch);
+	} else if (newBranch) {
+		insertBranchBefore(newBranch, parentNode, referenceNode);
+		referenceNode.remove();
+	}
+}
+const _for_of = /* @__PURE__ */ loop(([all, by = bySecondArg], cb) => {
+	if (typeof by === "string") forOf(all, (item, i) => cb(item[by], [item, i]));
+	else forOf(all, (item, i) => cb(by(item, i), [item, i]));
 });
-var _for_in = loop(
-  ([obj, by = byFirstArg], cb) => forIn(obj, (key, value) => cb(by(key, value), [key, value]))
-);
-var _for_to = loop(
-  ([to, from, step, by = byFirstArg], cb) => forTo(to, from, step, (v) => cb(by(v), [v]))
-);
-var _for_until = loop(
-  ([until, from, step, by = byFirstArg], cb) => forUntil(until, from, step, (v) => cb(by(v), [v]))
-);
+const _for_in = /* @__PURE__ */ loop(([obj, by = byFirstArg], cb) => forIn(obj, (key, value) => cb(by(key, value), [key, value])));
+const _for_to = /* @__PURE__ */ loop(([to, from, step, by = byFirstArg], cb) => forTo(to, from, step, (v) => cb(by(v), [v])));
+const _for_until = /* @__PURE__ */ loop(([until, from, step, by = byFirstArg], cb) => forUntil(until, from, step, (v) => cb(by(v), [v])));
+/* @__NO_SIDE_EFFECTS__ */
 function loop(forEach) {
-  return (nodeAccessor, template, walks, setup, params) => {
-    if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
-    const scopesAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-    const renderer = _content("", template, walks, setup)();
-    enableBranches();
-    return (scope, value) => {
-      const referenceNode = scope[nodeAccessor];
-      const oldScopes = toArray(scope[scopesAccessor]);
-      const newScopes = scope[scopesAccessor] = [];
-      const oldLen = oldScopes.length;
-      const parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.["#StartNode" /* StartNode */].parentNode : referenceNode;
-      let oldScopesByKey;
-      let hasPotentialMoves;
-      if (true) {
-        var seenKeys = /* @__PURE__ */ new Set();
-      }
-      forEach(value, (key, args) => {
-        if (true) {
-          if (seenKeys.has(key)) {
-            console.error(
-              `A <for> tag's \`by\` attribute must return a unique value for each item, but a duplicate was found matching:`,
-              key
-            );
-          } else {
-            seenKeys.add(key);
-          }
-        }
-        let branch = oldLen && (oldScopesByKey ||= oldScopes.reduce(
-          (map, scope2, i) => map.set(scope2["#LoopKey" /* LoopKey */] ?? i, scope2),
-          /* @__PURE__ */ new Map()
-        )).get(key);
-        if (branch) {
-          hasPotentialMoves = oldScopesByKey.delete(key);
-        } else {
-          branch = createAndSetupBranch(
-            scope["$global" /* Global */],
-            renderer,
-            scope,
-            parentNode
-          );
-        }
-        branch["#LoopKey" /* LoopKey */] = key;
-        newScopes.push(branch);
-        params?.(branch, args);
-      });
-      const newLen = newScopes.length;
-      const hasSiblings = referenceNode !== parentNode;
-      let afterReference = null;
-      let oldEnd = oldLen - 1;
-      let newEnd = newLen - 1;
-      let start = 0;
-      if (hasSiblings) {
-        if (oldLen) {
-          afterReference = oldScopes[oldEnd]["#EndNode" /* EndNode */].nextSibling;
-          if (!newLen) {
-            parentNode.insertBefore(referenceNode, afterReference);
-          }
-        } else if (newLen) {
-          afterReference = referenceNode.nextSibling;
-          referenceNode.remove();
-        }
-      }
-      if (!hasPotentialMoves) {
-        if (oldLen) {
-          oldScopes.forEach(
-            hasSiblings ? removeAndDestroyBranch : destroyBranch
-          );
-          if (!hasSiblings) {
-            parentNode.textContent = "";
-          }
-        }
-        for (const newScope of newScopes) {
-          insertBranchBefore(newScope, parentNode, afterReference);
-        }
-        return;
-      }
-      for (const branch of oldScopesByKey.values()) {
-        removeAndDestroyBranch(branch);
-      }
-      while (start < oldLen && start < newLen && oldScopes[start] === newScopes[start]) {
-        start++;
-      }
-      while (oldEnd >= start && newEnd >= start && oldScopes[oldEnd] === newScopes[newEnd]) {
-        oldEnd--;
-        newEnd--;
-      }
-      if (oldEnd + 1 < oldLen) {
-        afterReference = oldScopes[oldEnd + 1]["#StartNode" /* StartNode */];
-      }
-      if (start > oldEnd) {
-        if (start <= newEnd) {
-          for (let i = start; i <= newEnd; i++) {
-            insertBranchBefore(newScopes[i], parentNode, afterReference);
-          }
-        }
-        return;
-      } else if (start > newEnd) {
-        return;
-      }
-      const diffLen = newEnd - start + 1;
-      const oldPos = /* @__PURE__ */ new Map();
-      const sources = new Array(diffLen);
-      const pred = new Array(diffLen);
-      const tails = [];
-      let tail = -1;
-      let lo;
-      let hi;
-      let mid;
-      for (let i = start; i <= oldEnd; i++) {
-        oldPos.set(oldScopes[i], i);
-      }
-      for (let i = diffLen; i--; ) {
-        sources[i] = oldPos.get(newScopes[start + i]) ?? -1;
-      }
-      for (let i = 0; i < diffLen; i++) {
-        if (~sources[i]) {
-          if (tail < 0 || sources[tails[tail]] < sources[i]) {
-            if (~tail) pred[i] = tails[tail];
-            tails[++tail] = i;
-          } else {
-            lo = 0;
-            hi = tail;
-            while (lo < hi) {
-              mid = (lo + hi) / 2 | 0;
-              if (sources[tails[mid]] < sources[i]) lo = mid + 1;
-              else hi = mid;
-            }
-            if (sources[i] < sources[tails[lo]]) {
-              if (lo > 0) pred[i] = tails[lo - 1];
-              tails[lo] = i;
-            }
-          }
-        }
-      }
-      hi = tails[tail];
-      lo = tail + 1;
-      while (lo-- > 0) {
-        tails[lo] = hi;
-        hi = pred[hi];
-      }
-      for (let i = diffLen; i--; ) {
-        if (~tail && i === tails[tail]) {
-          tail--;
-        } else {
-          insertBranchBefore(newScopes[start + i], parentNode, afterReference);
-        }
-        afterReference = newScopes[start + i]["#StartNode" /* StartNode */];
-      }
-    };
-  };
+	return (nodeAccessor, template, walks, setup, params) => {
+		const scopesAccessor = "BranchScopes:" + nodeAccessor;
+		const renderer = _content("", template, walks, setup)();
+		enableBranches();
+		return (scope, value) => {
+			const referenceNode = scope[nodeAccessor];
+			const oldScopes = toArray(scope[scopesAccessor]);
+			const newScopes = scope[scopesAccessor] = [];
+			const oldLen = oldScopes.length;
+			const parentNode = referenceNode.nodeType > 1 ? referenceNode.parentNode || oldScopes[0]?.["#StartNode"].parentNode : referenceNode;
+			let oldScopesByKey;
+			let hasPotentialMoves;
+			var seenKeys = /* @__PURE__ */ new Set();
+			forEach(value, (key, args) => {
+				if (seenKeys.has(key)) console.error(`A <for> tag's \`by\` attribute must return a unique value for each item, but a duplicate was found matching:`, key);
+				else seenKeys.add(key);
+				let branch = oldLen && (oldScopesByKey ||= oldScopes.reduce((map, scope, i) => map.set(scope["#LoopKey"] ?? i, scope), /* @__PURE__ */ new Map())).get(key);
+				if (branch) hasPotentialMoves = oldScopesByKey.delete(key);
+				else branch = createAndSetupBranch(scope["$global"], renderer, scope, parentNode);
+				branch["#LoopKey"] = key;
+				newScopes.push(branch);
+				params?.(branch, args);
+			});
+			const newLen = newScopes.length;
+			const hasSiblings = referenceNode !== parentNode;
+			let afterReference = null;
+			let oldEnd = oldLen - 1;
+			let newEnd = newLen - 1;
+			let start = 0;
+			if (hasSiblings) {
+				if (oldLen) {
+					afterReference = oldScopes[oldEnd]["#EndNode"].nextSibling;
+					if (!newLen) parentNode.insertBefore(referenceNode, afterReference);
+				} else if (newLen) {
+					afterReference = referenceNode.nextSibling;
+					referenceNode.remove();
+				}
+			}
+			if (!hasPotentialMoves) {
+				if (oldLen) {
+					oldScopes.forEach(hasSiblings ? removeAndDestroyBranch : destroyBranch);
+					if (!hasSiblings) parentNode.textContent = "";
+				}
+				for (const newScope of newScopes) insertBranchBefore(newScope, parentNode, afterReference);
+				return;
+			}
+			for (const branch of oldScopesByKey.values()) removeAndDestroyBranch(branch);
+			while (start < oldLen && start < newLen && oldScopes[start] === newScopes[start]) start++;
+			while (oldEnd >= start && newEnd >= start && oldScopes[oldEnd] === newScopes[newEnd]) {
+				oldEnd--;
+				newEnd--;
+			}
+			if (oldEnd + 1 < oldLen) afterReference = oldScopes[oldEnd + 1]["#StartNode"];
+			if (start > oldEnd) {
+				if (start <= newEnd) for (let i = start; i <= newEnd; i++) insertBranchBefore(newScopes[i], parentNode, afterReference);
+				return;
+			} else if (start > newEnd) return;
+			const diffLen = newEnd - start + 1;
+			const oldPos = /* @__PURE__ */ new Map();
+			const sources = new Array(diffLen);
+			const pred = new Array(diffLen);
+			const tails = [];
+			let tail = -1;
+			let lo;
+			let hi;
+			let mid;
+			for (let i = start; i <= oldEnd; i++) oldPos.set(oldScopes[i], i);
+			for (let i = diffLen; i--;) sources[i] = oldPos.get(newScopes[start + i]) ?? -1;
+			for (let i = 0; i < diffLen; i++) if (~sources[i]) if (tail < 0 || sources[tails[tail]] < sources[i]) {
+				if (~tail) pred[i] = tails[tail];
+				tails[++tail] = i;
+			} else {
+				lo = 0;
+				hi = tail;
+				while (lo < hi) {
+					mid = (lo + hi) / 2 | 0;
+					if (sources[tails[mid]] < sources[i]) lo = mid + 1;
+					else hi = mid;
+				}
+				if (sources[i] < sources[tails[lo]]) {
+					if (lo > 0) pred[i] = tails[lo - 1];
+					tails[lo] = i;
+				}
+			}
+			hi = tails[tail];
+			lo = tail + 1;
+			while (lo-- > 0) {
+				tails[lo] = hi;
+				hi = pred[hi];
+			}
+			for (let i = diffLen; i--;) {
+				if (~tail && i === tails[tail]) tail--;
+				else insertBranchBefore(newScopes[start + i], parentNode, afterReference);
+				afterReference = newScopes[start + i]["#StartNode"];
+			}
+		};
+	};
 }
 function createBranchWithTagNameOrRenderer($global, tagNameOrRenderer, parentScope, parentNode) {
-  if (typeof tagNameOrRenderer === "string") {
-    assertValidTagName(tagNameOrRenderer);
-  }
-  const branch = createBranch(
-    $global,
-    tagNameOrRenderer,
-    parentScope,
-    parentNode
-  );
-  if (typeof tagNameOrRenderer === "string") {
-    branch[true ? `#${tagNameOrRenderer}/0` : "a"] = branch["#StartNode" /* StartNode */] = branch["#EndNode" /* EndNode */] = document.createElementNS(
-      tagNameOrRenderer === "svg" ? "http://www.w3.org/2000/svg" : tagNameOrRenderer === "math" ? "http://www.w3.org/1998/Math/MathML" : parentNode.namespaceURI,
-      tagNameOrRenderer
-    );
-  } else {
-    setupBranch(tagNameOrRenderer, branch);
-  }
-  return branch;
+	if (typeof tagNameOrRenderer === "string") assertValidTagName(tagNameOrRenderer);
+	const branch = createBranch($global, tagNameOrRenderer, parentScope, parentNode);
+	if (typeof tagNameOrRenderer === "string") branch[`#${tagNameOrRenderer}/0`] = branch["#StartNode"] = branch["#EndNode"] = document.createElementNS(tagNameOrRenderer === "svg" ? "http://www.w3.org/2000/svg" : tagNameOrRenderer === "math" ? "http://www.w3.org/1998/Math/MathML" : parentNode.namespaceURI, tagNameOrRenderer);
+	else setupBranch(tagNameOrRenderer, branch);
+	return branch;
 }
 function bySecondArg(_item, index) {
-  return index;
+	return index;
 }
 function byFirstArg(name) {
-  return name;
-}
-
-// src/dom/queue.ts
-var pendingRenders = [];
-var pendingRendersLookup = /* @__PURE__ */ new Map();
-var asyncRendersLookup;
-var caughtError = /* @__PURE__ */ new WeakSet();
-var placeholderShown = /* @__PURE__ */ new WeakSet();
-var pendingEffects = [];
-var pendingScopes = [];
-var rendering;
-var scopeKeyOffset = 1e3;
-function queueRender(scope, signal, signalKey, value, scopeKey = scope["#Id" /* Id */]) {
-  const key = scopeKey * scopeKeyOffset + signalKey;
-  let render = signalKey >= 0 && pendingRendersLookup.get(key);
-  if (render) {
-    render.___value = value;
-  } else {
-    queuePendingRender(
-      render = {
-        ___key: key,
-        ___scope: scope,
-        ___signal: signal,
-        ___value: value
-      }
-    );
-    signalKey >= 0 && pendingRendersLookup.set(key, render);
-  }
+	return name;
+}
+//#endregion
+//#region src/dom/queue.ts
+let pendingRenders = [];
+let pendingRendersLookup = /* @__PURE__ */ new Map();
+let asyncRendersLookup;
+const caughtError = /* @__PURE__ */ new WeakSet();
+const placeholderShown = /* @__PURE__ */ new WeakSet();
+let pendingEffects = [];
+let pendingScopes = [];
+let rendering;
+const scopeKeyOffset = 1e3;
+function queueRender(scope, signal, signalKey, value, scopeKey = scope["#Id"]) {
+	const key = scopeKey * scopeKeyOffset + signalKey;
+	let render = signalKey >= 0 && pendingRendersLookup.get(key);
+	if (render) render["value"] = value;
+	else {
+		queuePendingRender(render = {
+			["key"]: key,
+			["scope"]: scope,
+			["signal"]: signal,
+			["value"]: value
+		});
+		signalKey >= 0 && pendingRendersLookup.set(key, render);
+	}
 }
 function queuePendingRender(render) {
-  let i = pendingRenders.push(render) - 1;
-  while (i) {
-    const parentIndex = i - 1 >> 1;
-    const parent = pendingRenders[parentIndex];
-    if (render.___key - parent.___key >= 0) break;
-    pendingRenders[i] = parent;
-    i = parentIndex;
-  }
-  pendingRenders[i] = render;
+	let i = pendingRenders.push(render) - 1;
+	while (i) {
+		const parentIndex = i - 1 >> 1;
+		const parent = pendingRenders[parentIndex];
+		if (render["key"] - parent["key"] >= 0) break;
+		pendingRenders[i] = parent;
+		i = parentIndex;
+	}
+	pendingRenders[i] = render;
 }
 function queueEffect(scope, fn) {
-  pendingEffects.push(fn, scope);
+	pendingEffects.push(fn, scope);
 }
 function run() {
-  const effects = pendingEffects;
-  asyncRendersLookup = /* @__PURE__ */ new Map();
-  try {
-    rendering = 1;
-    runRenders();
-  } finally {
-    pendingRendersLookup = asyncRendersLookup;
-    asyncRendersLookup = rendering = 0;
-    pendingRenders = [];
-    pendingEffects = [];
-  }
-  runEffects(effects);
+	const effects = pendingEffects;
+	asyncRendersLookup = /* @__PURE__ */ new Map();
+	try {
+		rendering = 1;
+		runRenders();
+	} finally {
+		pendingRendersLookup = asyncRendersLookup;
+		asyncRendersLookup = rendering = 0;
+		pendingRenders = [];
+		pendingEffects = [];
+	}
+	runEffects(effects);
 }
 function prepareEffects(fn) {
-  const prevRenders = pendingRenders;
-  const prevEffects = pendingEffects;
-  const prevLookup = asyncRendersLookup;
-  const preparedEffects = pendingEffects = [];
-  pendingRenders = [];
-  asyncRendersLookup = pendingRendersLookup;
-  pendingRendersLookup = /* @__PURE__ */ new Map();
-  try {
-    rendering = 1;
-    fn();
-    runRenders();
-  } finally {
-    rendering = 0;
-    pendingRendersLookup = asyncRendersLookup;
-    asyncRendersLookup = prevLookup;
-    pendingRenders = prevRenders;
-    pendingEffects = prevEffects;
-  }
-  return preparedEffects;
-}
-var runEffects = ((effects) => {
-  for (let i = 0; i < effects.length; ) {
-    effects[i++](effects[i++]);
-  }
+	const prevRenders = pendingRenders;
+	const prevEffects = pendingEffects;
+	const prevLookup = asyncRendersLookup;
+	const preparedEffects = pendingEffects = [];
+	pendingRenders = [];
+	asyncRendersLookup = pendingRendersLookup;
+	pendingRendersLookup = /* @__PURE__ */ new Map();
+	try {
+		rendering = 1;
+		fn();
+		runRenders();
+	} finally {
+		rendering = 0;
+		pendingRendersLookup = asyncRendersLookup;
+		asyncRendersLookup = prevLookup;
+		pendingRenders = prevRenders;
+		pendingEffects = prevEffects;
+	}
+	return preparedEffects;
+}
+let runEffects = ((effects) => {
+	for (let i = 0; i < effects.length;) effects[i++](effects[i++]);
 });
 function runRenders() {
-  while (pendingRenders.length) {
-    const render = pendingRenders[0];
-    const item = pendingRenders.pop();
-    if (render !== item) {
-      let i = 0;
-      const mid = pendingRenders.length >> 1;
-      const key = (pendingRenders[0] = item).___key;
-      while (i < mid) {
-        let bestChild = (i << 1) + 1;
-        const right = bestChild + 1;
-        if (right < pendingRenders.length && pendingRenders[right].___key - pendingRenders[bestChild].___key < 0) {
-          bestChild = right;
-        }
-        if (pendingRenders[bestChild].___key - key >= 0) {
-          break;
-        } else {
-          pendingRenders[i] = pendingRenders[bestChild];
-          i = bestChild;
-        }
-      }
-      pendingRenders[i] = item;
-    }
-    if (!render.___scope["#ClosestBranch" /* ClosestBranch */]?.["#Destroyed" /* Destroyed */]) {
-      runRender(render);
-    }
-  }
-  for (const scope of pendingScopes) {
-    scope["#Creating" /* Creating */] = 0;
-  }
-  pendingScopes = [];
-}
-var runRender = (render) => render.___signal(render.___scope, render.___value);
-var _enable_catch = () => {
-  _enable_catch = () => {
-  };
-  enableBranches();
-  const handlePendingTry = (fn, scope, branch) => {
-    while (branch) {
-      if (branch["#AwaitCounter" /* AwaitCounter */]?.i) {
-        return (branch["#PendingEffects" /* PendingEffects */] ||= []).push(fn, scope);
-      }
-      branch = branch["#ParentBranch" /* ParentBranch */];
-    }
-  };
-  runEffects = /* @__PURE__ */ ((runEffects2) => (effects, checkPending = placeholderShown.has(effects)) => {
-    if (checkPending || caughtError.has(effects)) {
-      let i = 0;
-      let fn;
-      let scope;
-      let branch;
-      for (; i < effects.length; ) {
-        fn = effects[i++];
-        scope = effects[i++];
-        branch = scope["#ClosestBranch" /* ClosestBranch */];
-        if (!branch?.["#Destroyed" /* Destroyed */] && !(checkPending && handlePendingTry(fn, scope, branch))) {
-          fn(scope);
-        }
-      }
-    } else {
-      runEffects2(effects);
-    }
-  })(runEffects);
-  runRender = /* @__PURE__ */ ((runRender2) => (render) => {
-    try {
-      let branch = render.___scope["#ClosestBranch" /* ClosestBranch */];
-      while (branch) {
-        if (branch["#PendingRenders" /* PendingRenders */]) {
-          asyncRendersLookup.set(
-            render.___key,
-            render
-          );
-          return branch["#PendingRenders" /* PendingRenders */].push(render);
-        }
-        branch = branch["#ParentBranch" /* ParentBranch */];
-      }
-      runRender2(render);
-    } catch (error) {
-      renderCatch(render.___scope, error);
-    }
-  })(runRender);
-};
-
-// src/dom/abort-signal.ts
+	while (pendingRenders.length) {
+		const render = pendingRenders[0];
+		const item = pendingRenders.pop();
+		if (render !== item) {
+			let i = 0;
+			const mid = pendingRenders.length >> 1;
+			const key = (pendingRenders[0] = item)["key"];
+			while (i < mid) {
+				let bestChild = (i << 1) + 1;
+				const right = bestChild + 1;
+				if (right < pendingRenders.length && pendingRenders[right]["key"] - pendingRenders[bestChild]["key"] < 0) bestChild = right;
+				if (pendingRenders[bestChild]["key"] - key >= 0) break;
+				else {
+					pendingRenders[i] = pendingRenders[bestChild];
+					i = bestChild;
+				}
+			}
+			pendingRenders[i] = item;
+		}
+		if (!render["scope"]["#ClosestBranch"]?.["#Destroyed"]) runRender(render);
+	}
+	for (const scope of pendingScopes) scope["#Creating"] = 0;
+	pendingScopes = [];
+}
+let runRender = (render) => render["signal"](render["scope"], render["value"]);
+let catchEnabled;
+function _enable_catch() {
+	if (!catchEnabled) {
+		catchEnabled = 1;
+		enableBranches();
+		const handlePendingTry = (fn, scope, branch) => {
+			while (branch) {
+				if (branch["#AwaitCounter"]?.i) return (branch["#PendingEffects"] ||= []).push(fn, scope);
+				branch = branch["#ParentBranch"];
+			}
+		};
+		runEffects = ((runEffects) => (effects, checkPending = placeholderShown.has(effects)) => {
+			if (checkPending || caughtError.has(effects)) {
+				let i = 0;
+				let fn;
+				let scope;
+				let branch;
+				for (; i < effects.length;) {
+					fn = effects[i++];
+					scope = effects[i++];
+					branch = scope["#ClosestBranch"];
+					if (!branch?.["#Destroyed"] && !(checkPending && handlePendingTry(fn, scope, branch))) fn(scope);
+				}
+			} else runEffects(effects);
+		})(runEffects);
+		runRender = ((runRender) => (render) => {
+			try {
+				let branch = render["scope"]["#ClosestBranch"];
+				while (branch) {
+					if (branch["#PendingRenders"]) {
+						asyncRendersLookup.set(render["key"], render);
+						return branch["#PendingRenders"].push(render);
+					}
+					branch = branch["#ParentBranch"];
+				}
+				runRender(render);
+			} catch (error) {
+				renderCatch(render["scope"], error);
+			}
+		})(runRender);
+	}
+}
+//#endregion
+//#region src/dom/abort-signal.ts
 function $signalReset(scope, id) {
-  const ctrl = scope["#AbortControllers" /* AbortControllers */]?.[id];
-  if (ctrl) {
-    queueEffect(ctrl, abort);
-    scope["#AbortControllers" /* AbortControllers */][id] = void 0;
-  }
+	const ctrl = scope["#AbortControllers"]?.[id];
+	if (ctrl) {
+		queueEffect(ctrl, abort);
+		scope["#AbortControllers"][id] = void 0;
+	}
 }
 function $signal(scope, id) {
-  if (scope["#ClosestBranch" /* ClosestBranch */]) {
-    (scope["#ClosestBranch" /* ClosestBranch */]["#AbortScopes" /* AbortScopes */] ||= /* @__PURE__ */ new Set()).add(scope);
-  }
-  return ((scope["#AbortControllers" /* AbortControllers */] ||= {})[id] ||= new AbortController()).signal;
+	if (scope["#ClosestBranch"]) (scope["#ClosestBranch"]["#AbortScopes"] ||= /* @__PURE__ */ new Set()).add(scope);
+	return ((scope["#AbortControllers"] ||= {})[id] ||= new AbortController()).signal;
 }
 function abort(ctrl) {
-  ctrl.abort();
-}
-
-// src/common/compat-meta.ts
-var prefix = true ? "$compat_" : "$C_";
-var RENDERER_REGISTER_ID = prefix + (true ? "renderer" : "r");
-var SET_SCOPE_REGISTER_ID = prefix + (true ? "setScope" : "s");
-var RENDER_BODY_ID = prefix + (true ? "renderBody" : "b");
-
-// src/dom/compat.ts
-var classIdToBranch = /* @__PURE__ */ new Map();
-var compat = {
-  patchDynamicTag,
-  queueEffect,
-  init(warp10Noop) {
-    _resume(SET_SCOPE_REGISTER_ID, (branch) => {
-      classIdToBranch.set(branch.m5c, branch);
-    });
-    _resume(RENDER_BODY_ID, warp10Noop);
-  },
-  registerRenderer(fn) {
-    _resume(RENDERER_REGISTER_ID, fn);
-  },
-  isRenderer(renderer) {
-    return renderer.___clone;
-  },
-  getStartNode(branch) {
-    return branch["#StartNode" /* StartNode */];
-  },
-  setScopeNodes(branch, startNode, endNode) {
-    branch["#StartNode" /* StartNode */] = startNode;
-    branch["#EndNode" /* EndNode */] = endNode;
-  },
-  runComponentEffects() {
-    if (this.effects) {
-      runEffects(this.effects);
-    }
-  },
-  runComponentDestroy() {
-    if (this.scope) {
-      destroyBranch(this.scope);
-    }
-  },
-  resolveRegistered(value, $global) {
-    if (Array.isArray(value) && typeof value[0] === "string") {
-      return getRegisteredWithScope(
-        value[0],
-        value.length === 2 && self[$global.runtimeId]?.[$global.renderId]?.s[value[1]]
-      );
-    }
-    return value;
-  },
-  createRenderer(params, clone) {
-    const renderer = _content("", 0, 0, 0, params)();
-    renderer.___clone = (branch) => {
-      const cloned = clone();
-      branch["#StartNode" /* StartNode */] = cloned.startNode;
-      branch["#EndNode" /* EndNode */] = cloned.endNode;
-    };
-    return renderer;
-  },
-  render(out, component, renderer, args) {
-    let branch = component.scope;
-    let created = 0;
-    if (!branch && (branch = classIdToBranch.get(component.id))) {
-      component.scope = branch;
-      classIdToBranch.delete(component.id);
-    }
-    if (typeof args[0] === "object" && "renderBody" in args[0]) {
-      const input = args[0];
-      const normalizedInput = args[0] = {};
-      for (const key in input) {
-        normalizedInput[key === "renderBody" ? "content" : key] = input[key];
-      }
-    }
-    component.effects = prepareEffects(() => {
-      if (!branch) {
-        created = 1;
-        branch = component.scope = createAndSetupBranch(
-          out.global,
-          renderer,
-          renderer.___owner,
-          document.body
-        );
-      }
-      renderer.___params?.(branch, renderer._ ? args[0] : args);
-    });
-    if (created) {
-      return toInsertNode(
-        branch["#StartNode" /* StartNode */],
-        branch["#EndNode" /* EndNode */]
-      );
-    }
-  }
+	ctrl.abort();
+}
+//#endregion
+//#region src/common/compat-meta.ts
+const prefix = "$compat_";
+const RENDERER_REGISTER_ID = prefix + "renderer";
+const SET_SCOPE_REGISTER_ID = prefix + "setScope";
+const RENDER_BODY_ID = prefix + "renderBody";
+//#endregion
+//#region src/dom/compat.ts
+const classIdToBranch = /* @__PURE__ */ new Map();
+const compat = {
+	patchDynamicTag,
+	queueEffect,
+	init(warp10Noop) {
+		_resume(SET_SCOPE_REGISTER_ID, (branch) => {
+			classIdToBranch.set(branch.m5c, branch);
+		});
+		_resume(RENDER_BODY_ID, warp10Noop);
+	},
+	registerRenderer(fn) {
+		_resume(RENDERER_REGISTER_ID, fn);
+	},
+	isRenderer(renderer) {
+		return renderer["clone"];
+	},
+	getStartNode(branch) {
+		return branch["#StartNode"];
+	},
+	setScopeNodes(branch, startNode, endNode) {
+		branch["#StartNode"] = startNode;
+		branch["#EndNode"] = endNode;
+	},
+	runComponentEffects() {
+		if (this.effects) runEffects(this.effects);
+	},
+	runComponentDestroy() {
+		if (this.scope) destroyBranch(this.scope);
+	},
+	resolveRegistered(value, $global) {
+		if (Array.isArray(value) && typeof value[0] === "string") return getRegisteredWithScope(value[0], value.length === 2 && self[$global.runtimeId]?.[$global.renderId]?.s[value[1]]);
+		return value;
+	},
+	createRenderer(params, clone) {
+		const renderer = _content("", 0, 0, 0, params)();
+		renderer["clone"] = (branch) => {
+			const cloned = clone();
+			branch["#StartNode"] = cloned.startNode;
+			branch["#EndNode"] = cloned.endNode;
+		};
+		return renderer;
+	},
+	render(out, component, renderer, args) {
+		let branch = component.scope;
+		let created = 0;
+		if (!branch && (branch = classIdToBranch.get(component.id))) {
+			component.scope = branch;
+			classIdToBranch.delete(component.id);
+		}
+		if (typeof args[0] === "object" && "renderBody" in args[0]) {
+			const input = args[0];
+			const normalizedInput = args[0] = {};
+			for (const key in input) normalizedInput[key === "renderBody" ? "content" : key] = input[key];
+		}
+		component.effects = prepareEffects(() => {
+			if (!branch) {
+				created = 1;
+				branch = component.scope = createAndSetupBranch(out.global, renderer, renderer["owner"], document.body);
+			}
+			renderer["params"]?.(branch, renderer._ ? args[0] : args);
+		});
+		if (created) return toInsertNode(branch["#StartNode"], branch["#EndNode"]);
+	}
 };
-
-// src/dom/template.ts
-var _template = (id, template, walks, setup, inputSignal) => {
-  const renderer = _content(
-    id,
-    template,
-    walks,
-    setup,
-    inputSignal
-  )();
-  renderer.mount = mount;
-  renderer._ = renderer;
-  if (true) {
-    renderer.render = () => {
-      throw new Error(
-        `render() is not implemented for the DOM compilation of a Marko template`
-      );
-    };
-  }
-  return _resume(id, renderer);
+//#endregion
+//#region src/dom/template.ts
+const _template = (id, template, walks, setup, inputSignal) => {
+	const renderer = _content(id, template, walks, setup, inputSignal)();
+	renderer.mount = mount;
+	renderer._ = renderer;
+	renderer.render = () => {
+		throw new Error(`render() is not implemented for the DOM compilation of a Marko template`);
+	};
+	return _resume(id, renderer);
 };
 function mount(input = {}, reference, position) {
-  let branch;
-  let parentNode = reference;
-  let nextSibling = null;
-  let { $global } = input;
-  if ($global) {
-    ({ $global, ...input } = input);
-    $global = {
-      runtimeId: DEFAULT_RUNTIME_ID,
-      renderId: DEFAULT_RENDER_ID,
-      ...$global
-    };
-    if (true) {
-      if (!String($global.runtimeId).match(/^[_$a-z][_$a-z0-9]*$/i)) {
-        throw new Error(
-          `Invalid runtimeId: "${$global.runtimeId}". The runtimeId must be a valid JavaScript identifier.`
-        );
-      }
-      if (!String($global.renderId).match(/^[_$a-z][_$a-z0-9]*$/i)) {
-        throw new Error(
-          `Invalid renderId: "${$global.renderId}". The renderId must be a valid JavaScript identifier.`
-        );
-      }
-    }
-  } else {
-    $global = {
-      runtimeId: DEFAULT_RUNTIME_ID,
-      renderId: DEFAULT_RENDER_ID
-    };
-  }
-  switch (position) {
-    case "beforebegin":
-      parentNode = reference.parentNode;
-      nextSibling = reference;
-      break;
-    case "afterbegin":
-      nextSibling = reference.firstChild;
-      break;
-    case "afterend":
-      parentNode = reference.parentNode;
-      nextSibling = reference.nextSibling;
-      break;
-  }
-  let curValue;
-  const args = this.___params;
-  const effects = prepareEffects(() => {
-    branch = createBranch(
-      $global,
-      this,
-      void 0,
-      parentNode
-    );
-    branch["#TagVariable" /* TagVariable */] = (newValue) => {
-      curValue = newValue;
-    };
-    this.___setup?.(branch);
-    args?.(branch, input);
-  });
-  insertChildNodes(
-    parentNode,
-    nextSibling,
-    branch["#StartNode" /* StartNode */],
-    branch["#EndNode" /* EndNode */]
-  );
-  runEffects(effects);
-  return {
-    get value() {
-      return curValue;
-    },
-    set value(newValue) {
-      _var_change(branch, newValue);
-    },
-    update(newInput) {
-      if (args) {
-        runEffects(
-          prepareEffects(() => {
-            args(branch, newInput);
-          })
-        );
-      }
-    },
-    destroy() {
-      removeAndDestroyBranch(branch);
-    }
-  };
-}
+	let branch;
+	let parentNode = reference;
+	let nextSibling = null;
+	let { $global } = input;
+	if ($global) {
+		({$global, ...input} = input);
+		$global = {
+			runtimeId: "M",
+			renderId: "_",
+			...$global
+		};
+		if (!String($global.runtimeId).match(/^[_$a-z][_$a-z0-9]*$/i)) throw new Error(`Invalid runtimeId: "${$global.runtimeId}". The runtimeId must be a valid JavaScript identifier.`);
+		if (!String($global.renderId).match(/^[_$a-z][_$a-z0-9]*$/i)) throw new Error(`Invalid renderId: "${$global.renderId}". The renderId must be a valid JavaScript identifier.`);
+	} else $global = {
+		runtimeId: "M",
+		renderId: "_"
+	};
+	switch (position) {
+		case "beforebegin":
+			parentNode = reference.parentNode;
+			nextSibling = reference;
+			break;
+		case "afterbegin":
+			nextSibling = reference.firstChild;
+			break;
+		case "afterend":
+			parentNode = reference.parentNode;
+			nextSibling = reference.nextSibling;
+			break;
+	}
+	let curValue;
+	const args = this["params"];
+	const effects = prepareEffects(() => {
+		branch = createBranch($global, this, void 0, parentNode);
+		branch["#TagVariable"] = (newValue) => {
+			curValue = newValue;
+		};
+		this["setup"]?.(branch);
+		args?.(branch, input);
+	});
+	insertChildNodes(parentNode, nextSibling, branch["#StartNode"], branch["#EndNode"]);
+	runEffects(effects);
+	return {
+		get value() {
+			return curValue;
+		},
+		set value(newValue) {
+			_var_change(branch, newValue);
+		},
+		update(newInput) {
+			if (args) runEffects(prepareEffects(() => {
+				args(branch, newInput);
+			}));
+		},
+		destroy() {
+			removeAndDestroyBranch(branch);
+		}
+	};
+}
+//#endregion
+exports.$signal = $signal;
+exports.$signalReset = $signalReset;
+exports._assert_hoist = _assert_hoist;
+exports._assert_init = _assert_init;
+exports._attr = _attr;
+exports._attr_class = _attr_class;
+exports._attr_class_item = _attr_class_item;
+exports._attr_class_items = _attr_class_items;
+exports._attr_content = _attr_content;
+exports._attr_details_open = _attr_details_or_dialog_open;
+exports._attr_details_open_default = _attr_details_or_dialog_open_default;
+exports._attr_details_open_script = _attr_details_or_dialog_open_script;
+exports._attr_dialog_open = _attr_details_or_dialog_open;
+exports._attr_dialog_open_default = _attr_details_or_dialog_open_default;
+exports._attr_dialog_open_script = _attr_details_or_dialog_open_script;
+exports._attr_input_checked = _attr_input_checked;
+exports._attr_input_checkedValue = _attr_input_checkedValue;
+exports._attr_input_checkedValue_default = _attr_input_checkedValue_default;
+exports._attr_input_checkedValue_script = _attr_input_checkedValue_script;
+exports._attr_input_checked_default = _attr_input_checked_default;
+exports._attr_input_checked_script = _attr_input_checked_script;
+exports._attr_input_value = _attr_input_value;
+exports._attr_input_value_default = _attr_input_value_default;
+exports._attr_input_value_script = _attr_input_value_script;
+exports._attr_nonce = _attr_nonce;
+exports._attr_select_value = _attr_select_value;
+exports._attr_select_value_default = _attr_select_value_default;
+exports._attr_select_value_script = _attr_select_value_script;
+exports._attr_style = _attr_style;
+exports._attr_style_item = _attr_style_item;
+exports._attr_style_items = _attr_style_items;
+exports._attr_textarea_value = _attr_input_value;
+exports._attr_textarea_value_default = _attr_input_value_default;
+exports._attr_textarea_value_script = _attr_input_value_script;
+exports._attrs = _attrs;
+exports._attrs_content = _attrs_content;
+exports._attrs_partial = _attrs_partial;
+exports._attrs_partial_content = _attrs_partial_content;
+exports._attrs_script = _attrs_script;
+exports._await_content = _await_content;
+exports._await_promise = _await_promise;
+exports._call = _call;
+exports._child_setup = _child_setup;
+exports._closure = _closure;
+exports._closure_get = _closure_get;
+exports._const = _const;
+exports._content = _content;
+exports._content_closures = _content_closures;
+exports._content_resume = _content_resume;
+Object.defineProperty(exports, "_dynamic_tag", {
+	enumerable: true,
+	get: function() {
+		return _dynamic_tag;
+	}
+});
+exports._el = _el;
+exports._el_read = _el_read;
+exports._enable_catch = _enable_catch;
+exports._for_closure = _for_closure;
+exports._for_in = _for_in;
+exports._for_of = _for_of;
+exports._for_to = _for_to;
+exports._for_until = _for_until;
+exports._hoist = _hoist;
+exports._hoist_resume = _hoist_resume;
+exports._html = _html;
+exports._id = _id;
+exports._if = _if;
+exports._if_closure = _if_closure;
+exports._let = _let;
+exports._lifecycle = _lifecycle;
+exports._on = _on;
+exports._or = _or;
+exports._resume = _resume;
+exports._resume_dynamic_tag = _resume_dynamic_tag;
+exports._return = _return;
+exports._return_change = _return_change;
+exports._script = _script;
+exports._template = _template;
+exports._text = _text;
+exports._text_content = _text_content;
+exports._to_text = _to_text;
+exports._try = _try;
+exports._var = _var;
+exports._var_change = _var_change;
+exports._var_resume = _var_resume;
+exports.attrTag = attrTag;
+exports.attrTags = attrTags;
+exports.compat = compat;
+exports.forIn = forIn;
+exports.forOf = forOf;
+exports.forTo = forTo;
+exports.forUntil = forUntil;
+exports.init = init;
+exports.initEmbedded = initEmbedded;
+exports.run = run;