marko 6.0.60 → 6.0.62

package/dist/debug/dom.js

@@ -20,98 +20,99 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/dom.ts
 var dom_exports = {};
 __export(dom_exports, {
-  attr: () => attr,
+  $signal: () => $signal,
+  $signalReset: () => $signalReset,
+  _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_script: () => _attr_details_or_dialog_open_script,
+  _attr_dialog_open: () => _attr_details_or_dialog_open,
+  _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_script: () => _attr_input_checkedValue_script,
+  _attr_input_checked_script: () => _attr_input_checked_script,
+  _attr_input_value: () => _attr_input_value,
+  _attr_input_value_script: () => _attr_input_value_script,
+  _attr_select_value: () => _attr_select_value,
+  _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_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: () => _await,
+  _closure: () => _closure,
+  _closure_get: () => _closure_get,
+  _const: () => _const,
+  _content: () => _content,
+  _content_branch: () => _content_branch,
+  _content_closures: () => _content_closures,
+  _content_resume: () => _content_resume,
+  _dynamic_tag: () => _dynamic_tag,
+  _el: () => _el,
+  _enable_catch: () => _enable_catch,
+  _for_closure: () => _for_closure,
+  _for_in: () => _for_in,
+  _for_of: () => _for_of,
+  _for_to: () => _for_to,
+  _hoist: () => _hoist,
+  _html: () => _html,
+  _id: () => _id,
+  _if: () => _if,
+  _if_closure: () => _if_closure,
+  _let: () => _let,
+  _lifecycle: () => _lifecycle,
+  _on: () => _on,
+  _or: () => _or,
+  _resume: () => _resume,
+  _return: () => _return,
+  _return_change: () => _return_change,
+  _script: () => _script,
+  _template: () => _template,
+  _text: () => _text,
+  _text_content: () => _text_content,
+  _try: () => _try,
+  _var: () => _var,
+  _var_change: () => _var_change,
+  _var_resume: () => _var_resume,
   attrTag: () => attrTag,
   attrTags: () => attrTags,
-  attrs: () => attrs,
-  attrsAndContent: () => attrsAndContent,
-  attrsEvents: () => attrsEvents,
-  awaitTag: () => awaitTag,
-  classAttr: () => classAttr,
-  classItem: () => classItem,
-  classItems: () => classItems,
   compat: () => compat,
-  conditional: () => conditional,
-  conditionalClosure: () => conditionalClosure,
-  controllable_detailsOrDialog_open: () => controllable_detailsOrDialog_open,
-  controllable_detailsOrDialog_open_effect: () => controllable_detailsOrDialog_open_effect,
-  controllable_input_checked: () => controllable_input_checked,
-  controllable_input_checkedValue: () => controllable_input_checkedValue,
-  controllable_input_checkedValue_effect: () => controllable_input_checkedValue_effect,
-  controllable_input_checked_effect: () => controllable_input_checked_effect,
-  controllable_input_value: () => controllable_input_value,
-  controllable_input_value_effect: () => controllable_input_value_effect,
-  controllable_select_value: () => controllable_select_value,
-  controllable_select_value_effect: () => controllable_select_value_effect,
-  controllable_textarea_value: () => controllable_input_value,
-  controllable_textarea_value_effect: () => controllable_input_value_effect,
-  createContent: () => createContent,
-  createRenderer: () => createRenderer,
-  createTemplate: () => createTemplate,
-  createTry: () => createTry,
-  data: () => data,
-  dynamicClosure: () => dynamicClosure,
-  dynamicClosureRead: () => dynamicClosureRead,
-  dynamicTag: () => dynamicTag,
-  effect: () => effect,
-  enableCatch: () => enableCatch,
   forIn: () => forIn,
   forOf: () => forOf,
   forTo: () => forTo,
-  getAbortSignal: () => getAbortSignal,
-  hoist: () => hoist,
-  html: () => html,
   init: () => init,
-  insertContent: () => insertContent,
-  intersection: () => intersection,
-  lifecycle: () => lifecycle,
-  localClosures: () => localClosures,
-  loopClosure: () => loopClosure,
-  loopIn: () => loopIn,
-  loopOf: () => loopOf,
-  loopTo: () => loopTo,
-  nextTagId: () => nextTagId,
-  nodeRef: () => nodeRef,
-  on: () => on,
-  partialAttrs: () => partialAttrs,
-  partialAttrsAndContent: () => partialAttrsAndContent,
-  props: () => props,
-  register: () => register,
-  registerBoundSignal: () => registerBoundSignal,
-  registerContent: () => registerContent,
-  resetAbortSignal: () => resetAbortSignal,
-  run: () => run,
-  setTagVar: () => setTagVar,
-  setTagVarChange: () => setTagVarChange,
-  state: () => state,
-  styleAttr: () => styleAttr,
-  styleItem: () => styleItem,
-  styleItems: () => styleItems,
-  tagVarSignal: () => tagVarSignal,
-  tagVarSignalChange: () => tagVarSignalChange,
-  textContent: () => textContent,
-  value: () => value
+  run: () => run
 });
 module.exports = __toCommonJS(dom_exports);
 
 // src/common/attr-tag.ts
 var empty = [];
 var rest = true ? Symbol("Attribute Tag") : Symbol();
-function attrTag(attrs2) {
-  attrs2[Symbol.iterator] = attrTagIterator;
-  attrs2[rest] = empty;
-  return attrs2;
+function attrTag(attrs) {
+  attrs[Symbol.iterator] = attrTagIterator;
+  attrs[rest] = empty;
+  return attrs;
 }
-function attrTags(first, attrs2) {
+function attrTags(first, attrs) {
   if (first) {
     if (first[rest] === empty) {
-      first[rest] = [attrs2];
+      first[rest] = [attrs];
     } else {
-      first[rest].push(attrs2);
+      first[rest].push(attrs);
     }
     return first;
   }
-  return attrTag(attrs2);
+  return attrTag(attrs);
 }
 function* attrTagIterator() {
   yield this;
@@ -144,14 +145,14 @@ function forTo(to, from, step, cb) {
 function classValue(classValue2) {
   return toDelimitedString(classValue2, " ", stringifyClassObject);
 }
-function stringifyClassObject(name, value2) {
-  return value2 ? name : "";
+function stringifyClassObject(name, value) {
+  return value ? name : "";
 }
 function styleValue(styleValue2) {
   return toDelimitedString(styleValue2, ";", stringifyStyleObject);
 }
-function stringifyStyleObject(name, value2) {
-  return value2 || value2 === 0 ? name + ":" + value2 : "";
+function stringifyStyleObject(name, value) {
+  return value || value === 0 ? name + ":" + value : "";
 }
 function toDelimitedString(val, delimiter, stringify) {
   let str = "";
@@ -186,13 +187,13 @@ function isEventHandler(name) {
 function getEventHandlerName(name) {
   return name[2] === "-" ? name.slice(3) : name.slice(2).toLowerCase();
 }
-function normalizeDynamicRenderer(value2) {
-  return value2 ? value2.content || value2.default || value2 : void 0;
+function normalizeDynamicRenderer(value) {
+  return value ? value.content || value.default || value : void 0;
 }
 
 // src/dom/event.ts
 var defaultDelegator = createDelegator();
-function on(element, type, handler) {
+function _on(element, type, handler) {
   if (element["$" + type] === void 0) {
     defaultDelegator(element, type, handleDelegated);
   }
@@ -307,57 +308,57 @@ function walk(startNode, walkCodes, branch) {
   walkInternal(0, walkCodes, branch);
 }
 function walkInternal(currentWalkIndex, walkCodes, scope) {
-  let value2;
+  let value;
   let storedMultiplier = 0;
   let currentMultiplier = 0;
   let currentScopeIndex = 0;
   for (; currentWalkIndex < walkCodes.length; ) {
-    value2 = walkCodes.charCodeAt(currentWalkIndex++);
+    value = walkCodes.charCodeAt(currentWalkIndex++);
     currentMultiplier = storedMultiplier;
     storedMultiplier = 0;
-    if (value2 === 32 /* Get */) {
+    if (value === 32 /* Get */) {
       const node = walker.currentNode;
       scope[true ? getDebugKey(currentScopeIndex, walker.currentNode) : currentScopeIndex] = node;
       scope["Getter:" /* Getter */ + (true ? getDebugKey(currentScopeIndex++, walker.currentNode) : currentScopeIndex++)] = () => node;
-    } else if (value2 === 37 /* Replace */ || value2 === 49 /* DynamicTagWithVar */) {
+    } else if (value === 37 /* Replace */ || value === 49 /* DynamicTagWithVar */) {
       walker.currentNode.replaceWith(
         walker.currentNode = scope[true ? getDebugKey(currentScopeIndex++, "#text") : currentScopeIndex++] = new Text()
       );
-      if (value2 === 49 /* DynamicTagWithVar */) {
+      if (value === 49 /* DynamicTagWithVar */) {
         scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : currentScopeIndex++] = skipScope(scope);
       }
-    } else if (value2 === 38 /* EndChild */) {
+    } else if (value === 38 /* EndChild */) {
       return currentWalkIndex;
-    } else if (value2 === 47 /* BeginChild */ || value2 === 48 /* BeginChildWithVar */) {
+    } else if (value === 47 /* BeginChild */ || value === 48 /* BeginChildWithVar */) {
       currentWalkIndex = walkInternal(
         currentWalkIndex,
         walkCodes,
         scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : currentScopeIndex++] = createScope(scope.$global, scope.___closestBranch)
       );
-      if (value2 === 48 /* BeginChildWithVar */) {
+      if (value === 48 /* BeginChildWithVar */) {
         scope[true ? getDebugKey(currentScopeIndex++, "#scopeOffset") : currentScopeIndex++] = skipScope(scope);
       }
-    } else if (value2 < 91 /* NextEnd */ + 1) {
-      value2 = 20 /* Next */ * currentMultiplier + value2 - 67 /* Next */;
-      while (value2--) {
+    } else if (value < 91 /* NextEnd */ + 1) {
+      value = 20 /* Next */ * currentMultiplier + value - 67 /* Next */;
+      while (value--) {
         walker.nextNode();
       }
-    } else if (value2 < 106 /* OverEnd */ + 1) {
-      value2 = 10 /* Over */ * currentMultiplier + value2 - 97 /* Over */;
-      while (value2--) {
+    } else if (value < 106 /* OverEnd */ + 1) {
+      value = 10 /* Over */ * currentMultiplier + value - 97 /* Over */;
+      while (value--) {
         walker.nextSibling();
       }
-    } else if (value2 < 116 /* OutEnd */ + 1) {
-      value2 = 10 /* Out */ * currentMultiplier + value2 - 107 /* Out */;
-      while (value2--) {
+    } else if (value < 116 /* OutEnd */ + 1) {
+      value = 10 /* Out */ * currentMultiplier + value - 107 /* Out */;
+      while (value--) {
         walker.parentNode();
       }
       walker.nextSibling();
     } else {
-      if (value2 < 117 /* Multiplier */ || value2 > 126 /* MultiplierEnd */) {
-        throw new Error(`Unknown walk code: ${value2}`);
+      if (value < 117 /* Multiplier */ || value > 126 /* MultiplierEnd */) {
+        throw new Error(`Unknown walk code: ${value}`);
       }
-      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value2 - 117 /* Multiplier */;
+      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value - 117 /* Multiplier */;
     }
   }
 }
@@ -397,84 +398,72 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
       value: resumeRender = ((renderId) => {
         const render = resumeRender[renderId] = renders2[renderId] || renders2(renderId);
         const walk2 = render.w;
-        const commentPrefixLen = render.i.length;
         const scopeLookup = render.s = {};
         const serializeContext = {
           _: registeredValues
         };
         const branches = branchesEnabled && /* @__PURE__ */ (() => {
-          const branchStack = [];
-          const branchIds = /* @__PURE__ */ new Set();
-          const parentBranchIds = /* @__PURE__ */ new Map();
-          let lastEndNode;
-          let currentBranchId;
-          const endBranch = (branchId, reference) => {
-            const branch = scopeLookup[branchId] ||= {};
-            let endNode = reference;
-            let prevNode;
-            while ((prevNode = endNode.previousSibling) !== branch.___startNode && ~visits.indexOf(endNode = prevNode)) ;
-            branch.___endNode = lastEndNode = endNode === lastEndNode ? reference.parentNode.insertBefore(new Text(), reference) : endNode;
-            branch.___startNode ||= lastEndNode;
-            branchIds.add(branchId);
-            return branch;
+          const branchParents = /* @__PURE__ */ new Map();
+          const branchStarts = [];
+          const orphanBranches = [];
+          const endBranch = (singleNode) => {
+            const parent = visit.parentNode;
+            let startVisit = visit;
+            let i = orphanBranches.length;
+            let claimed = 0;
+            let branchId;
+            let branch;
+            while (branchId = +lastToken) {
+              branch = scopeLookup[branchId] ||= {};
+              if (singleNode) {
+                while (startVisit.previousSibling && ~visits.indexOf(
+                  startVisit = startVisit.previousSibling
+                )) ;
+                branch.___endNode = branch.___startNode = startVisit;
+                if (visitType === "'" /* BranchEndNativeTag */) {
+                  branch[true ? getDebugKey(0, startVisit) : 0] = startVisit;
+                }
+              } else {
+                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] > branchId) {
+                branchParents.set(orphanBranches[i], branchId);
+                claimed++;
+              }
+              orphanBranches.push(branchId);
+              branchParents.set(branchId, 0);
+              nextToken();
+            }
+            orphanBranches.splice(i, claimed);
           };
           return {
             ___visit() {
-              if (visitToken === "[" /* BranchStart */) {
-                if (currentBranchId && visitDataIndex) {
-                  endBranch(currentBranchId, visit);
-                  currentBranchId = branchStack.pop();
-                }
-                if (currentBranchId) {
-                  branchStack.push(currentBranchId);
-                  parentBranchIds.set(scopeId, currentBranchId);
-                }
-                currentBranchId = scopeId;
-                visitScope.___startNode = visit;
-              } else if (visitToken === "]" /* BranchEnd */) {
-                const curParent = visit.parentNode;
-                const startNode = endBranch(
-                  currentBranchId,
-                  visit
-                ).___startNode;
-                visitScope[visitData] = visit;
-                if (curParent !== startNode.parentNode) {
-                  curParent.prepend(startNode);
-                }
-                currentBranchId = branchStack.pop();
+              if (visitType === "[" /* BranchStart */) {
+                endBranch();
+                branchStarts.push(visit);
               } else {
-                let next = visitData.indexOf(" ");
-                let curNode = visit;
-                visitScope[~next ? visitData.slice(0, next) : visitData] = visitToken === "=" /* BranchSingleNodeOnlyChildInParent */ ? visit.parentNode : visit;
-                while (~next) {
-                  const start = next + 1;
-                  next = visitData.indexOf(" ", start);
-                  const childScopeId = +visitData.slice(
-                    start,
-                    ~next ? next : visitData.length
-                  );
-                  curNode = endBranch(childScopeId, curNode).___endNode;
-                  parentBranchIds.set(childScopeId, scopeId);
-                  if (visitToken === "'" /* BranchNativeTag */) {
-                    const childBranch = scopeLookup[childScopeId];
-                    childBranch[true ? getDebugKey(0, curNode) : 0] = childBranch.___startNode = childBranch.___endNode = curNode;
-                  }
-                }
+                visitScope[
+                  nextToken()
+                  /* read accessor */
+                ] = visitType === ")" /* BranchEndOnlyChildInParent */ || visitType === "}" /* BranchEndSingleNodeOnlyChildInParent */ ? visit.parentNode : visit;
+                nextToken();
+                endBranch(
+                  visitType !== "]" /* BranchEnd */ && visitType !== ")" /* BranchEndOnlyChildInParent */
+                );
               }
             },
             ___scope(scope) {
-              const parentBranchId = scope["#ClosestBranchId" /* ClosestBranchId */] || parentBranchIds.get(scopeId);
-              if (parentBranchId) {
-                scope.___closestBranch = scopeLookup[parentBranchId];
-              }
-              if (branchIds.has(scopeId)) {
-                const branch = scope;
-                const parentBranch = branch.___closestBranch;
-                scope.___closestBranch = branch;
-                if (parentBranch) {
-                  branch.___parentBranch = parentBranch;
-                  (parentBranch.___branchScopes ||= /* @__PURE__ */ new Set()).add(branch);
+              scope.___closestBranch = scopeLookup[scope["#ClosestBranchId" /* ClosestBranchId */] || branchParents.get(scopeId)];
+              if (branchParents.has(scopeId)) {
+                if (scope.___closestBranch) {
+                  ((scope.___parentBranch = scope.___closestBranch).___branchScopes ||= /* @__PURE__ */ new Set()).add(scope);
                 }
+                scope.___closestBranch = scope;
               }
             }
           };
@@ -487,29 +476,31 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
         let scopeId;
         let visit;
         let visitText;
-        let visitData;
-        let visitDataIndex;
-        let visitToken;
+        let visitType;
         let visitScope;
+        let lastToken;
+        let lastTokenIndex;
+        const nextToken = () => lastToken = visitText.slice(
+          lastTokenIndex,
+          // eslint-disable-next-line no-cond-assign
+          (lastTokenIndex = visitText.indexOf(" ", lastTokenIndex) + 1) ? lastTokenIndex - 1 : visitText.length
+        );
         render.w = () => {
           try {
             walk2();
             isResuming = 1;
             for (visit of visits = render.v) {
+              lastTokenIndex = render.i.length;
               visitText = visit.data;
-              visitDataIndex = visitText.indexOf(" ") + 1;
-              scopeId = +visitText.slice(
-                commentPrefixLen + 1,
-                visitDataIndex ? visitDataIndex - 1 : visitText.length
-              );
-              visitData = visitDataIndex ? visitText.slice(visitDataIndex) : "";
-              visitToken = visitText[commentPrefixLen];
-              visitScope = scopeLookup[scopeId] ||= {
-                ___id: scopeId
-              };
-              if (visitToken === "*" /* Node */) {
-                visitScope["Getter:" /* Getter */ + visitData] = /* @__PURE__ */ ((node) => () => node)(visitScope[visitData] = visit.previousSibling);
-              } else if (branches) {
+              visitType = visitText[lastTokenIndex++];
+              if (scopeId = +nextToken()) {
+                visitScope = scopeLookup[scopeId] ||= {
+                  ___id: scopeId
+                };
+              }
+              if (visitType === "*" /* Node */) {
+                visitScope["Getter:" /* Getter */ + nextToken()] = /* @__PURE__ */ ((node) => () => node)(visitScope[lastToken] = visit.previousSibling);
+              } else if (branchesEnabled) {
                 branches.___visit();
               }
             }
@@ -542,7 +533,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
                         scopeLookup[scopeId]
                       );
                     }
-                    if (branches) {
+                    if (branchesEnabled) {
                       branches.___scope(scope);
                     }
                     if (true) {
@@ -573,24 +564,24 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
   }
 }
 var isResuming;
-function register(id, obj) {
+function _resume(id, obj) {
   registeredValues[id] = obj;
   return obj;
 }
-function registerBoundSignal(id, signal) {
-  registeredValues[id] = (scope) => (value2) => signal(scope, value2);
+function _var_resume(id, signal) {
+  registeredValues[id] = (scope) => (value) => signal(scope, value);
   return signal;
 }
 function getRegisteredWithScope(id, scope) {
   const val = registeredValues[id];
   return scope ? val(scope) : val;
 }
-function nodeRef(id, key) {
-  return register(id, (scope) => () => scope[key]());
+function _el(id, key) {
+  return _resume(id, (scope) => () => scope[key]());
 }
 
 // src/dom/controllable.ts
-function controllable_input_checked(scope, nodeAccessor, checked, checkedChange) {
+function _attr_input_checked(scope, nodeAccessor, checked, checkedChange) {
   setCheckboxValue(
     scope,
     nodeAccessor,
@@ -599,7 +590,7 @@ function controllable_input_checked(scope, nodeAccessor, checked, checkedChange)
     checkedChange
   );
 }
-function controllable_input_checked_effect(scope, nodeAccessor) {
+function _attr_input_checked_script(scope, nodeAccessor) {
   const el = scope[nodeAccessor];
   syncControllable(el, "input", hasCheckboxChanged, () => {
     const checkedChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
@@ -611,18 +602,18 @@ function controllable_input_checked_effect(scope, nodeAccessor) {
     }
   });
 }
-function controllable_input_checkedValue(scope, nodeAccessor, checkedValue, checkedValueChange, value2) {
+function _attr_input_checkedValue(scope, nodeAccessor, checkedValue, checkedValueChange, value) {
   scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = checkedValue;
-  attr(scope[nodeAccessor], "value", value2);
+  _attr(scope[nodeAccessor], "value", value);
   setCheckboxValue(
     scope,
     nodeAccessor,
     1 /* InputCheckedValue */,
-    Array.isArray(checkedValue) ? checkedValue.includes(value2) : checkedValue === value2,
+    Array.isArray(checkedValue) ? checkedValue.includes(value) : checkedValue === value,
     checkedValueChange
   );
 }
-function controllable_input_checkedValue_effect(scope, nodeAccessor) {
+function _attr_input_checkedValue_script(scope, nodeAccessor) {
   const el = scope[nodeAccessor];
   syncControllable(el, "input", hasCheckboxChanged, () => {
     const checkedValueChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
@@ -645,13 +636,13 @@ function controllable_input_checkedValue_effect(scope, nodeAccessor) {
     }
   });
 }
-function controllable_input_value(scope, nodeAccessor, value2, valueChange) {
+function _attr_input_value(scope, nodeAccessor, value, valueChange) {
   const el = scope[nodeAccessor];
-  const normalizedValue = normalizeStrProp(value2);
+  const normalizedValue = normalizeStrProp(value);
   scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = valueChange;
   if (valueChange) {
     scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 0 /* InputChecked */;
-    scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = value2;
+    scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = value;
     if (el.isConnected) {
       setValueAndUpdateSelection(el, normalizedValue);
     } else {
@@ -662,7 +653,7 @@ function controllable_input_value(scope, nodeAccessor, value2, valueChange) {
     el.defaultValue = normalizedValue;
   }
 }
-function controllable_input_value_effect(scope, nodeAccessor) {
+function _attr_input_value_script(scope, nodeAccessor) {
   const el = scope[nodeAccessor];
   if (isResuming) {
     scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = el.defaultValue;
@@ -681,24 +672,24 @@ function controllable_input_value_effect(scope, nodeAccessor) {
     }
   });
 }
-function controllable_select_value(scope, nodeAccessor, value2, valueChange) {
+function _attr_select_value(scope, nodeAccessor, value, valueChange) {
   scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = valueChange;
   if (valueChange) {
     scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 3 /* SelectValue */;
-    scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = value2;
+    scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = value;
   } else {
     scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 5 /* None */;
   }
   pendingEffects.unshift(
     () => setSelectOptions(
       scope[nodeAccessor],
-      value2,
+      value,
       valueChange
     ),
     scope
   );
 }
-function controllable_select_value_effect(scope, nodeAccessor) {
+function _attr_select_value_script(scope, nodeAccessor) {
   const el = scope[nodeAccessor];
   const onChange = () => {
     const valueChange = scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor];
@@ -717,8 +708,8 @@ function controllable_select_value_effect(scope, nodeAccessor) {
   };
   if (!el._) {
     new MutationObserver(() => {
-      const value2 = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
-      if (Array.isArray(value2) ? value2.length !== el.selectedOptions.length || value2.some((value3, i) => value3 != el.selectedOptions[i].value) : el.value != value2) {
+      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, {
@@ -728,10 +719,10 @@ function controllable_select_value_effect(scope, nodeAccessor) {
   }
   syncControllable(el, "input", hasSelectChanged, onChange);
 }
-function setSelectOptions(el, value2, valueChange) {
-  if (Array.isArray(value2)) {
+function setSelectOptions(el, value, valueChange) {
+  if (Array.isArray(value)) {
     for (const opt of el.options) {
-      const selected = value2.includes(opt.value);
+      const selected = value.includes(opt.value);
       if (valueChange) {
         opt.selected = selected;
       } else {
@@ -739,7 +730,7 @@ function setSelectOptions(el, value2, valueChange) {
       }
     }
   } else {
-    const normalizedValue = normalizeStrProp(value2);
+    const normalizedValue = normalizeStrProp(value);
     if (valueChange) {
       el.value = normalizedValue;
     } else {
@@ -749,7 +740,7 @@ function setSelectOptions(el, value2, valueChange) {
     }
   }
 }
-function controllable_detailsOrDialog_open(scope, nodeAccessor, open, openChange) {
+function _attr_details_or_dialog_open(scope, nodeAccessor, open, openChange) {
   scope["ControlledHandler:" /* ControlledHandler */ + nodeAccessor] = openChange;
   if (openChange) {
     scope["ControlledType:" /* ControlledType */ + nodeAccessor] = 4 /* DetailsOrDialogOpen */;
@@ -758,7 +749,7 @@ function controllable_detailsOrDialog_open(scope, nodeAccessor, open, openChange
   }
   scope[nodeAccessor].open = scope["ControlledValue:" /* ControlledValue */ + nodeAccessor] = normalizeBoolProp(open);
 }
-function controllable_detailsOrDialog_open_effect(scope, nodeAccessor) {
+function _attr_details_or_dialog_open_script(scope, nodeAccessor) {
   const el = scope[nodeAccessor];
   const hasChanged = () => el.open !== scope["ControlledValue:" /* ControlledValue */ + nodeAccessor];
   syncControllable(
@@ -777,13 +768,13 @@ function controllable_detailsOrDialog_open_effect(scope, nodeAccessor) {
   );
 }
 var inputType = "";
-function setValueAndUpdateSelection(el, value2) {
-  if (el.value !== value2) {
+function setValueAndUpdateSelection(el, value) {
+  if (el.value !== value) {
     const updatedPosition = resolveCursorPosition(
       inputType,
       el.getRootNode().activeElement === el && el.selectionStart,
       el.value,
-      el.value = value2
+      el.value = value
     );
     if (~updatedPosition) {
       el.setSelectionRange(updatedPosition, updatedPosition);
@@ -847,11 +838,11 @@ function hasSelectChanged(el) {
 function hasFormElementChanged(el) {
   return el.options ? hasSelectChanged(el) : hasValueChanged(el) || hasCheckboxChanged(el);
 }
-function normalizeStrProp(value2) {
-  return normalizeAttrValue(value2) || "";
+function normalizeStrProp(value) {
+  return normalizeAttrValue(value) || "";
 }
-function normalizeBoolProp(value2) {
-  return value2 != null && value2 !== false;
+function normalizeBoolProp(value) {
+  return value != null && value !== false;
 }
 function updateList(arr, val, push) {
   const index = arr.indexOf(val);
@@ -863,9 +854,9 @@ function toValueProp(it) {
 
 // src/dom/parse-html.ts
 var parsers = {};
-function parseHTML(html2, ns) {
+function parseHTML(html, ns) {
   const parser = parsers[ns] ||= document.createElementNS(ns, "template");
-  parser.innerHTML = html2;
+  parser.innerHTML = html;
   return parser.content || parser;
 }
 
@@ -913,7 +904,7 @@ function triggerMacroTask() {
 }
 
 // src/dom/signals.ts
-function state(valueAccessor, fn) {
+function _let(valueAccessor, fn) {
   if (true) {
     var id = +valueAccessor.slice(
       valueAccessor.lastIndexOf("/") + 1
@@ -924,42 +915,42 @@ function state(valueAccessor, fn) {
     );
   }
   const valueChangeAccessor = "TagVariableChange:" /* TagVariableChange */ + valueAccessor;
-  const update = (scope, value2) => {
-    if (scope[valueAccessor] !== value2) {
-      scope[valueAccessor] = value2;
-      fn(scope, value2);
+  const update = (scope, value) => {
+    if (scope[valueAccessor] !== value) {
+      scope[valueAccessor] = value;
+      fn(scope, value);
     }
   };
-  return (scope, value2, valueChange) => {
+  return (scope, value, valueChange) => {
     if (rendering) {
-      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value2 || !(valueAccessor in scope)) {
-        scope[valueAccessor] = value2;
-        fn(scope, value2);
+      if ((scope[valueChangeAccessor] = valueChange) && scope[valueAccessor] !== value || !(valueAccessor in scope)) {
+        scope[valueAccessor] = value;
+        fn(scope, value);
       }
     } else if (scope[valueChangeAccessor]) {
-      scope[valueChangeAccessor](value2);
+      scope[valueChangeAccessor](value);
     } else {
       schedule();
       queueRender(
         scope,
         update,
         true ? id : valueAccessor,
-        value2
+        value
       );
     }
-    return value2;
+    return value;
   };
 }
-function value(valueAccessor, fn = () => {
+function _const(valueAccessor, fn = () => {
 }) {
-  return (scope, value2) => {
-    if (!(valueAccessor in scope) || scope[valueAccessor] !== value2) {
-      scope[valueAccessor] = value2;
-      fn(scope, value2);
+  return (scope, value) => {
+    if (!(valueAccessor in scope) || scope[valueAccessor] !== value) {
+      scope[valueAccessor] = value;
+      fn(scope, value);
     }
   };
 }
-function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "___id") {
+function _or(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__ */ "___id") {
   return (scope) => {
     if (scope.___creating) {
       if (scope[id] === void 0) {
@@ -972,7 +963,7 @@ function intersection(id, fn, defaultPending = 1, scopeIdAccessor = /* @__KEY__
     }
   };
 }
-function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
+function _for_closure(valueAccessor, ownerLoopNodeAccessor, fn) {
   const childSignal = closure(valueAccessor, fn);
   const loopScopeAccessor = "LoopScopeArray:" /* LoopScopeArray */ + ownerLoopNodeAccessor;
   const loopScopeMapAccessor = "LoopScopeMap:" /* LoopScopeMap */ + ownerLoopNodeAccessor;
@@ -998,7 +989,7 @@ function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn) {
   ownerSignal._ = childSignal;
   return ownerSignal;
 }
-function conditionalClosure(valueAccessor, ownerConditionalNodeAccessor, branch, fn) {
+function _if_closure(valueAccessor, ownerConditionalNodeAccessor, branch, fn) {
   const childSignal = closure(valueAccessor, fn);
   const scopeAccessor = "ConditionalScope:" /* ConditionalScope */ + ownerConditionalNodeAccessor;
   const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + ownerConditionalNodeAccessor;
@@ -1015,13 +1006,13 @@ function subscribeToScopeSet(ownerScope, accessor, scope) {
   const subscribers = ownerScope[accessor] ||= /* @__PURE__ */ new Set();
   if (!subscribers.has(scope)) {
     subscribers.add(scope);
-    getAbortSignal(scope, -1).addEventListener(
+    $signal(scope, -1).addEventListener(
       "abort",
       () => ownerScope[accessor].delete(scope)
     );
   }
 }
-function dynamicClosure(...closureSignals) {
+function _closure(...closureSignals) {
   const [{ ___scopeInstancesAccessor, ___signalIndexAccessor }] = closureSignals;
   for (let i = closureSignals.length; i--; ) {
     closureSignals[i].___index = i;
@@ -1040,7 +1031,7 @@ function dynamicClosure(...closureSignals) {
     }
   };
 }
-function dynamicClosureRead(valueAccessor, fn, getOwnerScope) {
+function _closure_get(valueAccessor, fn, getOwnerScope) {
   const childSignal = closure(valueAccessor, fn, getOwnerScope);
   const closureSignal = ((scope) => {
     scope[closureSignal.___signalIndexAccessor] = closureSignal.___index;
@@ -1063,22 +1054,22 @@ function closure(valueAccessor, fn, getOwnerScope) {
     );
   };
 }
-function setTagVar(scope, childAccessor, tagVarSignal2) {
-  scope[childAccessor]["#TagVariable" /* TagVariable */] = (value2) => tagVarSignal2(scope, value2);
+function _var(scope, childAccessor, signal) {
+  scope[childAccessor]["#TagVariable" /* TagVariable */] = (value) => signal(scope, value);
 }
-var tagVarSignal = (scope, value2) => scope["#TagVariable" /* TagVariable */]?.(value2);
-function setTagVarChange(scope, changeHandler) {
+var _return = (scope, value) => scope["#TagVariable" /* TagVariable */]?.(value);
+function _return_change(scope, changeHandler) {
   scope["#TagVariableChange" /* TagVariableChange */] = changeHandler;
 }
-var tagVarSignalChange = (scope, value2) => scope["#TagVariableChange" /* TagVariableChange */]?.(value2);
+var _var_change = (scope, value) => scope["#TagVariableChange" /* TagVariableChange */]?.(value);
 var tagIdsByGlobal = /* @__PURE__ */ new WeakMap();
-function nextTagId({ $global }) {
+function _id({ $global }) {
   const id = tagIdsByGlobal.get($global) || 0;
   tagIdsByGlobal.set($global, id + 1);
   return "c" + $global.runtimeId + $global.renderId + id.toString(36);
 }
-function effect(id, fn) {
-  register(id, fn);
+function _script(id, fn) {
+  _resume(id, fn);
   return (scope) => {
     queueEffect(scope, fn);
   };
@@ -1096,7 +1087,7 @@ function* traverseAllHoisted(scope, path, curIndex = path.length - 1) {
     }
   }
 }
-function hoist(...path) {
+function _hoist(...path) {
   return (scope) => {
     const getOne = (...args) => iterator().next().value(...args);
     const iterator = getOne[Symbol.iterator] = () => traverseAllHoisted(scope, path);
@@ -1135,7 +1126,7 @@ function setupBranch(renderer, branch) {
   }
   return branch;
 }
-function createContent(id, template, walks, setup, params, dynamicScopesAccessor) {
+function _content(id, template, walks, setup, params, dynamicScopesAccessor) {
   walks = walks ? walks.replace(/[^\0-1]+$/, "") : "";
   setup = setup ? setup._ || setup : void 0;
   params ||= void 0;
@@ -1162,16 +1153,16 @@ function createContent(id, template, walks, setup, params, dynamicScopesAccessor
     };
   };
 }
-function registerContent(id, template, walks, setup, params, dynamicScopesAccessor) {
-  return register(
+function _content_resume(id, template, walks, setup, params, dynamicScopesAccessor) {
+  return _resume(
     id,
-    createContent(id, template, walks, setup, params, dynamicScopesAccessor)
+    _content(id, template, walks, setup, params, dynamicScopesAccessor)
   );
 }
-function localClosures(renderer, closureFns) {
+function _content_closures(renderer, closureFns) {
   const closureSignals = {};
   for (const key in closureFns) {
-    closureSignals[key] = value(key, closureFns[key]);
+    closureSignals[key] = _const(key, closureFns[key]);
   }
   return (owner, closureValues) => {
     const instance = renderer(owner);
@@ -1180,12 +1171,12 @@ function localClosures(renderer, closureFns) {
     return instance;
   };
 }
-function createRenderer(template, walks, setup, params) {
-  return createContent("", template, walks, setup, params)();
+function _content_branch(template, walks, setup, params) {
+  return _content("", template, walks, setup, params)();
 }
 var cloneCache = {};
-function createCloneableHTML(html2, ns) {
-  const { firstChild, lastChild } = parseHTML(html2, ns);
+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) => {
@@ -1203,53 +1194,53 @@ function createCloneableHTML(html2, ns) {
 }
 
 // src/dom/dom.ts
-function attr(element, name, value2) {
-  setAttribute(element, name, normalizeAttrValue(value2));
+function _attr(element, name, value) {
+  setAttribute(element, name, normalizeAttrValue(value));
 }
-function setAttribute(element, name, value2) {
-  if (element.getAttribute(name) != value2) {
-    if (value2 === void 0) {
+function setAttribute(element, name, value) {
+  if (element.getAttribute(name) != value) {
+    if (value === void 0) {
       element.removeAttribute(name);
     } else {
-      element.setAttribute(name, value2);
+      element.setAttribute(name, value);
     }
   }
 }
-function classAttr(element, value2) {
-  setAttribute(element, "class", classValue(value2) || void 0);
+function _attr_class(element, value) {
+  setAttribute(element, "class", classValue(value) || void 0);
 }
-function classItems(element, items) {
+function _attr_class_items(element, items) {
   for (const key in items) {
-    classItem(element, key, items[key]);
+    _attr_class_item(element, key, items[key]);
   }
 }
-function classItem(element, name, value2) {
-  element.classList.toggle(name, !!value2);
+function _attr_class_item(element, name, value) {
+  element.classList.toggle(name, !!value);
 }
-function styleAttr(element, value2) {
-  setAttribute(element, "style", styleValue(value2) || void 0);
+function _attr_style(element, value) {
+  setAttribute(element, "style", styleValue(value) || void 0);
 }
-function styleItems(element, items) {
+function _attr_style_items(element, items) {
   for (const key in items) {
-    styleItem(element, key, items[key]);
+    _attr_style_item(element, key, items[key]);
   }
 }
-function styleItem(element, name, value2) {
-  element.style.setProperty(name, value2 || value2 === 0 ? value2 + "" : "");
+function _attr_style_item(element, name, value) {
+  element.style.setProperty(name, value || value === 0 ? value + "" : "");
 }
-function data(node, value2) {
-  const normalizedValue = normalizeString(value2);
+function _text(node, value) {
+  const normalizedValue = normalizeString(value);
   if (node.data !== normalizedValue) {
     node.data = normalizedValue;
   }
 }
-function textContent(node, value2) {
-  const normalizedValue = normalizeString(value2);
+function _text_content(node, value) {
+  const normalizedValue = normalizeString(value);
   if (node.textContent !== normalizedValue) {
     node.textContent = normalizedValue;
   }
 }
-function attrs(scope, nodeAccessor, nextAttrs) {
+function _attrs(scope, nodeAccessor, nextAttrs) {
   const el = scope[nodeAccessor];
   for (let i = el.attributes.length; i--; ) {
     const { name } = el.attributes.item(i);
@@ -1259,14 +1250,14 @@ function attrs(scope, nodeAccessor, nextAttrs) {
   }
   attrsInternal(scope, nodeAccessor, nextAttrs);
 }
-function attrsAndContent(scope, nodeAccessor, nextAttrs) {
-  attrs(scope, nodeAccessor, nextAttrs);
-  insertContent(scope, nodeAccessor, nextAttrs?.content);
+function _attrs_content(scope, nodeAccessor, nextAttrs) {
+  _attrs(scope, nodeAccessor, nextAttrs);
+  _attr_content(scope, nodeAccessor, nextAttrs?.content);
 }
-function hasAttrAlias(element, attr2, nextAttrs) {
-  return attr2 === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
+function hasAttrAlias(element, attr, nextAttrs) {
+  return attr === "checked" && element.tagName === "INPUT" && "checkedValue" in nextAttrs;
 }
-function partialAttrs(scope, nodeAccessor, nextAttrs, skip) {
+function _attrs_partial(scope, nodeAccessor, nextAttrs, skip) {
   const el = scope[nodeAccessor];
   const partial = {};
   for (let i = el.attributes.length; i--; ) {
@@ -1280,9 +1271,9 @@ function partialAttrs(scope, nodeAccessor, nextAttrs, skip) {
   }
   attrsInternal(scope, nodeAccessor, partial);
 }
-function partialAttrsAndContent(scope, nodeAccessor, nextAttrs, skip) {
-  partialAttrs(scope, nodeAccessor, nextAttrs, skip);
-  insertContent(scope, nodeAccessor, nextAttrs?.content);
+function _attrs_partial_content(scope, nodeAccessor, nextAttrs, skip) {
+  _attrs_partial(scope, nodeAccessor, nextAttrs, skip);
+  _attr_content(scope, nodeAccessor, nextAttrs?.content);
 }
 function attrsInternal(scope, nodeAccessor, nextAttrs) {
   const el = scope[nodeAccessor];
@@ -1291,14 +1282,14 @@ function attrsInternal(scope, nodeAccessor, nextAttrs) {
   switch (el.tagName) {
     case "INPUT":
       if ("checked" in nextAttrs || "checkedChange" in nextAttrs) {
-        controllable_input_checked(
+        _attr_input_checked(
           scope,
           nodeAccessor,
           nextAttrs.checked,
           nextAttrs.checkedChange
         );
       } else if ("checkedValue" in nextAttrs || "checkedValueChange" in nextAttrs) {
-        controllable_input_checkedValue(
+        _attr_input_checkedValue(
           scope,
           nodeAccessor,
           nextAttrs.checkedValue,
@@ -1306,7 +1297,7 @@ function attrsInternal(scope, nodeAccessor, nextAttrs) {
           nextAttrs.value
         );
       } else if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        controllable_input_value(
+        _attr_input_value(
           scope,
           nodeAccessor,
           nextAttrs.value,
@@ -1319,7 +1310,7 @@ function attrsInternal(scope, nodeAccessor, nextAttrs) {
       break;
     case "SELECT":
       if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        controllable_select_value(
+        _attr_select_value(
           scope,
           nodeAccessor,
           nextAttrs.value,
@@ -1330,7 +1321,7 @@ function attrsInternal(scope, nodeAccessor, nextAttrs) {
       break;
     case "TEXTAREA":
       if ("value" in nextAttrs || "valueChange" in nextAttrs) {
-        controllable_input_value(
+        _attr_input_value(
           scope,
           nodeAccessor,
           nextAttrs.value,
@@ -1342,7 +1333,7 @@ function attrsInternal(scope, nodeAccessor, nextAttrs) {
     case "DETAILS":
     case "DIALOG":
       if ("open" in nextAttrs || "openChange" in nextAttrs) {
-        controllable_detailsOrDialog_open(
+        _attr_details_or_dialog_open(
           scope,
           nodeAccessor,
           nextAttrs.open,
@@ -1353,27 +1344,27 @@ function attrsInternal(scope, nodeAccessor, nextAttrs) {
       break;
   }
   for (const name in nextAttrs) {
-    const value2 = nextAttrs[name];
+    const value = nextAttrs[name];
     switch (name) {
       case "class":
-        classAttr(el, value2);
+        _attr_class(el, value);
         break;
       case "style":
-        styleAttr(el, value2);
+        _attr_style(el, value);
         break;
       default: {
         if (isEventHandler(name)) {
-          (events ||= scope["EventAttributes:" /* EventAttributes */ + nodeAccessor] = {})[getEventHandlerName(name)] = value2;
+          (events ||= scope["EventAttributes:" /* EventAttributes */ + nodeAccessor] = {})[getEventHandlerName(name)] = value;
         } else if (!(skip?.test(name) || name === "content" && el.tagName !== "META")) {
-          attr(el, name, value2);
+          _attr(el, name, value);
         }
         break;
       }
     }
   }
 }
-function insertContent(scope, nodeAccessor, value2) {
-  const content = normalizeClientRender(value2);
+function _attr_content(scope, nodeAccessor, value) {
+  const content = normalizeClientRender(value);
   const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
   if (scope[rendererAccessor] !== (scope[rendererAccessor] = content?.___id)) {
     setConditionalRenderer(scope, nodeAccessor, content, createAndSetupBranch);
@@ -1386,36 +1377,36 @@ function insertContent(scope, nodeAccessor, value2) {
     }
   }
 }
-function attrsEvents(scope, nodeAccessor) {
+function _attrs_script(scope, nodeAccessor) {
   const el = scope[nodeAccessor];
   const events = scope["EventAttributes:" /* EventAttributes */ + nodeAccessor];
   switch (scope["ControlledType:" /* ControlledType */ + nodeAccessor]) {
     case 0 /* InputChecked */:
-      controllable_input_checked_effect(scope, nodeAccessor);
+      _attr_input_checked_script(scope, nodeAccessor);
       break;
     case 1 /* InputCheckedValue */:
-      controllable_input_checkedValue_effect(scope, nodeAccessor);
+      _attr_input_checkedValue_script(scope, nodeAccessor);
       break;
     case 2 /* InputValue */:
-      controllable_input_value_effect(scope, nodeAccessor);
+      _attr_input_value_script(scope, nodeAccessor);
       break;
     case 3 /* SelectValue */:
-      controllable_select_value_effect(scope, nodeAccessor);
+      _attr_select_value_script(scope, nodeAccessor);
       break;
     case 4 /* DetailsOrDialogOpen */:
-      controllable_detailsOrDialog_open_effect(scope, nodeAccessor);
+      _attr_details_or_dialog_open_script(scope, nodeAccessor);
       break;
   }
   for (const name in events) {
-    on(el, name, events[name]);
+    _on(el, name, events[name]);
   }
 }
-function html(scope, value2, accessor) {
+function _html(scope, value, accessor) {
   const firstChild = scope[accessor];
   const parentNode = firstChild.parentNode;
   const lastChild = scope["DynamicPlaceholderLastChild:" /* DynamicPlaceholderLastChild */ + accessor] || firstChild;
   const newContent = parseHTML(
-    value2 || value2 === 0 ? value2 + "" : "",
+    value || value === 0 ? value + "" : "",
     parentNode.namespaceURI
   );
   insertChildNodes(
@@ -1426,43 +1417,27 @@ function html(scope, value2, accessor) {
   );
   removeChildNodes(firstChild, lastChild);
 }
-function normalizeClientRender(value2) {
-  const renderer = normalizeDynamicRenderer(value2);
+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 value2}`
+        `Invalid \`content\` attribute. Received ${typeof value}`
       );
     }
   }
 }
-function props(scope, nodeIndex, index) {
-  const nextProps = scope[index];
-  const prevProps = scope[index + "-"];
-  const node = scope[nodeIndex];
-  if (prevProps) {
-    for (const name in prevProps) {
-      if (!(name in nextProps)) {
-        node[name] = void 0;
-      }
-    }
-  }
-  for (const name in nextProps) {
-    node[name] = nextProps[name];
+function normalizeAttrValue(value) {
+  if (value || value === 0) {
+    return value === true ? "" : value + "";
   }
-  scope[index + "-"] = nextProps;
 }
-function normalizeAttrValue(value2) {
-  if (value2 || value2 === 0) {
-    return value2 === true ? "" : value2 + "";
-  }
+function normalizeString(value) {
+  return value || value === 0 ? value + "" : "\u200D";
 }
-function normalizeString(value2) {
-  return value2 || value2 === 0 ? value2 + "" : "\u200D";
-}
-function lifecycle(scope, index, thisObj) {
+function _lifecycle(scope, index, thisObj) {
   const instance = scope[index];
   if (instance) {
     Object.assign(instance, thisObj);
@@ -1470,10 +1445,7 @@ function lifecycle(scope, index, thisObj) {
   } else {
     scope[index] = thisObj;
     thisObj.onMount?.();
-    getAbortSignal(
-      scope,
-      "LifecycleAbortController:" /* LifecycleAbortController */ + index
-    ).onabort = () => thisObj.onDestroy?.();
+    $signal(scope, "LifecycleAbortController:" /* LifecycleAbortController */ + index).onabort = () => thisObj.onDestroy?.();
   }
 }
 function removeChildNodes(startNode, endNode) {
@@ -1668,7 +1640,7 @@ function longestIncreasingSubsequence(a) {
 }
 
 // src/dom/control-flow.ts
-function awaitTag(nodeAccessor, renderer) {
+function _await(nodeAccessor, renderer) {
   const promiseAccessor = "Promise:" /* Promise */ + nodeAccessor;
   const branchAccessor = "ConditionalScope:" /* ConditionalScope */ + nodeAccessor;
   return (scope, promise) => {
@@ -1713,7 +1685,7 @@ function awaitTag(nodeAccessor, renderer) {
       tempDetachBranch(awaitBranch);
     }
     const thisPromise = scope[promiseAccessor] = promise.then(
-      (data2) => {
+      (data) => {
         if (thisPromise === scope[promiseAccessor]) {
           scope[promiseAccessor] = 0;
           schedule();
@@ -1739,7 +1711,7 @@ function awaitTag(nodeAccessor, renderer) {
                 );
                 referenceNode.remove();
               }
-              renderer.___params?.(awaitBranch, [data2]);
+              renderer.___params?.(awaitBranch, [data]);
               if (tryWithPlaceholder) {
                 placeholderShown.add(pendingEffects);
                 if (!--tryWithPlaceholder.___pendingAsyncCount) {
@@ -1773,14 +1745,14 @@ function awaitTag(nodeAccessor, renderer) {
     );
   };
 }
-function createTry(nodeAccessor, tryContent) {
+function _try(nodeAccessor, content) {
   const branchAccessor = "ConditionalScope:" /* ConditionalScope */ + nodeAccessor;
   return (scope, input) => {
     if (!scope[branchAccessor]) {
       setConditionalRenderer(
         scope,
         nodeAccessor,
-        tryContent,
+        content,
         createAndSetupBranch
       );
     }
@@ -1819,7 +1791,7 @@ function renderCatch(scope, error) {
     );
   }
 }
-function conditional(nodeAccessor, ...branches) {
+function _if(nodeAccessor, ...branches) {
   const branchAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
   enableBranches();
   return (scope, newBranch) => {
@@ -1834,9 +1806,9 @@ function conditional(nodeAccessor, ...branches) {
   };
 }
 function patchDynamicTag(fn) {
-  dynamicTag = fn(dynamicTag);
+  _dynamic_tag = fn(_dynamic_tag);
 }
-var dynamicTag = function dynamicTag2(nodeAccessor, getContent, getTagVar, inputIsArgs) {
+var _dynamic_tag = function dynamicTag(nodeAccessor, getContent, getTagVar, inputIsArgs) {
   const childScopeAccessor = "ConditionalScope:" /* ConditionalScope */ + nodeAccessor;
   const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
   enableBranches();
@@ -1850,7 +1822,7 @@ var dynamicTag = function dynamicTag2(nodeAccessor, getContent, getTagVar, input
         createBranchWithTagNameOrRenderer
       );
       if (getTagVar) {
-        setTagVar(scope, childScopeAccessor, getTagVar());
+        _var(scope, childScopeAccessor, getTagVar());
       }
       if (typeof normalizedRenderer === "string") {
         if (getContent) {
@@ -1881,7 +1853,7 @@ var dynamicTag = function dynamicTag2(nodeAccessor, getContent, getTagVar, input
       const childScope = scope[childScopeAccessor];
       const args = getInput?.();
       if (typeof normalizedRenderer === "string") {
-        (getContent ? attrs : attrsAndContent)(
+        (getContent ? _attrs : _attrs_content)(
           childScope,
           true ? `#${normalizedRenderer}/0` : 0,
           (inputIsArgs ? args[0] : args) || {}
@@ -1936,7 +1908,7 @@ function setConditionalRenderer(scope, nodeAccessor, newRenderer, createBranch2)
     referenceNode.remove();
   }
 }
-function loopOf(nodeAccessor, renderer) {
+function _for_of(nodeAccessor, renderer) {
   return loop(
     nodeAccessor,
     renderer,
@@ -1952,14 +1924,14 @@ function loopOf(nodeAccessor, renderer) {
     }
   );
 }
-function loopIn(nodeAccessor, renderer) {
+function _for_in(nodeAccessor, renderer) {
   return loop(
     nodeAccessor,
     renderer,
-    ([obj, by = byFirstArg], cb) => forIn(obj, (key, value2) => cb(by(key, value2), [key, value2]))
+    ([obj, by = byFirstArg], cb) => forIn(obj, (key, value) => cb(by(key, value), [key, value]))
   );
 }
-function loopTo(nodeAccessor, renderer) {
+function _for_to(nodeAccessor, renderer) {
   return loop(
     nodeAccessor,
     renderer,
@@ -1969,7 +1941,7 @@ function loopTo(nodeAccessor, renderer) {
 function loop(nodeAccessor, renderer, forEach) {
   const params = renderer.___params;
   enableBranches();
-  return (scope, value2) => {
+  return (scope, value) => {
     const referenceNode = scope[nodeAccessor];
     const oldMap = scope["LoopScopeMap:" /* LoopScopeMap */ + nodeAccessor];
     const oldArray = oldMap ? scope["LoopScopeArray:" /* LoopScopeArray */ + nodeAccessor] || [
@@ -1978,7 +1950,7 @@ function loop(nodeAccessor, renderer, forEach) {
     const parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldArray[0].___startNode.parentNode : referenceNode;
     const newMap = scope["LoopScopeMap:" /* LoopScopeMap */ + nodeAccessor] = /* @__PURE__ */ new Map();
     const newArray = scope["LoopScopeArray:" /* LoopScopeArray */ + nodeAccessor] = [];
-    forEach(value2, (key, args) => {
+    forEach(value, (key, args) => {
       const branch = oldMap?.get(key) || createAndSetupBranch(scope.$global, renderer, scope, parentNode);
       params?.(branch, args);
       newMap.set(key, branch);
@@ -2032,17 +2004,17 @@ var pendingEffects = [];
 var pendingScopes = [];
 var rendering;
 var scopeKeyOffset = 1e3;
-function queueRender(scope, signal, signalKey, value2, scopeKey = scope.___id) {
+function queueRender(scope, signal, signalKey, value, scopeKey = scope.___id) {
   const key = scopeKey * scopeKeyOffset + signalKey;
   const existingRender = signalKey >= 0 && pendingRendersLookup.get(key);
   if (existingRender) {
-    existingRender.___value = value2;
+    existingRender.___value = value;
   } else {
     const render = {
       ___key: key,
       ___scope: scope,
       ___signal: signal,
-      ___value: value2
+      ___value: value
     };
     let i = pendingRenders.push(render) - 1;
     while (i) {
@@ -2132,8 +2104,8 @@ function runRenders() {
   pendingScopes = [];
 }
 var runRender = (render) => render.___signal(render.___scope, render.___value);
-var enableCatch = () => {
-  enableCatch = () => {
+var _enable_catch = () => {
+  _enable_catch = () => {
   };
   enableBranches();
   const handlePendingTry = (fn, scope, branch) => {
@@ -2172,14 +2144,14 @@ var enableCatch = () => {
 };
 
 // src/dom/abort-signal.ts
-function resetAbortSignal(scope, id) {
+function $signalReset(scope, id) {
   const ctrl = scope.___abortControllers?.[id];
   if (ctrl) {
     queueEffect(ctrl, abort);
     scope.___abortControllers[id] = void 0;
   }
 }
-function getAbortSignal(scope, id) {
+function $signal(scope, id) {
   if (scope.___closestBranch) {
     (scope.___closestBranch.___abortScopes ||= /* @__PURE__ */ new Set()).add(scope);
   }
@@ -2201,13 +2173,13 @@ var compat = {
   patchDynamicTag,
   queueEffect,
   init(warp10Noop) {
-    register(SET_SCOPE_REGISTER_ID, (branch) => {
+    _resume(SET_SCOPE_REGISTER_ID, (branch) => {
       classIdToBranch.set(branch.m5c, branch);
     });
-    register(RENDER_BODY_ID, warp10Noop);
+    _resume(RENDER_BODY_ID, warp10Noop);
   },
   registerRenderer(fn) {
-    register(RENDERER_REGISTER_ID, fn);
+    _resume(RENDERER_REGISTER_ID, fn);
   },
   isRenderer(renderer) {
     return renderer.___clone;
@@ -2229,17 +2201,17 @@ var compat = {
       destroyBranch(this.scope);
     }
   },
-  resolveRegistered(value2, $global) {
-    if (Array.isArray(value2) && typeof value2[0] === "string") {
+  resolveRegistered(value, $global) {
+    if (Array.isArray(value) && typeof value[0] === "string") {
       return getRegisteredWithScope(
-        value2[0],
-        value2.length === 2 && self[$global.runtimeId]?.[$global.renderId]?.s[value2[1]]
+        value[0],
+        value.length === 2 && self[$global.runtimeId]?.[$global.renderId]?.s[value[1]]
       );
     }
-    return value2;
+    return value;
   },
   createRenderer(params, clone) {
-    const renderer = createRenderer(0, 0, 0, params);
+    const renderer = _content_branch(0, 0, 0, params);
     renderer.___clone = (branch) => {
       const cloned = clone();
       branch.___startNode = cloned.startNode;
@@ -2281,8 +2253,8 @@ var compat = {
 };
 
 // src/dom/template.ts
-var createTemplate = (id, template, walks, setup, inputSignal) => {
-  const renderer = createContent(
+var _template = (id, template, walks, setup, inputSignal) => {
+  const renderer = _content(
     id,
     template,
     walks,
@@ -2298,7 +2270,7 @@ var createTemplate = (id, template, walks, setup, inputSignal) => {
       );
     };
   }
-  return register(id, renderer);
+  return _resume(id, renderer);
 };
 function mount(input = {}, reference, position) {
   let branch;
@@ -2372,7 +2344,7 @@ function mount(input = {}, reference, position) {
       return curValue;
     },
     set value(newValue) {
-      tagVarSignalChange(branch, newValue);
+      _var_change(branch, newValue);
     },
     update(newInput) {
       if (args) {