marko 5.37.2 → 6.0.0-3.5

package/dist/debug/html.mjs

@@ -0,0 +1,2663 @@
+// 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 attrTags(first, attrs2) {
+  if (first) {
+    if (first[rest] === empty) {
+      first[rest] = [attrs2];
+    } else {
+      first[rest].push(attrs2);
+    }
+    return first;
+  }
+  return attrTag(attrs2);
+}
+function* attrTagIterator() {
+  yield this;
+  yield* this[rest];
+}
+
+// src/common/helpers.ts
+function classValue(value) {
+  return toDelimitedString(value, " ", stringifyClassObject);
+}
+function stringifyClassObject(name, value) {
+  return value ? name : "";
+}
+function styleValue(value) {
+  return toDelimitedString(value, ";", stringifyStyleObject);
+}
+var NON_DIMENSIONAL = /^(--|ta|or|li|z)|n-c|i(do|nk|m|t)|w$|we/;
+function stringifyStyleObject(name, value) {
+  return value || value === 0 ? `${name}:${typeof value === "number" && value && !NON_DIMENSIONAL.test(name) ? value + "px" : value}` : "";
+}
+function toDelimitedString(val, delimiter, stringify) {
+  switch (typeof val) {
+    case "string":
+      return val;
+    case "object":
+      if (val !== null) {
+        let result = "";
+        let curDelimiter = "";
+        if (Array.isArray(val)) {
+          for (const v of val) {
+            const part = toDelimitedString(v, delimiter, stringify);
+            if (part !== "") {
+              result += curDelimiter + part;
+              curDelimiter = delimiter;
+            }
+          }
+        } else {
+          for (const name in val) {
+            const v = val[name];
+            const part = stringify(name, v);
+            if (part !== "") {
+              result += curDelimiter + part;
+              curDelimiter = delimiter;
+            }
+          }
+        }
+        return result;
+      }
+  }
+  return "";
+}
+function isEventHandler(name) {
+  return /^on[A-Z-]/.test(name);
+}
+function getEventHandlerName(name) {
+  return name[2] === "-" ? name.slice(3) : name.slice(2).toLowerCase();
+}
+function isVoid(value) {
+  return value == null || value === false;
+}
+function normalizeDynamicRenderer(value) {
+  if (value) return value.renderBody || value.default || value;
+}
+
+// src/html/content.ts
+function toString(val) {
+  return val ? val + "" : val === 0 ? "0" : "";
+}
+var unsafeXMLReg = /[<&]/g;
+var replaceUnsafeXML = (c) => c === "&" ? "&amp;" : "&lt;";
+var escapeXMLStr = (str) => unsafeXMLReg.test(str) ? str.replace(unsafeXMLReg, replaceUnsafeXML) : str;
+function escapeXML(val) {
+  return val ? escapeXMLStr(val + "") : val === 0 ? "0" : "&zwj;";
+}
+function escapeTextAreaValue(val) {
+  return val ? escapeXMLStr(val + "") : val === 0 ? "0" : "";
+}
+var unsafeScriptReg = /<\/script/g;
+var escapeScriptStr = (str) => unsafeScriptReg.test(str) ? str.replace(unsafeScriptReg, "\\x3C/script") : str;
+function escapeScript(val) {
+  return val ? escapeScriptStr(val + "") : val === 0 ? "0" : "";
+}
+var unsafeStyleReg = /<\/style/g;
+var escapeStyleStr = (str) => unsafeStyleReg.test(str) ? str.replace(unsafeStyleReg, "\\3C/style") : str;
+function escapeStyle(val) {
+  return val ? escapeStyleStr(val + "") : val === 0 ? "0" : "";
+}
+
+// src/html/inlined-runtimes.ts
+var WALKER_RUNTIME_CODE = true ? `((runtimeId) =>
+(self[runtimeId] =
+  self[runtimeId] ||
+  ((renderId) => {
+    let id,
+      markers = {},
+      visits = [],
+      doc = document,
+      walker = doc.createTreeWalker(
+        doc,
+        129,
+      ) /* NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_ELEMENT */,
+      op = (self[runtimeId][renderId] = {
+        i: (renderId = runtimeId + renderId),
+        d: doc,
+        l: markers,
+        v: visits,
+        x() {},
+        w(node) {
+          while ((node = walker.nextNode())) {
+            this.x(
+              (op =
+                (op = node.data) &&
+                !op.indexOf(renderId) &&
+                ((markers[(id = op.slice(prefix + 1))] = node), op[prefix])),
+              id,
+              node,
+            );
+
+            if (op > "#") {
+              visits.push(node);
+            }
+          }
+        },
+      }),
+      prefix = renderId.length;
+  })))` : `(e=>self[e]=self[e]||(l=>{let t,d={},f=[],s=document,a=s.createTreeWalker(s,129),r=self[e][l]={i:l=e+l,d:s,l:d,v:f,x(){},w(e){for(;e=a.nextNode();)this.x(r=(r=e.data)&&!r.indexOf(l)&&(d[t=r.slice(x+1)]=e,r[x]),t,e),r>"#"&&f.push(e)}},x=l.length}))`;
+var REORDER_RUNTIME_CODE = true ? `((runtime) => {
+let insertOne,
+  placeholder,
+  nextSibling,
+  previousSibling,
+  placeholders = {},
+  replace = (marker, container) => {
+    marker.replaceWith(...container.childNodes);
+    container.remove();
+  };
+runtime.d.head.append(
+  runtime.d.querySelector("style[" + runtime.i + "]") || "",
+);
+runtime.j = {};
+runtime.x = (op, id, node, start, placeholderCallback) => {
+  // "node" and "end" are all closed over and can't be repurposed. "start" is too but only in the new placeholder case
+
+  if (op == "#") {
+    (placeholders[id] = placeholder).i++;
+  } else if (node == nextSibling) {
+    insertOne();
+  }
+
+  if (node.tagName == "T" && (id = node.getAttribute(runtime.i))) {
+    start = runtime.l["^" + id];
+
+    if (start) {
+      placeholder = placeholders[id] = {
+        i: 0,
+        c(end = runtime.l[id] || previousSibling || node) {
+          while (end.parentNode !== start.parentNode) {
+            end = end.parentNode;
+          }
+
+          for (
+            ;
+            end != nextSibling;
+            (nextSibling = start.nextSibling).remove()
+          );
+          replace(start, node);
+        },
+      };
+    } else {
+      insertOne = () => {
+        previousSibling = node.previousSibling;
+        replace(runtime.l[id], node);
+        if (!--start.i) {
+          start.c();
+        }
+      };
+
+      // repurpose "start" to hold this placeholder
+      start = placeholder = placeholders[id];
+      nextSibling = node.nextElementSibling || insertOne();
+    }
+
+    // repurpose "op" for callbacks ...carefully
+    placeholderCallback = placeholder.c;
+    (op = runtime.j[id]) &&
+      (placeholder.c = () => placeholderCallback() + op(runtime));
+
+    if (node.attributes.c) placeholder.c();
+  }
+};
+})` : `(e=>{let i,t,r,l,d={},n=(e,i)=>{e.replaceWith(...i.childNodes),i.remove()};e.d.head.append(e.d.querySelector("style["+e.i+"]")||""),e.j={},e.x=(o,a,c,p,b)=>{"#"==o?(d[a]=t).i++:c==r&&i(),"T"==c.tagName&&(a=c.getAttribute(e.i))&&((p=e.l["^"+a])?t=d[a]={i:0,c(i=e.l[a]||l||c){for(;i.parentNode!==p.parentNode;)i=i.parentNode;for(;i!=r;(r=p.nextSibling).remove());n(p,c)}}:(i=()=>{l=c.previousSibling,n(e.l[a],c),--p.i||p.c()},p=t=d[a],r=c.nextElementSibling||i()),b=t.c,(o=e.j[a])&&(t.c=()=>b()+o(e)),c.attributes.c&&t.c())}})`;
+
+// src/html/serializer.ts
+var { hasOwnProperty } = {};
+var Generator = function* () {
+}().constructor;
+var AsyncGenerator = async function* () {
+}().constructor;
+var REGISTRY = /* @__PURE__ */ new WeakMap();
+var KNOWN_SYMBOLS = (() => {
+  const KNOWN_SYMBOLS2 = /* @__PURE__ */ new Map();
+  for (const name of Object.getOwnPropertyNames(Symbol)) {
+    const symbol = Symbol[name];
+    if (typeof symbol === "symbol") {
+      KNOWN_SYMBOLS2.set(symbol, "Symbol." + name);
+    }
+  }
+  return KNOWN_SYMBOLS2;
+})();
+var KNOWN_FUNCTIONS = /* @__PURE__ */ new Map([
+  // This is by no means an exhaustive list,
+  // but it should cover most of the built-in functions.
+  [AggregateError, "AggregateError"],
+  [Array, "Array"],
+  [Array.from, "Array.from"],
+  [Array.isArray, "Array.isArray"],
+  [Array.of, "Array.of"],
+  [ArrayBuffer, "ArrayBuffer"],
+  [ArrayBuffer.isView, "ArrayBuffer.isView"],
+  [Atomics.add, "Atomics.add"],
+  [Atomics.and, "Atomics.and"],
+  [Atomics.compareExchange, "Atomics.compareExchange"],
+  [Atomics.exchange, "Atomics.exchange"],
+  [Atomics.isLockFree, "Atomics.isLockFree"],
+  [Atomics.load, "Atomics.load"],
+  [Atomics.notify, "Atomics.notify"],
+  [Atomics.or, "Atomics.or"],
+  [Atomics.store, "Atomics.store"],
+  [Atomics.sub, "Atomics.sub"],
+  [Atomics.wait, "Atomics.wait"],
+  [BigInt, "BigInt"],
+  [BigInt.asIntN, "BigInt.asIntN"],
+  [BigInt.asUintN, "BigInt.asUintN"],
+  [BigInt64Array, "BigInt64Array"],
+  [BigInt64Array.from, "BigInt64Array.from"],
+  [BigInt64Array.of, "BigInt64Array.of"],
+  [BigUint64Array, "BigUint64Array"],
+  [BigUint64Array.from, "BigUint64Array.from"],
+  [BigUint64Array.of, "BigUint64Array.of"],
+  [Boolean, "Boolean"],
+  [console.assert, "console.assert"],
+  [console.clear, "console.clear"],
+  [console.count, "console.count"],
+  [console.countReset, "console.countReset"],
+  [console.debug, "console.debug"],
+  [console.dir, "console.dir"],
+  [console.dirxml, "console.dirxml"],
+  [console.error, "console.error"],
+  [console.group, "console.group"],
+  [console.groupCollapsed, "console.groupCollapsed"],
+  [console.groupEnd, "console.groupEnd"],
+  [console.info, "console.info"],
+  [console.log, "console.log"],
+  [console.table, "console.table"],
+  [console.time, "console.time"],
+  [console.timeEnd, "console.timeEnd"],
+  [console.timeLog, "console.timeLog"],
+  [console.timeStamp, "console.timeStamp"],
+  [console.trace, "console.trace"],
+  [console.warn, "console.warn"],
+  [DataView, "DataView"],
+  [Date, "Date"],
+  [Date.now, "Date.now"],
+  [Date.parse, "Date.parse"],
+  [Date.UTC, "Date.UTC"],
+  [decodeURI, "decodeURI"],
+  [decodeURIComponent, "decodeURIComponent"],
+  [encodeURI, "encodeURI"],
+  [encodeURIComponent, "encodeURIComponent"],
+  [Error, "Error"],
+  [EvalError, "EvalError"],
+  [Float32Array, "Float32Array"],
+  [Float32Array.from, "Float32Array.from"],
+  [Float32Array.of, "Float32Array.of"],
+  [Float64Array, "Float64Array"],
+  [Float64Array.from, "Float64Array.from"],
+  [Float64Array.of, "Float64Array.of"],
+  [Function, "Function"],
+  [globalThis.atob, "atob"],
+  [globalThis.btoa, "btoa"],
+  [globalThis.clearImmediate, "clearImmediate"],
+  [globalThis.clearInterval, "clearInterval"],
+  [globalThis.clearTimeout, "clearTimeout"],
+  [globalThis.crypto?.getRandomValues, "crypto.getRandomValues"],
+  [globalThis.crypto?.randomUUID, "crypto.randomUUID"],
+  [globalThis.fetch, "fetch"],
+  [globalThis.performance?.now, "performance.now"],
+  [globalThis.queueMicrotask, "queueMicrotask"],
+  [globalThis.setImmediate, "setImmediate"],
+  [globalThis.setInterval, "setInterval"],
+  [globalThis.setTimeout, "setTimeout"],
+  [globalThis.structuredClone, "structuredClone"],
+  [globalThis.URL, "URL"],
+  [globalThis.URLSearchParams, "URLSearchParams"],
+  [globalThis.WritableStream, "WritableStream"],
+  [Int16Array, "Int16Array"],
+  [Int16Array.from, "Int16Array.from"],
+  [Int16Array.of, "Int16Array.of"],
+  [Int32Array, "Int32Array"],
+  [Int32Array.from, "Int32Array.from"],
+  [Int32Array.of, "Int32Array.of"],
+  [Int8Array, "Int8Array"],
+  [Int8Array.from, "Int8Array.from"],
+  [Int8Array.of, "Int8Array.of"],
+  [Intl.Collator, "Intl.Collator"],
+  [Intl.DateTimeFormat, "Intl.DateTimeFormat"],
+  [Intl.DisplayNames, "Intl.DisplayNames"],
+  [Intl.getCanonicalLocales, "Intl.getCanonicalLocales"],
+  [Intl.ListFormat, "Intl.ListFormat"],
+  [Intl.Locale, "Intl.Locale"],
+  [Intl.NumberFormat, "Intl.NumberFormat"],
+  [Intl.PluralRules, "Intl.PluralRules"],
+  [Intl.RelativeTimeFormat, "Intl.RelativeTimeFormat"],
+  [Intl.Segmenter, "Intl.Segmenter"],
+  [Intl.supportedValuesOf, "Intl.supportedValuesOf"],
+  [isFinite, "isFinite"],
+  [isNaN, "isNaN"],
+  [JSON.parse, "JSON.parse"],
+  [JSON.stringify, "JSON.stringify"],
+  [Map, "Map"],
+  [Map.groupBy, "Map.groupBy"],
+  [Math.abs, "Math.abs"],
+  [Math.acos, "Math.acos"],
+  [Math.acosh, "Math.acosh"],
+  [Math.asin, "Math.asin"],
+  [Math.asinh, "Math.asinh"],
+  [Math.atan, "Math.atan"],
+  [Math.atan2, "Math.atan2"],
+  [Math.atanh, "Math.atanh"],
+  [Math.cbrt, "Math.cbrt"],
+  [Math.ceil, "Math.ceil"],
+  [Math.clz32, "Math.clz32"],
+  [Math.cos, "Math.cos"],
+  [Math.cosh, "Math.cosh"],
+  [Math.exp, "Math.exp"],
+  [Math.expm1, "Math.expm1"],
+  [Math.floor, "Math.floor"],
+  [Math.fround, "Math.fround"],
+  [Math.hypot, "Math.hypot"],
+  [Math.imul, "Math.imul"],
+  [Math.log, "Math.log"],
+  [Math.log10, "Math.log10"],
+  [Math.log1p, "Math.log1p"],
+  [Math.log2, "Math.log2"],
+  [Math.max, "Math.max"],
+  [Math.min, "Math.min"],
+  [Math.pow, "Math.pow"],
+  [Math.random, "Math.random"],
+  [Math.round, "Math.round"],
+  [Math.sign, "Math.sign"],
+  [Math.sin, "Math.sin"],
+  [Math.sinh, "Math.sinh"],
+  [Math.sqrt, "Math.sqrt"],
+  [Math.tan, "Math.tan"],
+  [Math.tanh, "Math.tanh"],
+  [Math.trunc, "Math.trunc"],
+  [Number, "Number"],
+  [Number.isFinite, "Number.isFinite"],
+  [Number.isInteger, "Number.isInteger"],
+  [Number.isNaN, "Number.isNaN"],
+  [Number.isSafeInteger, "Number.isSafeInteger"],
+  [Number.parseFloat, "Number.parseFloat"],
+  [Number.parseInt, "Number.parseInt"],
+  [Object, "Object"],
+  [Object.assign, "Object.assign"],
+  [Object.create, "Object.create"],
+  [Object.defineProperties, "Object.defineProperties"],
+  [Object.defineProperty, "Object.defineProperty"],
+  [Object.entries, "Object.entries"],
+  [Object.freeze, "Object.freeze"],
+  [Object.fromEntries, "Object.fromEntries"],
+  [Object.getOwnPropertyDescriptor, "Object.getOwnPropertyDescriptor"],
+  [Object.getOwnPropertyDescriptors, "Object.getOwnPropertyDescriptors"],
+  [Object.getOwnPropertyNames, "Object.getOwnPropertyNames"],
+  [Object.getOwnPropertySymbols, "Object.getOwnPropertySymbols"],
+  [Object.getPrototypeOf, "Object.getPrototypeOf"],
+  [Object.is, "Object.is"],
+  [Object.isExtensible, "Object.isExtensible"],
+  [Object.isFrozen, "Object.isFrozen"],
+  [Object.isSealed, "Object.isSealed"],
+  [Object.keys, "Object.keys"],
+  [Object.preventExtensions, "Object.preventExtensions"],
+  [Object.seal, "Object.seal"],
+  [Object.setPrototypeOf, "Object.setPrototypeOf"],
+  [Object.values, "Object.values"],
+  [parseFloat, "parseFloat"],
+  [parseInt, "parseInt"],
+  [Promise, "Promise"],
+  [Proxy, "Proxy"],
+  [RangeError, "RangeError"],
+  [ReferenceError, "ReferenceError"],
+  [Reflect.apply, "Reflect.apply"],
+  [Reflect.construct, "Reflect.construct"],
+  [Reflect.defineProperty, "Reflect.defineProperty"],
+  [Reflect.deleteProperty, "Reflect.deleteProperty"],
+  [Reflect.get, "Reflect.get"],
+  [Reflect.getOwnPropertyDescriptor, "Reflect.getOwnPropertyDescriptor"],
+  [Reflect.getPrototypeOf, "Reflect.getPrototypeOf"],
+  [Reflect.has, "Reflect.has"],
+  [Reflect.isExtensible, "Reflect.isExtensible"],
+  [Reflect.ownKeys, "Reflect.ownKeys"],
+  [Reflect.preventExtensions, "Reflect.preventExtensions"],
+  [Reflect.set, "Reflect.set"],
+  [Reflect.setPrototypeOf, "Reflect.setPrototypeOf"],
+  [RegExp, "RegExp"],
+  [Set, "Set"],
+  [String, "String"],
+  [String.fromCharCode, "String.fromCharCode"],
+  [String.fromCodePoint, "String.fromCodePoint"],
+  [String.raw, "String.raw"],
+  [Symbol, "Symbol"],
+  [Symbol.for, "Symbol.for"],
+  [SyntaxError, "SyntaxError"],
+  [TypeError, "TypeError"],
+  [Uint16Array, "Uint16Array"],
+  [Uint16Array.from, "Uint16Array.from"],
+  [Uint16Array.of, "Uint16Array.of"],
+  [Uint32Array, "Uint32Array"],
+  [Uint32Array.from, "Uint32Array.from"],
+  [Uint32Array.of, "Uint32Array.of"],
+  [Uint8Array, "Uint8Array"],
+  [Uint8Array.from, "Uint8Array.from"],
+  [Uint8Array.of, "Uint8Array.of"],
+  [Uint8ClampedArray, "Uint8ClampedArray"],
+  [Uint8ClampedArray.from, "Uint8ClampedArray.from"],
+  [Uint8ClampedArray.of, "Uint8ClampedArray.of"],
+  [URIError, "URIError"],
+  [WeakMap, "WeakMap"],
+  [WeakSet, "WeakSet"]
+]);
+var KNOWN_OBJECTS = /* @__PURE__ */ new Map([
+  [Atomics, "Atomics"],
+  [console, "console"],
+  [globalThis, "globalThis"],
+  [globalThis.crypto, "crypto"],
+  [Intl, "Intl"],
+  [JSON, "JSON"],
+  [Math, "Math"],
+  [Reflect, "Reflect"]
+]);
+var State = class {
+  ids = 0;
+  flush = 0;
+  flushed = false;
+  buf = [];
+  refs = /* @__PURE__ */ new WeakMap();
+  assigned = /* @__PURE__ */ new Set();
+  boundary = void 0;
+};
+var Reference = class {
+  constructor(parent, accessor, flush, pos = null, id = null) {
+    this.parent = parent;
+    this.accessor = accessor;
+    this.flush = flush;
+    this.pos = pos;
+    this.id = id;
+    this.parent = parent;
+    this.accessor = accessor;
+    this.flush = flush;
+    this.pos = pos;
+    this.id = id;
+  }
+  init = "";
+  assigns = "";
+};
+var Serializer = class {
+  #state = new State();
+  get flushed() {
+    return this.#state.flushed;
+  }
+  stringify(val, boundary) {
+    try {
+      this.#state.flushed = false;
+      this.#state.boundary = boundary;
+      return writeRoot(this.#state, val);
+    } finally {
+      this.#flush();
+    }
+  }
+  nextId() {
+    return nextId(this.#state);
+  }
+  symbol(id) {
+    const symbol = Symbol();
+    this.#state.refs.set(symbol, new Reference(null, null, 0, null, id));
+    return symbol;
+  }
+  #flush() {
+    this.#state.flush++;
+    this.#state.buf = [];
+    this.#state.assigned = /* @__PURE__ */ new Set();
+  }
+};
+function register(id, val, scope) {
+  REGISTRY.set(val, { id, scope, access: "_._" + toAccess(toObjectKey(id)) });
+  return val;
+}
+function getRegistered(val) {
+  const registered = REGISTRY.get(val);
+  if (registered) {
+    return {
+      id: registered.id,
+      scope: registered.scope
+    };
+  }
+}
+function writeRoot(state, root) {
+  const { buf, assigned } = state;
+  const hadBuf = buf.length !== 0;
+  let result = "";
+  if (hadBuf) {
+    buf.push(",");
+  }
+  if (writeProp(state, root, null, "")) {
+    const rootRef = state.refs.get(root);
+    if (rootRef) {
+      ensureId(state, rootRef);
+    }
+    if (assigned.size) {
+      if (assigned.delete(rootRef)) {
+        assigned.add(rootRef);
+        writeAssigned(state);
+      } else {
+        writeAssigned(state);
+        buf.push("," + rootRef.id);
+      }
+    }
+    result = "(";
+    buf.push(")");
+  } else {
+    if (hadBuf) {
+      buf.pop();
+      writeAssigned(state);
+    }
+    result = "{";
+    buf.push("}");
+  }
+  for (const chunk of buf) {
+    result += chunk;
+  }
+  return "_=>" + result;
+}
+function writeAssigned(state) {
+  for (const valueRef of state.assigned) {
+    state.buf.push("," + valueRef.assigns + (valueRef.init || valueRef.id));
+    valueRef.init = "";
+  }
+}
+function writeProp(state, val, parent, accessor) {
+  switch (typeof val) {
+    case "string":
+      return writeString(state, val);
+    case "number":
+      return writeNumber(state, val);
+    case "boolean":
+      return writeBoolean(state, val);
+    case "bigint":
+      return writeBigInt(state, val);
+    case "symbol":
+      return writeSymbol(state, val, parent, accessor);
+    case "function":
+      return writeFunction(state, val, parent, accessor);
+    case "object":
+      return writeObject(state, val, parent, accessor);
+    default:
+      return false;
+  }
+}
+function writeReferenceOr(state, write2, val, parent, accessor) {
+  let ref = state.refs.get(val);
+  if (ref) {
+    if (ref.init) {
+      ref.assigns += ensureId(state, parent) + toAccess(accessor) + "=";
+      return false;
+    }
+    if (isCircular(parent, ref)) {
+      if (!ref.assigns) {
+        ensureId(state, ref);
+        state.assigned.add(ref);
+      }
+      ref.assigns += ensureId(state, parent) + toAccess(accessor) + "=";
+      return false;
+    }
+    state.buf.push(ensureId(state, ref));
+    return true;
+  }
+  const registered = REGISTRY.get(val);
+  if (registered)
+    return writeRegistered(state, val, parent, accessor, registered);
+  state.refs.set(
+    val,
+    ref = new Reference(parent, accessor, state.flush, state.buf.length)
+  );
+  if (write2(state, val, ref)) return true;
+  state.refs.delete(ref);
+  return false;
+}
+function writeRegistered(state, val, parent, accessor, { access, scope }) {
+  if (scope) {
+    const scopeRef = state.refs.get(scope);
+    const fnRef = new Reference(
+      parent,
+      accessor,
+      state.flush,
+      state.buf.length
+    );
+    state.refs.set(val, fnRef);
+    if (scopeRef) {
+      const scopeId = ensureId(state, scopeRef);
+      if (isCircular(parent, scopeRef)) {
+        state.assigned.add(fnRef);
+        fnRef.init = access + "(" + scopeId + ")";
+        fnRef.assigns += ensureId(state, parent) + toAccess(accessor) + "=";
+        return false;
+      }
+      state.buf.push(access + "(" + scopeId + ")");
+    } else {
+      state.buf.push(access + "(");
+      writeProp(state, scope, parent, "");
+      const scopeRef2 = state.refs.get(scope);
+      if (scopeRef2) ensureId(state, scopeRef2);
+      state.buf.push(")");
+    }
+  } else {
+    state.buf.push(access);
+  }
+  return true;
+}
+function writeString(state, val) {
+  state.buf.push(quote(val, 0));
+  return true;
+}
+function writeNumber(state, val) {
+  state.buf.push(val + "");
+  return true;
+}
+function writeBoolean(state, val) {
+  state.buf.push(val ? "!0" : "!1");
+  return true;
+}
+function writeBigInt(state, val) {
+  state.buf.push(val + "n");
+  return true;
+}
+function writeFunction(state, val, parent, accessor) {
+  const wellKnownFunction = KNOWN_FUNCTIONS.get(val);
+  if (wellKnownFunction) {
+    state.buf.push(wellKnownFunction);
+    return true;
+  }
+  return writeReferenceOr(state, writeNever, val, parent, accessor);
+}
+function writeSymbol(state, val, parent, accessor) {
+  const wellKnownSymbol = KNOWN_SYMBOLS.get(val);
+  if (wellKnownSymbol) {
+    state.buf.push(wellKnownSymbol);
+    return true;
+  }
+  const key = Symbol.keyFor(val);
+  if (key !== void 0) {
+    state.buf.push("Symbol.for(" + quote(key, 0) + ")");
+    return true;
+  }
+  return writeReferenceOr(state, writeUnknownSymbol, val, parent, accessor);
+}
+function writeUnknownSymbol(state) {
+  state.buf.push("Symbol()");
+  return true;
+}
+function writeNever() {
+  return false;
+}
+function writeNull(state) {
+  state.buf.push("null");
+  return true;
+}
+function writeObject(state, val, parent, accessor) {
+  if (val === null) return writeNull(state);
+  const wellKnownObject = KNOWN_OBJECTS.get(val);
+  if (wellKnownObject) {
+    state.buf.push(wellKnownObject);
+    return true;
+  }
+  return writeReferenceOr(state, writeUnknownObject, val, parent, accessor);
+}
+function writeUnknownObject(state, val, ref) {
+  switch (val.constructor) {
+    case void 0:
+      return writeNullObject(state, val, ref);
+    case Object:
+      return writePlainObject(state, val, ref);
+    case Array:
+      return writeArray(state, val, ref);
+    case Date:
+      return writeDate(state, val);
+    case RegExp:
+      return writeRegExp(state, val);
+    case Promise:
+      return writePromise(state, val, ref);
+    case Map:
+      return writeMap(state, val, ref);
+    case Set:
+      return writeSet(state, val, ref);
+    case Generator:
+      return writeGenerator(state, val, ref);
+    case AsyncGenerator:
+      return writeAsyncGenerator(state, val, ref);
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return writeError(state, val, ref);
+    case AggregateError:
+      return writeAggregateError(state, val, ref);
+    case ArrayBuffer:
+      return writeArrayBuffer(state, val);
+    case Int8Array:
+    case Uint8Array:
+    case Uint8ClampedArray:
+    case Int16Array:
+    case Uint16Array:
+    case Int32Array:
+    case Uint32Array:
+    case Float32Array:
+    case Float64Array:
+      return writeTypedArray(state, val, ref);
+    case WeakSet:
+      return writeWeakSet(state);
+    case WeakMap:
+      return writeWeakMap(state);
+    // The following references use `globalThis`
+    // since they are not implemented by all runtimes.
+    case globalThis.URL:
+      return writeURL(state, val);
+    case globalThis.URLSearchParams:
+      return writeURLSearchParams(state, val);
+    case globalThis.Headers:
+      return writeHeaders(state, val);
+    case globalThis.FormData:
+      return writeFormData(state, val);
+    case globalThis.ReadableStream:
+      return writeReadableStream(state, val, ref);
+    case globalThis.Request:
+      return writeRequest(state, val, ref);
+    case globalThis.Response:
+      return writeResponse(state, val, ref);
+  }
+  return false;
+}
+function writePlainObject(state, val, ref) {
+  state.buf.push("{");
+  writeObjectProps(state, val, ref);
+  state.buf.push("}");
+  return true;
+}
+function writeArray(state, val, ref) {
+  state.buf.push("[");
+  writeProp(state, val[0], ref, "0");
+  for (let i = 1; i < val.length; i++) {
+    state.buf.push(",");
+    writeProp(state, val[i], ref, "" + i);
+  }
+  state.buf.push("]");
+  return true;
+}
+function writeDate(state, val) {
+  state.buf.push('new Date("' + val.toISOString() + '")');
+  return true;
+}
+function writeRegExp(state, val) {
+  state.buf.push(val + "");
+  return true;
+}
+function writePromise(state, val, ref) {
+  const { boundary } = state;
+  if (!boundary) return false;
+  const pId = nextRefAccess(state);
+  const pRef = new Reference(ref, null, state.flush, null, pId);
+  state.buf.push("new Promise((f,r)=>" + pId + "={f,r})");
+  val.then(
+    (v) => writeAsyncCall(state, boundary, pRef, "f", v, pId),
+    (v) => writeAsyncCall(state, boundary, pRef, "r", v, pId)
+  );
+  boundary.startAsync();
+  return true;
+}
+function writeMap(state, val, ref) {
+  if (!val.size) {
+    state.buf.push("new Map");
+    return true;
+  }
+  const items = [];
+  let assigns = "";
+  for (let [itemKey, itemValue] of val) {
+    if (itemKey === val) {
+      itemKey = void 0;
+      assigns += "i[" + items.length + "][0]=";
+    }
+    if (itemValue === val) {
+      itemValue = void 0;
+      assigns += "i[" + items.length + "][1]=";
+    }
+    if (itemValue === void 0) {
+      items.push([itemKey]);
+    } else {
+      items.push([itemKey, itemValue]);
+    }
+  }
+  const arrayRef = new Reference(
+    ref,
+    null,
+    state.flush,
+    null,
+    nextRefAccess(state)
+  );
+  state.buf.push(
+    (assigns ? "((m,i)=>(" + assigns + "m,i.forEach(i=>m.set(i[0],i[1])),m))(new Map," : "new Map(") + arrayRef.id + "="
+  );
+  writeArray(state, items, arrayRef);
+  state.buf.push(")");
+  return true;
+}
+function writeSet(state, val, ref) {
+  if (!val.size) {
+    state.buf.push("new Set");
+    return true;
+  }
+  const items = [];
+  let assigns = "";
+  for (let item of val) {
+    if (item === val) {
+      item = void 0;
+      assigns += "i[" + items.length + "]=";
+    }
+    items.push(item);
+  }
+  const arrayRef = new Reference(
+    ref,
+    null,
+    state.flush,
+    null,
+    nextRefAccess(state)
+  );
+  state.buf.push(
+    (assigns ? "((s,i)=>(" + assigns + "s,i.forEach(i=>s.add(i)),s))(new Set," : "new Set(") + arrayRef.id + "="
+  );
+  writeArray(state, items, arrayRef);
+  state.buf.push(")");
+  return true;
+}
+function writeArrayBuffer(state, val) {
+  let result = "";
+  if (val.byteLength) {
+    const view = new Int8Array(val);
+    result = hasOnlyZeros(view) ? "new ArrayBuffer(" + val.byteLength + ")" : "new Int8Array(" + typedArrayToInitString(view) + ").buffer";
+  } else {
+    result = "new ArrayBuffer";
+  }
+  state.buf.push(result);
+  return true;
+}
+function writeTypedArray(state, val, ref) {
+  if (val.byteOffset || state.refs.has(val.buffer)) {
+    state.buf.push("new " + val.constructor.name + "(");
+    writeProp(state, val.buffer, ref, "buffer");
+    state.buf.push(val.byteOffset ? "," + val.byteOffset + ")" : ")");
+  } else {
+    state.refs.set(val.buffer, new Reference(ref, "buffer", state.flush, null));
+    state.buf.push(
+      "new " + val.constructor.name + (val.length === 0 ? "" : "(" + (hasOnlyZeros(val) ? val.length : typedArrayToInitString(val)) + ")")
+    );
+  }
+  return true;
+}
+function writeWeakSet(state) {
+  state.buf.push("new WeakSet");
+  return true;
+}
+function writeWeakMap(state) {
+  state.buf.push("new WeakMap");
+  return true;
+}
+function writeError(state, val, ref) {
+  const result = "new " + val.constructor.name + "(" + quote(val.message + "", 0);
+  if (val.cause) {
+    state.buf.push(result + ",{cause:");
+    writeProp(state, val.cause, ref, "cause");
+    state.buf.push("})");
+  } else {
+    state.buf.push(result + ")");
+  }
+  return true;
+}
+function writeAggregateError(state, val, ref) {
+  state.buf.push("new AggregateError(");
+  writeProp(state, val.errors, ref, "errors");
+  if (val.message) {
+    state.buf.push("," + quote(val.message + "", 0) + ")");
+  } else {
+    state.buf.push(")");
+  }
+  return true;
+}
+function writeURL(state, val) {
+  state.buf.push("new URL(" + quote(val.toString(), 0) + ")");
+  return true;
+}
+function writeURLSearchParams(state, val) {
+  const str = val.toString();
+  if (str) {
+    state.buf.push("new URLSearchParams(" + quote(str, 0) + ")");
+  } else {
+    state.buf.push("new URLSearchParams");
+  }
+  return true;
+}
+function writeHeaders(state, val) {
+  const headers = stringEntriesToProps(val);
+  state.buf.push("new Headers" + (headers ? "({" + headers + "})" : ""));
+  return true;
+}
+function writeFormData(state, val) {
+  let sep = "[";
+  let valStr = "";
+  for (const [key, value] of val) {
+    if (typeof value === "string") {
+      valStr += sep + "[" + quote(key, 0) + "," + quote(value, 0) + "]";
+      sep = ",";
+    }
+  }
+  if (sep === "[") {
+    state.buf.push("new FormData");
+  } else {
+    state.buf.push(
+      "((f,i)=>(f,i.forEach(i=>f.append(i[0],i[1])),f))(new FormData," + valStr + "])"
+    );
+  }
+  return true;
+}
+function writeRequest(state, val, ref) {
+  let sep = "";
+  const hasBody = val.body && !val.bodyUsed && val.duplex === "half";
+  state.buf.push("new Request(" + quote(val.url, 0));
+  if (hasBody) {
+    state.buf.push(",{body:");
+    if (writeProp(state, val.body, ref, "body")) {
+      state.buf.push(',duplex:"half"');
+      sep = ",";
+    } else {
+      state.buf.pop();
+    }
+  }
+  let options = "";
+  if (val.cache !== "default") {
+    options += sep + "cache:" + quote(val.cache, 0);
+    sep = ",";
+  }
+  if (val.credentials !== "same-origin") {
+    options += sep + "credentials:" + quote(val.credentials, 0);
+    sep = ",";
+  }
+  const headers = stringEntriesToProps(val.headers);
+  state.refs.set(val.headers, new Reference(ref, "headers", state.flush, null));
+  if (headers) {
+    options += sep + "headers:{" + headers + "}";
+    sep = ",";
+  }
+  if (val.integrity) {
+    options += sep + "integrity:" + quote(val.integrity, 0);
+    sep = ",";
+  }
+  if (val.keepalive) {
+    options += sep + "keepalive:true";
+    sep = ",";
+  }
+  if (val.method !== "GET") {
+    options += sep + "method:" + quote(val.method, 0);
+    sep = ",";
+  }
+  if (val.mode !== "cors") {
+    options += sep + "mode:" + quote(val.mode, 0);
+    sep = ",";
+  }
+  if (val.redirect !== "follow") {
+    options += sep + "redirect:" + quote(val.redirect, 0);
+    sep = ",";
+  }
+  if (val.referrer !== "about:client") {
+    options += sep + "referrer:" + quote(val.referrer, 0);
+    sep = ",";
+  }
+  if (val.referrerPolicy) {
+    options += sep + "referrerPolicy:" + quote(val.referrerPolicy, 0);
+    sep = ",";
+  }
+  state.buf.push(
+    hasBody ? options + "})" : options ? ",{" + options + "})" : ")"
+  );
+  return true;
+}
+function writeResponse(state, val, ref) {
+  let sep = "";
+  let options = "";
+  if (val.status !== 200) {
+    options += "status:" + val.status;
+    sep = ",";
+  }
+  if (val.statusText) {
+    options += sep + "statusText:" + quote(val.statusText, 0);
+    sep = ",";
+  }
+  const headers = stringEntriesToProps(val.headers);
+  state.refs.set(val.headers, new Reference(ref, "headers", state.flush, null));
+  if (headers) {
+    options += sep + "headers:{" + headers + "}";
+    sep = ",";
+  }
+  if (!val.body || val.bodyUsed) {
+    state.buf.push(
+      "new Response" + (options ? "(null,{" + options + "})" : "")
+    );
+  } else {
+    state.buf.push("new Response(");
+    state.buf.push(
+      (writeProp(state, val.body, ref, "body") ? "" : "null") + (options ? ",{" + options + "})" : ")")
+    );
+  }
+  return true;
+}
+function writeReadableStream(state, val, ref) {
+  const { boundary } = state;
+  if (!boundary || val.locked) return false;
+  const reader = val.getReader();
+  const iterId = nextRefAccess(state);
+  const iterRef = new Reference(ref, null, state.flush, null, iterId);
+  const onFulfilled = ({ value, done }) => {
+    if (done) {
+      writeAsyncCall(state, boundary, iterRef, "r", value);
+    } else if (!boundary.signal.aborted) {
+      reader.read().then(onFulfilled, onRejected);
+      boundary.startAsync();
+      writeAsyncCall(state, boundary, iterRef, "f", value);
+    }
+  };
+  const onRejected = (reason) => {
+    writeAsyncCall(state, boundary, iterRef, "j", reason);
+  };
+  state.buf.push(
+    "new ReadableStream({start(c){(async(_,f,v,l,i,p=a=>l=new Promise((r,j)=>{f=_.r=r;_.j=j}),a=((_.f=v=>{f(v);a.push(p())}),[p()]))=>{for(i of a)v=await i,i==l?c.close():c.enqueue(v)})(" + iterId + "={}).catch(e=>c.error(e))}})"
+  );
+  reader.read().then(onFulfilled, onRejected);
+  boundary.startAsync();
+  return true;
+}
+function writeGenerator(state, iter, ref) {
+  let sep = "";
+  state.buf.push("(function*(){");
+  while (true) {
+    const { value, done } = iter.next();
+    if (done) {
+      if (value !== void 0) {
+        state.buf.push(sep + "return ");
+        writeProp(state, value, ref, "");
+      }
+      break;
+    }
+    if (value === void 0) {
+      state.buf.push(sep + "yield");
+    } else {
+      state.buf.push(sep + "yield ");
+      writeProp(state, value, ref, "");
+    }
+    sep = ";";
+  }
+  state.buf.push("})()");
+  return true;
+}
+function writeAsyncGenerator(state, iter, ref) {
+  const { boundary } = state;
+  if (!boundary) return false;
+  const iterId = nextRefAccess(state);
+  const iterRef = new Reference(ref, null, state.flush, null, iterId);
+  const onFulfilled = ({ value, done }) => {
+    if (done) {
+      writeAsyncCall(state, boundary, iterRef, "r", value);
+    } else if (!boundary.signal.aborted) {
+      iter.next().then(onFulfilled, onRejected);
+      boundary.startAsync();
+      writeAsyncCall(state, boundary, iterRef, "f", value);
+    }
+  };
+  const onRejected = (reason) => {
+    writeAsyncCall(state, boundary, iterRef, "j", reason);
+  };
+  state.buf.push(
+    "(async function*(_,f,v,l,i,p=a=>l=new Promise((r,j)=>{f=_.r=r;_.j=j}),a=((_.f=v=>{f(v);a.push(p())}),[p()])){for(i of a)v=await i,i!=l&&(yield v);return v})(" + iterId + "={})"
+  );
+  iter.next().then(onFulfilled, onRejected);
+  boundary.startAsync();
+  return true;
+}
+function writeNullObject(state, val, ref) {
+  state.buf.push("{");
+  state.buf.push(writeObjectProps(state, val, ref) + "__proto__:null}");
+  return true;
+}
+function writeObjectProps(state, val, ref) {
+  let sep = "";
+  for (const key in val) {
+    if (hasOwnProperty.call(val, key)) {
+      const escapedKey = toObjectKey(key);
+      state.buf.push(sep + escapedKey + ":");
+      if (writeProp(
+        state,
+        val[key],
+        ref,
+        escapedKey
+      )) {
+        sep = ",";
+      } else {
+        state.buf.pop();
+      }
+    }
+  }
+  if (hasSymbolIterator(val)) {
+    state.buf.push(sep + "[Symbol.iterator]:");
+    sep = ",";
+    if (!writeReferenceOr(
+      state,
+      writeNever,
+      val[Symbol.iterator],
+      ref,
+      "Symbol.iterator"
+    )) {
+      const arrayRef = new Reference(
+        ref,
+        null,
+        state.flush,
+        null,
+        nextRefAccess(state)
+      );
+      state.buf.push("(a=>()=>a.values())(" + arrayRef.id + "=");
+      writeArray(state, [...val], arrayRef);
+      state.buf.push(")");
+    }
+  }
+  return sep;
+}
+function writeAsyncCall(state, boundary, ref, method, value, preferredValueId = null) {
+  if (boundary.signal.aborted) return;
+  state.flushed = true;
+  const valueStartIndex = state.buf.push(
+    (state.buf.length === 0 ? "" : ",") + ref.id + "." + method + "("
+  );
+  if (writeProp(state, value, ref, "")) {
+    const valueRef = state.refs.get(value);
+    if (valueRef && !valueRef.id) {
+      valueRef.id = preferredValueId || nextRefAccess(state);
+      state.buf[valueStartIndex] = valueRef.id + "=" + state.buf[valueStartIndex];
+    }
+  }
+  state.buf.push(")");
+  boundary.endAsync();
+}
+function isCircular(parent, ref) {
+  let cur = parent;
+  while (cur) {
+    if (cur === ref) return true;
+    cur = cur.parent;
+  }
+  return false;
+}
+function toObjectKey(name) {
+  if (name === "") {
+    return '""';
+  }
+  const startChar = name[0];
+  if (isDigit(startChar)) {
+    if (startChar === "0") {
+      if (name !== "0") {
+        return quote(name, 1);
+      }
+    } else {
+      for (let i = 1; i < name.length; i++) {
+        if (!isDigit(name[i])) {
+          return quote(name, i);
+        }
+      }
+    }
+  } else if (isWord(startChar)) {
+    for (let i = 1; i < name.length; i++) {
+      if (!isWordOrDigit(name[i])) {
+        return quote(name, i);
+      }
+    }
+  } else {
+    return quote(name, 0);
+  }
+  return name;
+}
+function toAccess(accessor) {
+  const start = accessor[0];
+  return start === '"' || start >= "0" && start <= "9" ? "[" + accessor + "]" : "." + accessor;
+}
+function quote(str, startPos) {
+  let result = "";
+  let lastPos = 0;
+  for (let i = startPos; i < str.length; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case "\n":
+        replacement = "\\n";
+        break;
+      case "\r":
+        replacement = "\\r";
+        break;
+      case "\u2028":
+        replacement = "\\u2028";
+        break;
+      case "\u2029":
+        replacement = "\\u2029";
+        break;
+      default:
+        continue;
+    }
+    result += str.slice(lastPos, i) + replacement;
+    lastPos = i + 1;
+  }
+  return '"' + (lastPos === startPos ? str : result + str.slice(lastPos)) + '"';
+}
+function ensureId(state, ref) {
+  return ref.id || assignId(state, ref);
+}
+function assignId(state, ref) {
+  const { pos } = ref;
+  ref.id = nextRefAccess(state);
+  if (pos !== null && ref.flush === state.flush) {
+    if (pos === 0) {
+      state.buf[0] = ref.id + "=" + state.buf[0];
+    } else {
+      state.buf[pos - 1] += ref.id + "=";
+    }
+    return ref.id;
+  }
+  let cur = ref;
+  let accessPrevValue = "";
+  do {
+    accessPrevValue = toAccess(cur.accessor) + accessPrevValue;
+    const parent = cur.parent;
+    if (parent.id) {
+      accessPrevValue = parent.id + accessPrevValue;
+      break;
+    }
+    if (parent.flush === state.flush) {
+      accessPrevValue = ensureId(state, parent) + accessPrevValue;
+      break;
+    }
+    cur = parent;
+  } while (cur);
+  return ref.id + "=" + accessPrevValue;
+}
+function nextRefAccess(state) {
+  return "_." + nextId(state);
+}
+function nextId(state) {
+  const encodeChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+  const encodeLen = encodeChars.length;
+  const encodeStartLen = encodeLen - 11;
+  let index = state.ids++;
+  let mod = index % encodeStartLen;
+  let id = encodeChars[mod];
+  index = (index - mod) / encodeStartLen;
+  while (index > 0) {
+    mod = index % encodeLen;
+    id += encodeChars[mod];
+    index = (index - mod) / encodeLen;
+  }
+  return id;
+}
+function hasSymbolIterator(value) {
+  return Symbol.iterator in value;
+}
+function stringEntriesToProps(entries) {
+  let result = "";
+  let sep = "";
+  for (const [key, value] of entries) {
+    result += sep + toObjectKey(key) + ":" + quote(value, 0);
+    sep = ",";
+  }
+  return result;
+}
+function typedArrayToInitString(view) {
+  let result = "[";
+  let sep = "";
+  for (let i = 0; i < view.length; i++) {
+    result += sep + view[i];
+    sep = ",";
+  }
+  result += "]";
+  return result;
+}
+function hasOnlyZeros(typedArray) {
+  for (let i = 0; i < typedArray.length; i++) {
+    if (typedArray[i] !== 0) return false;
+  }
+  return true;
+}
+function isWordOrDigit(char) {
+  return isWord(char) || isDigit(char);
+}
+function isDigit(char) {
+  return char >= "0" && char <= "9";
+}
+function isWord(char) {
+  return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "$";
+}
+
+// src/html/writer.ts
+var $chunk;
+var NOOP = () => {
+};
+var K_SCOPE_ID = Symbol("Scope ID");
+function getChunk() {
+  return $chunk;
+}
+function getScopeId(scope) {
+  return scope[K_SCOPE_ID];
+}
+function write(html) {
+  $chunk.writeHTML(html);
+}
+function writeScript(script) {
+  $chunk.writeScript(script);
+}
+function writeEffect(scopeId, registryId) {
+  $chunk.boundary.state.needsMainRuntime = true;
+  $chunk.writeEffect(scopeId, registryId);
+}
+var kPendingContexts = Symbol("Pending Contexts");
+function withContext(key, value, cb) {
+  const ctx = $chunk.context ||= { [kPendingContexts]: 0 };
+  const prev = ctx[key];
+  ctx[kPendingContexts]++;
+  ctx[key] = value;
+  try {
+    cb();
+  } finally {
+    ctx[kPendingContexts]--;
+    ctx[key] = prev;
+  }
+}
+function register2(val, id, scopeId) {
+  return scopeId === void 0 ? register(id, val) : register(id, val, ensureScopeWithId(scopeId));
+}
+function nextTagId() {
+  const state = $chunk.boundary.state;
+  const { $global: $global2 } = state;
+  return "s" + $global2.runtimeId + $global2.renderId + (state.tagIndex++).toString(36);
+}
+function nextScopeId() {
+  return $chunk.boundary.state.scopeIndex++;
+}
+function peekNextScopeId() {
+  return $chunk.boundary.state.scopeIndex;
+}
+function peekNextScope() {
+  return ensureScopeWithId(peekNextScopeId());
+}
+function getScopeById(scopeId) {
+  if (scopeId !== void 0) {
+    return $chunk.boundary.state.scopes.get(scopeId);
+  }
+}
+function markResumeNode(scopeId, accessor) {
+  const { state } = $chunk.boundary;
+  state.needsMainRuntime = true;
+  return state.mark("*" /* Node */, scopeId + " " + accessor);
+}
+function nodeRef(scopeId, id) {
+  const getter = () => {
+    if (true) {
+      throw new Error("Cannot read a node reference on the server.");
+    }
+  };
+  return id ? register2(getter, id, scopeId) : getter;
+}
+function markResumeScopeStart(scopeId, index) {
+  return $chunk.boundary.state.mark(
+    "[" /* SectionStart */,
+    scopeId + (index ? " " + index : "")
+  );
+}
+function markResumeControlEnd(scopeId, accessor) {
+  return $chunk.boundary.state.mark("]" /* SectionEnd */, scopeId + " " + accessor);
+}
+function markResumeControlSingleNodeEnd(scopeId, accessor, childScopeIds) {
+  return $chunk.boundary.state.mark(
+    "|" /* SectionSingleNodesEnd */,
+    scopeId + " " + accessor + " " + (childScopeIds ?? "")
+  );
+}
+function markResumeCleanup(scopeId) {
+  return $chunk.boundary.state.mark("$" /* Cleanup */, "" + scopeId);
+}
+function writeScope(scopeId, partialScope) {
+  const { state } = $chunk.boundary;
+  const { scopes } = state;
+  let scope = scopes.get(scopeId);
+  state.needsMainRuntime = true;
+  if (scope) {
+    Object.assign(scope, partialScope);
+  } else {
+    scope = partialScope;
+    scope[K_SCOPE_ID] = scopeId;
+    state.scopes.set(scopeId, scope);
+  }
+  if (state.writeScopes) {
+    state.writeScopes[scopeId] = scope;
+  } else if (state.hasGlobals) {
+    state.writeScopes = { [scopeId]: scope };
+  } else {
+    state.hasGlobals = true;
+    state.writeScopes = {
+      $: getFilteredGlobals(state.$global),
+      [scopeId]: scope
+    };
+  }
+  return scope;
+}
+function writeExistingScope(scope) {
+  return writeScope(scope[K_SCOPE_ID], scope);
+}
+function ensureScopeWithId(scopeId) {
+  const { state } = $chunk.boundary;
+  let scope = state.scopes.get(scopeId);
+  if (!scope) {
+    scope = { [K_SCOPE_ID]: scopeId };
+    state.scopes.set(scopeId, scope);
+  }
+  return scope;
+}
+function $global() {
+  return $chunk.boundary.state.$global;
+}
+function fork(promise, renderBody) {
+  if (!isPromise(promise)) {
+    renderBody(promise);
+    return;
+  }
+  const chunk = $chunk;
+  const { boundary } = chunk;
+  chunk.next = $chunk = new Chunk(boundary, chunk.next, chunk.context);
+  chunk.async = true;
+  if (chunk.context?.[kPendingContexts]) {
+    chunk.context = { ...chunk.context, [kPendingContexts]: 0 };
+  }
+  boundary.startAsync();
+  promise.then(
+    (value) => {
+      if (chunk.async) {
+        chunk.async = false;
+        if (!boundary.signal.aborted) {
+          chunk.render(renderBody, value);
+          boundary.endAsync(chunk);
+        }
+      }
+    },
+    (err) => {
+      chunk.async = false;
+      boundary.abort(err);
+    }
+  );
+}
+function tryPlaceholder(renderBody, renderPlaceholder) {
+  const chunk = $chunk;
+  const { boundary } = chunk;
+  const body = new Chunk(boundary, null, chunk.context);
+  if (body === body.render(renderBody)) {
+    chunk.append(body);
+    return;
+  }
+  chunk.next = $chunk = new Chunk(boundary, chunk.next, body.context);
+  chunk.placeholderBody = body;
+  chunk.placeholderRender = renderPlaceholder;
+}
+function tryCatch(renderBody, renderCatch) {
+  const chunk = $chunk;
+  const { boundary } = chunk;
+  const { state } = boundary;
+  const catchBoundary = new Boundary(state);
+  const body = new Chunk(catchBoundary, null, chunk.context);
+  const bodyEnd = body.render(renderBody);
+  if (catchBoundary.signal.aborted) {
+    renderCatch(catchBoundary.signal.reason);
+    return;
+  }
+  if (body === bodyEnd) {
+    chunk.append(body);
+    return;
+  }
+  const reorderId = state.nextReorderId();
+  const endMarker = state.mark("!" /* PlaceholderEnd */, reorderId);
+  const bodyNext = bodyEnd.next = $chunk = new Chunk(boundary, chunk.next, body.context);
+  chunk.next = body;
+  chunk.writeHTML(state.mark("!^" /* Placeholder */, reorderId));
+  bodyEnd.writeHTML(endMarker);
+  boundary.startAsync();
+  catchBoundary.onNext = () => {
+    if (boundary.signal.aborted) return;
+    if (catchBoundary.signal.aborted) {
+      if (!bodyEnd.consumed) {
+        let cur = body;
+        let writeMarker = true;
+        do {
+          const next = cur.next;
+          if (cur.boundary !== catchBoundary) {
+            cur.boundary.abort(catchBoundary.signal.reason);
+          }
+          if (writeMarker && !cur.consumed) {
+            writeMarker = false;
+            cur.async = false;
+            cur.next = bodyNext;
+            cur.html = endMarker;
+            cur.scripts = cur.effects = "";
+            cur.placeholderBody = cur.placeholderRender = cur.reorderId = null;
+          }
+          cur = next;
+        } while (cur !== bodyNext);
+      }
+      const catchChunk = new Chunk(boundary, null, chunk.context);
+      catchChunk.reorderId = reorderId;
+      catchChunk.render(renderCatch, catchBoundary.signal.reason);
+      state.reorder(catchChunk);
+      boundary.endAsync();
+    } else if (catchBoundary.done) {
+      boundary.endAsync();
+    } else {
+      boundary.onNext();
+    }
+  };
+}
+var State2 = class {
+  constructor($global2) {
+    this.$global = $global2;
+    this.$global = $global2;
+    if ($global2.cspNonce) {
+      this.nonceAttr = " " + escapeAttrValue($global2.cspNonce + "");
+    }
+  }
+  tagIndex = 0;
+  scopeIndex = 0;
+  reorderIndex = 0;
+  hasGlobals = false;
+  needsMainRuntime = false;
+  hasMainRuntime = false;
+  hasReorderRuntime = false;
+  hasWrittenResume = false;
+  trailerHTML = "";
+  nonceAttr = "";
+  serializer = new Serializer();
+  writeReorders = null;
+  scopes = /* @__PURE__ */ new Map();
+  writeScopes = null;
+  get runtimePrefix() {
+    const { $global: $global2 } = this;
+    return $global2.runtimeId + "." + $global2.renderId;
+  }
+  get commentPrefix() {
+    const { $global: $global2 } = this;
+    return $global2.runtimeId + $global2.renderId;
+  }
+  reorder(chunk) {
+    if (this.writeReorders) {
+      this.writeReorders.push(chunk);
+    } else {
+      this.needsMainRuntime = true;
+      this.writeReorders = [chunk];
+    }
+  }
+  nextReorderId() {
+    const encodeChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+    const encodeLen = encodeChars.length;
+    const encodeStartLen = encodeLen - 10;
+    let index = this.reorderIndex++;
+    let mod = index % encodeStartLen;
+    let id = encodeChars[mod];
+    index = (index - mod) / encodeStartLen;
+    while (index > 0) {
+      mod = index % encodeLen;
+      id += encodeChars[mod];
+      index = (index - mod) / encodeLen;
+    }
+    return id;
+  }
+  mark(code, str) {
+    return "<!--" + this.commentPrefix + code + str + "-->";
+  }
+};
+var Boundary = class extends AbortController {
+  constructor(state, parent) {
+    super();
+    this.state = state;
+    this.state = state;
+    this.signal.addEventListener("abort", () => {
+      this.count = 0;
+      this.state = new State2(this.state.$global);
+      this.onNext();
+    });
+    if (parent) {
+      if (parent.aborted) {
+        this.abort(parent.reason);
+      } else {
+        parent.addEventListener("abort", () => {
+          this.abort(parent.reason);
+        });
+      }
+    }
+  }
+  onNext = NOOP;
+  count = 0;
+  get done() {
+    return this.count === 0;
+  }
+  startAsync() {
+    if (!this.signal.aborted) {
+      this.count++;
+    }
+  }
+  endAsync(chunk) {
+    if (!this.signal.aborted && this.count) {
+      this.count--;
+      if (chunk?.reorderId) {
+        this.state.reorder(chunk);
+      }
+      this.onNext();
+    }
+  }
+};
+var Chunk = class {
+  constructor(boundary, next, context) {
+    this.boundary = boundary;
+    this.next = next;
+    this.context = context;
+    this.boundary = boundary;
+    this.next = next;
+    this.context = context;
+  }
+  html = "";
+  scripts = "";
+  effects = "";
+  async = false;
+  consumed = false;
+  reorderId = null;
+  placeholderBody = null;
+  placeholderRender = null;
+  writeHTML(html) {
+    this.html += html;
+  }
+  writeEffect(scopeId, registryId) {
+    this.effects = concatEffects(
+      this.effects,
+      scopeId + ',"' + registryId + '"'
+    );
+  }
+  writeScript(script) {
+    this.scripts = concatScripts(this.scripts, script);
+  }
+  append(chunk) {
+    this.html += chunk.html;
+    this.effects = concatEffects(this.effects, chunk.effects);
+    this.scripts = concatScripts(this.scripts, chunk.scripts);
+  }
+  flushPlaceholder() {
+    if (this.placeholderBody) {
+      const body = this.placeholderBody.consume();
+      if (body.async) {
+        const { state } = this.boundary;
+        const reorderId = body.reorderId = state.nextReorderId();
+        this.writeHTML(state.mark("!^" /* Placeholder */, reorderId));
+        const after = this.render(this.placeholderRender);
+        if (after !== this) {
+          this.boundary.abort(
+            new Error("An @placeholder cannot contain async content.")
+          );
+        }
+        after.writeHTML(state.mark("!" /* PlaceholderEnd */, reorderId));
+        state.reorder(body);
+      } else {
+        body.next = this.next;
+        this.next = body;
+      }
+      this.placeholderRender = this.placeholderBody = null;
+    }
+  }
+  consume() {
+    let cur = this;
+    if (cur.next && !cur.async) {
+      let html = "";
+      let effects = "";
+      let scripts = "";
+      do {
+        cur.flushPlaceholder();
+        html += cur.html;
+        effects += cur.effects;
+        scripts = concatScripts(scripts, cur.scripts);
+        cur.consumed = true;
+        cur = cur.next;
+      } while (cur.next && !cur.async);
+      cur.html = html + cur.html;
+      cur.effects = concatEffects(effects, cur.effects);
+      cur.scripts = concatScripts(scripts, cur.scripts);
+    }
+    return cur;
+  }
+  render(renderBody, val) {
+    const prev = $chunk;
+    $chunk = this;
+    try {
+      renderBody(val);
+      return $chunk;
+    } catch (err) {
+      this.boundary.abort(err);
+      return this;
+    } finally {
+      $chunk = prev;
+    }
+  }
+};
+function prepareChunk(chunk) {
+  const head = chunk.consume();
+  const { boundary, effects } = head;
+  const { state } = boundary;
+  const { $global: $global2, runtimePrefix, serializer, nonceAttr } = state;
+  let { html, scripts } = head;
+  let hasWalk = false;
+  head.effects = "";
+  if (state.needsMainRuntime && !state.hasMainRuntime) {
+    state.hasMainRuntime = true;
+    scripts = concatScripts(
+      scripts,
+      WALKER_RUNTIME_CODE + '("' + $global2.runtimeId + '")("' + $global2.renderId + '")'
+    );
+  }
+  let resumes = "";
+  if (state.writeScopes || serializer.flushed) {
+    resumes = state.serializer.stringify(state.writeScopes || {}, boundary);
+    state.writeScopes = null;
+  }
+  if (effects) {
+    hasWalk = true;
+    resumes = resumes ? resumes + "," + effects : effects;
+  }
+  if (boundary.done && (resumes || state.hasWrittenResume)) {
+    resumes = resumes ? resumes + ",0" : "0";
+  }
+  if (resumes) {
+    if (state.hasWrittenResume) {
+      scripts = concatScripts(
+        scripts,
+        runtimePrefix + ".r.push(" + resumes + ")"
+      );
+    } else {
+      state.hasWrittenResume = true;
+      scripts = concatScripts(
+        scripts,
+        runtimePrefix + ".r=[" + resumes + "]"
+      );
+    }
+  }
+  if (state.writeReorders) {
+    hasWalk = true;
+    if (!state.hasReorderRuntime) {
+      state.hasReorderRuntime = true;
+      html += "<style " + state.commentPrefix + nonceAttr + ">t{display:none}</style>";
+      scripts = concatScripts(
+        scripts,
+        REORDER_RUNTIME_CODE + "(" + runtimePrefix + ")"
+      );
+    }
+    for (const reorderedChunk of state.writeReorders) {
+      const { reorderId } = reorderedChunk;
+      let isSync = true;
+      let reorderHTML = "";
+      let reorderEffects = "";
+      let reorderScripts = "";
+      let cur = reorderedChunk;
+      reorderedChunk.reorderId = null;
+      for (; ; ) {
+        cur.flushPlaceholder();
+        reorderHTML += cur.html;
+        reorderEffects = concatEffects(reorderEffects, cur.effects);
+        reorderScripts = concatScripts(reorderScripts, cur.scripts);
+        if (cur.async) {
+          reorderHTML += state.mark(
+            "#" /* ReorderMarker */,
+            cur.reorderId = state.nextReorderId()
+          );
+          cur.html = cur.effects = cur.scripts = "";
+          isSync = false;
+        }
+        if (cur.next) {
+          cur = cur.next;
+        } else {
+          break;
+        }
+      }
+      if (reorderEffects) {
+        if (!state.hasWrittenResume) {
+          state.hasWrittenResume = true;
+          scripts = concatScripts(
+            scripts,
+            runtimePrefix + ".r=[]"
+          );
+        }
+        reorderScripts = concatScripts(
+          reorderScripts,
+          "_.push(" + reorderEffects + ")"
+        );
+      }
+      scripts = concatScripts(
+        scripts,
+        reorderScripts && runtimePrefix + ".j." + reorderId + "=_=>{" + reorderScripts + "}"
+      );
+      html += "<t " + (isSync ? "c " : "") + state.commentPrefix + "=" + reorderId + ">" + reorderHTML + "</t>";
+    }
+    state.writeReorders = null;
+  }
+  if (hasWalk) {
+    scripts = concatScripts(scripts, runtimePrefix + ".w()");
+  }
+  head.html = html;
+  head.scripts = scripts;
+  return head;
+}
+function flushChunk(head, last) {
+  const { boundary } = head;
+  const { state } = boundary;
+  const { html, scripts } = head;
+  const { $global: $global2 } = state;
+  const { __flush__ } = $global2;
+  let result = html;
+  head.html = head.scripts = "";
+  if (scripts) {
+    result += "<script" + state.nonceAttr + ">" + scripts + "</script>";
+  }
+  if (__flush__) {
+    $global2.__flush__ = void 0;
+    result = __flush__($global2, result);
+  }
+  if (last && state.trailerHTML) {
+    result += state.trailerHTML;
+  }
+  return result;
+}
+function writeTrailers(html) {
+  $chunk.boundary.state.trailerHTML += html;
+}
+function concatEffects(a, b) {
+  return a ? b ? a + "," + b : a : b;
+}
+function concatScripts(a, b) {
+  return a ? b ? a + ";" + b : a : b;
+}
+var tick = globalThis.setImmediate || globalThis.setTimeout || globalThis.queueMicrotask || ((cb) => Promise.resolve().then(cb));
+var tickQueue;
+function queueTick(cb) {
+  if (tickQueue) {
+    tickQueue.add(cb);
+  } else {
+    tickQueue = /* @__PURE__ */ new Set([cb]);
+    tick(flushTickQueue);
+  }
+}
+function offTick(cb) {
+  tickQueue?.delete(cb);
+}
+function flushTickQueue() {
+  const queue = tickQueue;
+  tickQueue = void 0;
+  for (const cb of queue) {
+    cb(true);
+  }
+}
+function isPromise(value) {
+  return value != null && typeof value.then === "function";
+}
+function getFilteredGlobals($global2) {
+  if (!$global2) return void 0;
+  const serializedGlobals = $global2.serializedGlobals;
+  if (!serializedGlobals) return void 0;
+  let filtered;
+  if (Array.isArray(serializedGlobals)) {
+    for (const key of serializedGlobals) {
+      const value = $global2[key];
+      if (value !== void 0) {
+        if (filtered) {
+          filtered[key] = value;
+        } else {
+          filtered = { [key]: value };
+        }
+      }
+    }
+  } else {
+    for (const key in serializedGlobals) {
+      if (serializedGlobals[key]) {
+        const value = $global2[key];
+        if (value !== void 0) {
+          if (filtered) {
+            filtered[key] = value;
+          } else {
+            filtered = { [key]: value };
+          }
+        }
+      }
+    }
+  }
+  return filtered;
+}
+
+// src/html/attrs.ts
+function classAttr(val) {
+  return stringAttr("class", classValue(val));
+}
+function styleAttr(val) {
+  return stringAttr("style", styleValue(val));
+}
+function optionValueAttr(value) {
+  const { [kSelectedValue]: selectedValue } = getChunk()?.context || {};
+  return attr("value", value) + (!isVoid(value) && (Array.isArray(value) ? selectedValue.includes(value) : selectedValue === value) ? ` selected` : "");
+}
+var kSelectedValue = Symbol("selectedValue");
+function controllable_select_value(scopeId, nodeAccessor, value, valueChange, renderBody) {
+  if (valueChange) {
+    writeControlledScope(
+      3 /* SelectValue */,
+      scopeId,
+      nodeAccessor,
+      value,
+      valueChange
+    );
+  }
+  if (renderBody) {
+    withContext(kSelectedValue, value, renderBody);
+  }
+}
+function controllable_textarea_value(scopeId, nodeAccessor, value, valueChange) {
+  if (valueChange) {
+    writeControlledScope(
+      2 /* InputValue */,
+      scopeId,
+      nodeAccessor,
+      void 0,
+      valueChange
+    );
+  }
+  return escapeTextAreaValue(value);
+}
+function controllable_input_value(scopeId, nodeAccessor, value, valueChange) {
+  if (valueChange) {
+    writeControlledScope(
+      2 /* InputValue */,
+      scopeId,
+      nodeAccessor,
+      void 0,
+      valueChange
+    );
+  }
+  return attr("value", value);
+}
+function controllable_input_checked(scopeId, nodeAccessor, checked, checkedChange) {
+  if (checkedChange) {
+    writeControlledScope(
+      0 /* InputChecked */,
+      scopeId,
+      nodeAccessor,
+      void 0,
+      checkedChange
+    );
+  }
+  return attr("checked", checked);
+}
+function controllable_input_checkedValue(scopeId, nodeAccessor, checkedValue, checkedValueChange, value) {
+  const multiple = Array.isArray(checkedValue);
+  const valueAttr = attr("value", value);
+  if (checkedValueChange) {
+    writeControlledScope(
+      1 /* InputCheckedValue */,
+      scopeId,
+      nodeAccessor,
+      multiple ? checkedValue : void 0,
+      checkedValueChange
+    );
+  }
+  return (multiple ? checkedValue.includes(value) : checkedValue === value) ? valueAttr + " checked" : valueAttr;
+}
+function controllable_detailsOrDialog_open(scopeId, nodeAccessor, open, openChange) {
+  if (openChange) {
+    writeControlledScope(
+      4 /* DetailsOrDialogOpen */,
+      scopeId,
+      nodeAccessor,
+      open,
+      openChange
+    );
+  }
+  return attr("open", open);
+}
+function attr(name, val) {
+  return isVoid(val) ? "" : nonVoidAttr(name, val);
+}
+function attrs(data, nodeAccessor, scopeId, tagName) {
+  let result = "";
+  let skip = /[\s/>"'=]/;
+  let events;
+  switch (tagName) {
+    case "input":
+      if (data.checkedChange) {
+        result += controllable_input_checked(
+          scopeId,
+          nodeAccessor,
+          data.checked,
+          data.checkedChange
+        );
+      } else if (data.checkedValue || data.checkedValueChange) {
+        result += controllable_input_checkedValue(
+          scopeId,
+          nodeAccessor,
+          data.checkedValue,
+          data.checkedValueChange,
+          data.value
+        );
+      } else if (data.valueChange) {
+        result += controllable_input_value(
+          scopeId,
+          nodeAccessor,
+          data.value,
+          data.valueChange
+        );
+      } else {
+        break;
+      }
+      skip = /^(?:value|checked(?:Value)?)(?:Change)?$|[\s/>"'=]/;
+      break;
+    case "select":
+    case "textarea":
+      if (data.value || data.valueChange) {
+        skip = /^value(?:Change)?$|[\s/>"'=]/;
+      }
+      break;
+    case "option":
+      if (data.value) {
+        result += optionValueAttr(data.value);
+        skip = /^value$|[\s/>"'=]/;
+      }
+      break;
+    case "details":
+    case "dialog":
+      if (data.openChange) {
+        result += controllable_detailsOrDialog_open(
+          scopeId,
+          nodeAccessor,
+          data.open,
+          data.openChange
+        );
+        skip = /^open(?:Change)?$|[\s/>"'=]/;
+      }
+      break;
+  }
+  for (const name in data) {
+    const val = data[name];
+    switch (name) {
+      case "class":
+        result += classAttr(val);
+        break;
+      case "style":
+        result += styleAttr(val);
+        break;
+      case "":
+      case "renderBody":
+        break;
+      default:
+        if (!isVoid(val)) {
+          if (isEventHandler(name)) {
+            if (!events) {
+              events = {};
+              writeScope(scopeId, {
+                [nodeAccessor + "~" /* EventAttributes */]: events
+              });
+            }
+            events[getEventHandlerName(name)] = val;
+          } else if (!skip.test(name)) {
+            result += nonVoidAttr(name, val);
+          }
+        }
+        break;
+    }
+  }
+  return result;
+}
+function partialAttrs(data, skip, nodeAccessor, scopeId, tagName) {
+  const partial = {};
+  for (const key in data) {
+    if (!skip[key]) partial[key] = data[key];
+  }
+  return attrs(partial, nodeAccessor, scopeId, tagName);
+}
+function writeControlledScope(type, scopeId, nodeAccessor, value, valueChange) {
+  writeScope(scopeId, {
+    [nodeAccessor + "=" /* ControlledType */]: type,
+    [nodeAccessor + ":" /* ControlledValue */]: value,
+    [nodeAccessor + ";" /* ControlledHandler */]: valueChange
+  });
+}
+function stringAttr(name, val) {
+  return val && ` ${name}=${escapeAttrValue(val)}`;
+}
+function nonVoidAttr(name, val) {
+  switch (typeof val) {
+    case "string":
+      return ` ${name + attrAssignment(val)}`;
+    case "boolean":
+      return ` ${name}`;
+    case "number":
+      return ` ${name}=${val}`;
+    case "object":
+      if (val instanceof RegExp) {
+        return ` ${name + attrAssignment(val.source)}`;
+      }
+      break;
+  }
+  return ` ${name + attrAssignment(val + "")}`;
+}
+function attrAssignment(val) {
+  return val ? `=${escapeAttrValue(val)}` : "";
+}
+var unsafeAttrChars = /["'>\s]/g;
+function escapeAttrValue(str) {
+  if (unsafeAttrChars.test(str)) {
+    const c = str[unsafeAttrChars.lastIndex - 1];
+    unsafeAttrChars.lastIndex = 0;
+    return c === '"' ? `'${str.replace(/'/g, "&#39;")}'` : `"${str.replace(/"/g, "&#34;")}"`;
+  }
+  return str;
+}
+
+// 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");
+
+// src/common/meta.ts
+var DEFAULT_RUNTIME_ID = "M";
+var DEFAULT_RENDER_ID = "_";
+
+// src/html/dynamic-tag.ts
+var voidElementsReg = /^(?:area|b(?:ase|r)|col|embed|hr|i(?:mg|nput)|link|meta|param|source|track|wbr)$/;
+function dynamicTagInput(scope, tag, input, renderBody, tagVar) {
+  if (!tag && !renderBody) return void 0;
+  const scopeId = getScopeId(scope);
+  write(`${markResumeScopeStart(scopeId)}`);
+  writeScope(scopeId, scope);
+  if (!tag) {
+    return renderBody();
+  }
+  if (typeof tag === "string") {
+    nextScopeId();
+    write(
+      `<${tag}${attrs(input, true ? `#${tag}/0` : 0, scopeId, tag)}>`
+    );
+    if (!voidElementsReg.test(tag)) {
+      if (tag === "textarea") {
+        if (renderBody) {
+          throw new Error(
+            "A dynamic tag rendering a `<textarea>` cannot have a `renderBody` and must use the `value` attribute instead."
+          );
+        }
+        write(
+          controllable_textarea_value(
+            scopeId,
+            true ? `#${tag}/0` : 0,
+            input.value,
+            input.valueChange
+          )
+        );
+      } else if (renderBody) {
+        if (tag === "select" && ("value" in input || "valueChange" in input)) {
+          controllable_select_value(
+            scopeId,
+            true ? `#${tag}/0` : 0,
+            input.value,
+            input.valueChange,
+            renderBody
+          );
+        } else {
+          renderBody();
+        }
+      }
+      write(`</${tag}>`);
+    } else if (renderBody) {
+      throw new Error(
+        `A renderBody was provided for a "${tag}" tag, which cannot have children.`
+      );
+    }
+    return null;
+  }
+  const renderer = getDynamicRenderer(tag);
+  if (true) {
+    if (typeof renderer !== "function") {
+      throw new Error(`Invalid renderer passed for dynamic tag: ${tag}`);
+    }
+  }
+  return renderer(renderBody ? { ...input, renderBody } : input, tagVar);
+}
+function dynamicTagArgs(scope, tag, args) {
+  if (!tag) return void 0;
+  const scopeId = getScopeId(scope);
+  write(`${markResumeScopeStart(scopeId)}`);
+  writeScope(scopeId, scope);
+  if (typeof tag === "string") {
+    nextScopeId();
+    write(
+      `<${tag}${attrs(args[0], true ? `#${tag}/0` : 0, scopeId, tag)}>`
+    );
+    if (!voidElementsReg.test(tag)) {
+      write(`</${tag}>`);
+    }
+    return void 0;
+  }
+  const renderer = getDynamicRenderer(tag);
+  if (true) {
+    if (typeof renderer !== "function") {
+      throw new Error(`Invalid renderer passed for dynamic tag: ${tag}`);
+    }
+  }
+  return renderer(...args);
+}
+var getDynamicRenderer = normalizeDynamicRenderer;
+var createRenderer = (fn) => fn;
+function patchDynamicTag(newGetDynamicRenderer, newCreateRenderer) {
+  getDynamicRenderer = newGetDynamicRenderer;
+  createRenderer = newCreateRenderer;
+}
+
+// src/html/compat.ts
+var K_TAGS_API_STATE = Symbol();
+var COMPAT_REGISTRY = /* @__PURE__ */ new WeakMap();
+var compat = {
+  fork,
+  write,
+  writeScript,
+  nextScopeId,
+  patchDynamicTag,
+  writeSetScopeForComponent(m5c) {
+    const scopeId = nextScopeId();
+    writeScope(scopeId, { m5c });
+    writeEffect(scopeId, SET_SCOPE_REGISTER_ID);
+  },
+  toJSON() {
+    let compatRegistered = COMPAT_REGISTRY.get(this);
+    if (!compatRegistered) {
+      const registered = getRegistered(this);
+      if (registered) {
+        const scopeId = getScopeId(registered.scope);
+        if (scopeId !== void 0) {
+          writeScope(scopeId, {});
+        }
+        COMPAT_REGISTRY.set(
+          this,
+          compatRegistered = [registered.id, scopeId]
+        );
+      }
+    }
+    return compatRegistered;
+  },
+  render(renderer, willRerender, classAPIOut, component, input) {
+    const $global2 = classAPIOut.global;
+    let state = $global2[K_TAGS_API_STATE] ||= getChunk()?.boundary.state;
+    if (!state) {
+      $global2.runtimeId ||= DEFAULT_RUNTIME_ID;
+      $global2.renderId ||= $global2.componentIdPrefix || DEFAULT_RENDER_ID;
+      $global2[K_TAGS_API_STATE] = state = new State2($global2);
+    }
+    const boundary = new Boundary(state);
+    let head = new Chunk(
+      boundary,
+      null,
+      null
+    );
+    head.render(() => {
+      if (willRerender) {
+        const scopeId = peekNextScopeId();
+        writeScope(scopeId, { m5c: component.id });
+        writeEffect(scopeId, SET_SCOPE_REGISTER_ID);
+      }
+      renderer(input);
+    });
+    const asyncOut = classAPIOut.beginAsync();
+    (boundary.onNext = () => {
+      if (boundary.done) {
+        if (boundary.signal.aborted) {
+          asyncOut.error(boundary.signal.reason);
+        } else {
+          queueMicrotask(() => {
+            const { scripts, html } = head = prepareChunk(head);
+            asyncOut.script(scripts);
+            asyncOut.write(html);
+            asyncOut.end();
+            head.html = head.scripts = "";
+          });
+        }
+      }
+    })();
+  },
+  registerRenderer(renderer, id) {
+    return register(
+      RENDERER_REGISTER_ID,
+      renderer,
+      register(id, () => {
+      })
+    );
+  }
+};
+
+// src/common/for.ts
+function forIn(obj, cb) {
+  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++);
+    }
+  }
+}
+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);
+  }
+}
+
+// src/html/for.ts
+function forOfBy(by, item, index) {
+  if (by) {
+    if (typeof by === "string") {
+      return item[by];
+    }
+    return by(item, index);
+  }
+  return index;
+}
+function forInBy(by, name, value) {
+  if (by) {
+    return by(name, value);
+  }
+  return name;
+}
+function forToBy(by, index) {
+  if (by) {
+    return by(index);
+  }
+  return index;
+}
+
+// src/html/template.ts
+var createTemplate = (templateId, renderer) => {
+  renderer.render = render;
+  renderer._ = renderer;
+  if (true) {
+    renderer.mount = () => {
+      throw new Error(
+        `mount() is not implemented for the HTML compilation of a Marko template`
+      );
+    };
+  }
+  return register2(renderer, templateId);
+};
+function render(input = {}) {
+  let { $global: $global2 } = input;
+  if ($global2) {
+    ({ $global: $global2, ...input } = input);
+    $global2 = {
+      runtimeId: DEFAULT_RUNTIME_ID,
+      renderId: DEFAULT_RENDER_ID,
+      ...$global2
+    };
+  } else {
+    $global2 = {
+      runtimeId: DEFAULT_RUNTIME_ID,
+      renderId: DEFAULT_RENDER_ID
+    };
+  }
+  const head = new Chunk(
+    new Boundary(new State2($global2), $global2.signal),
+    null,
+    null
+  );
+  head.render(this, input);
+  return new ServerRenderResult(head);
+}
+var ServerRenderResult = class {
+  #head;
+  #cachedPromise = null;
+  constructor(head) {
+    this.#head = head;
+  }
+  [Symbol.asyncIterator]() {
+    let resolve;
+    let reject;
+    let value = "";
+    let done = false;
+    let aborted = false;
+    let reason;
+    const boundary = this.#read(
+      (html) => {
+        value += html;
+        if (resolve) {
+          resolve({ value, done });
+          value = "";
+        }
+      },
+      (err) => {
+        aborted = true;
+        reason = err;
+        if (reject) {
+          reject(err);
+        }
+      },
+      () => {
+        done = true;
+        if (resolve) {
+          resolve({ value, done: !value });
+        }
+      }
+    );
+    return {
+      next() {
+        if (value) {
+          const result = { value, done: false };
+          value = "";
+          return Promise.resolve(result);
+        }
+        return done ? Promise.resolve({ value: "", done }) : aborted ? Promise.reject(reason) : new Promise(exec);
+      },
+      throw(error) {
+        if (!(done || aborted)) {
+          boundary?.abort(error);
+        }
+        return Promise.resolve({
+          value: "",
+          done: true
+        });
+      },
+      return(value2) {
+        if (!(done || aborted)) {
+          boundary?.abort(new Error("Iterator returned before consumed."));
+        }
+        return Promise.resolve({
+          value: value2,
+          done: true
+        });
+      }
+    };
+    function exec(_resolve, _reject) {
+      resolve = _resolve;
+      reject = _reject;
+    }
+  }
+  pipe(stream) {
+    this.#read(
+      (html) => {
+        stream.write(html);
+      },
+      (err) => {
+        const socket = "socket" in stream && stream.socket;
+        if (socket && typeof socket.destroySoon === "function") {
+          socket.destroySoon();
+        }
+        if (!stream.emit?.("error", err)) {
+          throw err;
+        }
+      },
+      () => {
+        stream.end();
+      }
+    );
+  }
+  toReadable() {
+    return new ReadableStream({
+      start: (ctrl) => {
+        this.#read(
+          (html) => {
+            ctrl.enqueue(html);
+          },
+          (err) => {
+            ctrl.error(err);
+          },
+          () => {
+            ctrl.close();
+          }
+        );
+      }
+    });
+  }
+  then(onfulfilled, onrejected) {
+    return this.#promise().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#promise().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#promise().finally(onfinally);
+  }
+  #promise() {
+    return this.#cachedPromise ||= new Promise((resolve, reject) => {
+      let head = this.#head;
+      this.#head = null;
+      if (!head) {
+        return reject(new Error("Cannot read from a consumed render result"));
+      }
+      const { boundary } = head;
+      (boundary.onNext = () => {
+        if (boundary.done) {
+          if (boundary.signal.aborted) {
+            reject(boundary.signal.reason);
+          } else {
+            head = prepareChunk(head);
+            if (boundary.done) resolve(flushChunk(head, true));
+          }
+        }
+      })();
+    });
+  }
+  #read(onWrite, onAbort, onClose) {
+    let tick2 = true;
+    let head = this.#head;
+    this.#head = null;
+    if (!head) {
+      onAbort(new Error("Cannot read from a consumed render result"));
+      return;
+    }
+    const { boundary } = head;
+    const onNext = boundary.onNext = (write2) => {
+      if (write2 || boundary.done) {
+        if (boundary.signal.aborted) {
+          if (!tick2) offTick(onNext);
+          onAbort(boundary.signal.reason);
+          return;
+        }
+        head = prepareChunk(head);
+      }
+      if (write2 || boundary.done) {
+        const html = flushChunk(head, boundary.done);
+        if (html) onWrite(html);
+        if (boundary.done) {
+          if (!tick2) offTick(onNext);
+          onClose();
+        } else {
+          tick2 = true;
+        }
+      } else if (tick2) {
+        tick2 = false;
+        queueTick(onNext);
+      }
+    };
+    onNext();
+    return boundary;
+  }
+  toString() {
+    const head = this.#head;
+    if (!head) throw new Error("Cannot read from a consumed render result");
+    if (head.next) throw new Error("Cannot fork in sync mode");
+    this.#head = null;
+    return flushChunk(prepareChunk(head), true);
+  }
+};
+export {
+  $global,
+  attr,
+  attrTag,
+  attrTags,
+  attrs,
+  classAttr,
+  compat,
+  controllable_detailsOrDialog_open,
+  controllable_input_checked,
+  controllable_input_checkedValue,
+  controllable_input_value,
+  controllable_select_value,
+  controllable_textarea_value,
+  createRenderer,
+  createTemplate,
+  dynamicTagArgs,
+  dynamicTagInput,
+  ensureScopeWithId,
+  escapeScript,
+  escapeStyle,
+  escapeXML,
+  forIn,
+  forInBy,
+  forOf,
+  forOfBy,
+  forTo,
+  forToBy,
+  fork,
+  getScopeById,
+  markResumeCleanup,
+  markResumeControlEnd,
+  markResumeControlSingleNodeEnd,
+  markResumeNode,
+  markResumeScopeStart,
+  nextScopeId,
+  nextTagId,
+  nodeRef,
+  normalizeDynamicRenderer,
+  optionValueAttr,
+  partialAttrs,
+  peekNextScope,
+  register2 as register,
+  styleAttr,
+  toString,
+  tryCatch,
+  tryPlaceholder,
+  write,
+  writeEffect,
+  writeExistingScope,
+  writeScope,
+  writeTrailers
+};