@marko/runtime-tags 0.1.1

package/dist/html.mjs

@@ -0,0 +1,876 @@
+// src/html/content.ts
+function toString(val) {
+  return val || val === 0 ? val + "" : "";
+}
+var escapeXML = escapeIfNeeded((val) => {
+  let result = "", lastPos = 0;
+  for (let i = 0, len = val.length; i < len; i++) {
+    let replacement;
+    switch (val[i]) {
+      case "<":
+        replacement = "&lt;";
+        break;
+      case "&":
+        replacement = "&amp;";
+        break;
+      default:
+        continue;
+    }
+    result += val.slice(lastPos, i) + replacement, lastPos = i + 1;
+  }
+  return lastPos ? result + val.slice(lastPos) : val;
+}), escapeScript = escapeIfNeeded(escapeTagEnding("script")), escapeStyle = escapeIfNeeded(escapeTagEnding("style"));
+function escapeTagEnding(tagName) {
+  let openTag = `</${tagName}`, escaped = `<\\/${tagName}`;
+  return (val) => {
+    let result = "", lastPos = 0, i = val.indexOf(openTag, lastPos);
+    for (; i !== -1; )
+      result += val.slice(lastPos, i) + escaped, lastPos = i + 1, i = val.indexOf(openTag, lastPos);
+    return lastPos ? result + val.slice(lastPos) : val;
+  };
+}
+function escapeAttrValue(val) {
+  let len = val.length, i = 0;
+  do
+    switch (val[i]) {
+      case '"':
+        return quoteValue(val, i + 1, "'", "&#39;");
+      case "'":
+      case ">":
+      case " ":
+      case "	":
+      case `
+`:
+      case "\r":
+      case "\f":
+        return quoteValue(val, i + 1, '"', "&#34;");
+      default:
+        i++;
+        break;
+    }
+  while (i < len);
+  return val;
+}
+function escapeIfNeeded(escape) {
+  return (val) => {
+    if (!val && val !== 0)
+      return "&zwj;";
+    switch (typeof val) {
+      case "string":
+        return escape(val);
+      case "boolean":
+        return "true";
+      case "number":
+        return val + "";
+      default:
+        return escape(val + "");
+    }
+  };
+}
+function quoteValue(val, startPos, quote2, escaped) {
+  let result = quote2, lastPos = 0;
+  for (let i = startPos, len = val.length; i < len; i++)
+    val[i] === quote2 && (result += val.slice(lastPos, i) + escaped, lastPos = i + 1);
+  return result + (lastPos ? val.slice(lastPos) : val) + quote2;
+}
+
+// src/common/helpers.ts
+function classValue(value) {
+  return toDelimitedString(value, " ", stringifyClassObject);
+}
+function stringifyClassObject(name, value) {
+  return isVoid(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 isVoid(value) ? "" : (typeof value == "number" && value && !NON_DIMENSIONAL.test(name) && (value += "px"), `${name}:${value}`);
+}
+function toDelimitedString(val, delimiter, stringify) {
+  switch (typeof val) {
+    case "string":
+      return val;
+    case "object":
+      if (val !== null) {
+        let result = "", curDelimiter = "";
+        if (Array.isArray(val))
+          for (let v of val) {
+            let part = toDelimitedString(v, delimiter, stringify);
+            part !== "" && (result += curDelimiter + part, curDelimiter = delimiter);
+          }
+        else
+          for (let name in val) {
+            let v = val[name], part = stringify(name, v);
+            part !== "" && (result += curDelimiter + part, curDelimiter = delimiter);
+          }
+        return result;
+      }
+  }
+  return "";
+}
+function isVoid(value) {
+  return value == null || value === !1;
+}
+
+// src/html/attrs.ts
+function classAttr(val) {
+  return stringAttr("class", classValue(val));
+}
+function styleAttr(val) {
+  return stringAttr("style", styleValue(val));
+}
+function attr(name, val) {
+  return isVoid(val) ? "" : nonVoidUntypedAttr(name, val);
+}
+function attrs(data) {
+  let result = "";
+  for (let name in data) {
+    if (/^on[A-Z-]/.test(name))
+      continue;
+    let val = data[name];
+    switch (name) {
+      case "class":
+        result += classAttr(val);
+        break;
+      case "style":
+        result += styleAttr(val);
+        break;
+      case "renderBody":
+        break;
+      default:
+        isVoid(val) || isInvalidAttrName(name) || (result += nonVoidUntypedAttr(name, val));
+    }
+  }
+  return result;
+}
+function stringAttr(name, val) {
+  return val && ` ${name}=${escapeAttrValue(val)}`;
+}
+function nonVoidUntypedAttr(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}=${escapeAttrValue(val.source)}`;
+    default:
+      return ` ${name + attrAssignment(val + "")}`;
+  }
+}
+function attrAssignment(val) {
+  return val ? `=${escapeAttrValue(val)}` : "";
+}
+function isInvalidAttrName(name) {
+  for (let i = name.length; i--; )
+    if (name[i] === ">")
+      return !0;
+  return !1;
+}
+
+// src/html/serializer.ts
+var { hasOwnProperty } = Object.prototype, PARAM_BIND = "b", PARAM_SCOPE = "s", REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_", REF_START_CHARS_LEN = REF_START_CHARS.length, REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_", REF_CHARS_LEN = REF_CHARS.length, SYMBOL_REGISTRY_ID = Symbol("REGISTRY_ID"), SYMBOL_SCOPE = Symbol("SCOPE"), SYMBOL_SERIALIZE = Symbol("SERIALIZE"), Scope = class {
+}, serializedScope = (scopeId) => {
+  let scope = new Scope();
+  return makeSerializable(scope, (s, a) => {
+    s.value(s.scopeLookup.get(scopeId), a);
+  });
+};
+function register(entry, registryId, scopeId) {
+  return entry[SYMBOL_REGISTRY_ID] = registryId, entry[SYMBOL_SCOPE] = scopeId, entry;
+}
+function getRegistryInfo(entry) {
+  return [entry[SYMBOL_REGISTRY_ID], entry[SYMBOL_SCOPE]];
+}
+function makeSerializable(object, serialize) {
+  return object[SYMBOL_SERIALIZE] = serialize, object;
+}
+var Serializer = class {
+  // TODO: hoist these back out?
+  STACK = [];
+  BUFFER = [""];
+  ASSIGNMENTS = /* @__PURE__ */ new Map();
+  INDEX_OR_REF = /* @__PURE__ */ new WeakMap();
+  REF_COUNT = 0;
+  // These stay
+  PARENTS = /* @__PURE__ */ new WeakMap();
+  KEYS = /* @__PURE__ */ new WeakMap();
+  VALUES = /* @__PURE__ */ new Map();
+  scopeLookup;
+  constructor(scopeLookup) {
+    this.scopeLookup = scopeLookup, this.BUFFER.pop();
+  }
+  stringify(root) {
+    if (this.writeProp(root, "")) {
+      let { BUFFER, REF_COUNT, ASSIGNMENTS, INDEX_OR_REF } = this, result = BUFFER[0];
+      for (let i = 1, len = BUFFER.length; i < len; i++)
+        result += BUFFER[i];
+      if (REF_COUNT) {
+        if (ASSIGNMENTS.size) {
+          let ref = INDEX_OR_REF.get(root);
+          typeof ref == "number" && (ref = toRefParam(this.REF_COUNT++), result = ref + "=" + result);
+          for (let [assignmentRef, assignments] of ASSIGNMENTS)
+            result += "," + assignments + assignmentRef;
+          result += "," + ref, this.ASSIGNMENTS = /* @__PURE__ */ new Map();
+        }
+        result = "(" + PARAM_BIND + "," + PARAM_SCOPE + "," + this.refParamsString() + ")=>(" + result + ")";
+      } else
+        root && root.constructor === Object && (result = "(" + PARAM_BIND + "," + PARAM_SCOPE + ")=>(" + result + ")");
+      return BUFFER.length = 0, this.INDEX_OR_REF = /* @__PURE__ */ new WeakMap(), result;
+    }
+    return "void 0";
+  }
+  code(code) {
+    return this.BUFFER.push(code), this;
+  }
+  value(value, accessor = "") {
+    return !this.writeProp(value, accessor) && !this.STACK.includes(value) && this.BUFFER.push("void 0"), this;
+  }
+  writeProp(cur, accessor) {
+    let { BUFFER } = this;
+    switch (typeof cur) {
+      case "string":
+        BUFFER.push(quote(cur, 0));
+        break;
+      case "number":
+        BUFFER.push(cur + "");
+        break;
+      case "boolean":
+        BUFFER.push(cur ? "!0" : "!1");
+        break;
+      case "function":
+      case "object":
+        if (cur === null)
+          BUFFER.push("null");
+        else {
+          let ref = this.getRef(cur, accessor);
+          switch (ref) {
+            case !0:
+              return !1;
+            case !1:
+              switch (cur.constructor) {
+                case Object:
+                  this.writeObject(cur);
+                  break;
+                case Array:
+                  this.writeArray(cur);
+                  break;
+                case Date:
+                  BUFFER.push(
+                    'new Date("' + cur.toISOString() + '")'
+                  );
+                  break;
+                case RegExp:
+                  BUFFER.push(cur + "");
+                  break;
+                case Map:
+                  BUFFER.push("new Map("), this.writeArray(
+                    Array.from(cur)
+                  ), BUFFER.push(")");
+                  break;
+                case Set:
+                  BUFFER.push("new Set("), this.writeArray(
+                    Array.from(cur)
+                  ), BUFFER.push(")");
+                  break;
+                case void 0:
+                  BUFFER.push("Object.assign(Object.create(null),"), this.writeObject(cur), BUFFER.push("))");
+                  break;
+                default:
+                  return this.writeRegistered(
+                    cur,
+                    accessor
+                  );
+              }
+              break;
+            default:
+              BUFFER.push(ref);
+              break;
+          }
+        }
+        break;
+      default:
+        return !1;
+    }
+    return !0;
+  }
+  writeRegistered(value, accessor) {
+    let {
+      [SYMBOL_REGISTRY_ID]: registryId,
+      [SYMBOL_SCOPE]: scopeId,
+      [SYMBOL_SERIALIZE]: serialize
+    } = value, { BUFFER } = this;
+    if (registryId) {
+      let scope = scopeId !== void 0 ? this.scopeLookup.get(scopeId) ?? !1 : void 0, ref = scope && this.getRef(scope, "");
+      if (ref === !0) {
+        let { STACK, INDEX_OR_REF, ASSIGNMENTS } = this, parent = STACK[STACK.length - 1], parentRef = INDEX_OR_REF.get(parent), resolvedRef = INDEX_OR_REF.get(scope);
+        return ASSIGNMENTS.set(
+          `${PARAM_BIND}("${registryId}",${resolvedRef})`,
+          (ASSIGNMENTS.get(ref) || "") + toAssignment(parentRef, accessor) + "="
+        ), !1;
+      } else {
+        if (ref === !1)
+          throw new Error(
+            "The scope has not yet been defined. This needs to be fixed in the serializer."
+          );
+        return BUFFER.push(`${PARAM_BIND}("${registryId}"${ref ? "," + ref : ""})`), !0;
+      }
+    } else if (serialize) {
+      let prevSize = BUFFER.length;
+      return serialize(this, accessor), prevSize !== BUFFER.length;
+    }
+    return !1;
+  }
+  writeObject(obj) {
+    let { STACK, BUFFER } = this, sep = "{";
+    STACK.push(obj);
+    for (let key in obj)
+      if (hasOwnProperty.call(obj, key)) {
+        let val = obj[key], escapedKey = toObjectKey(key);
+        BUFFER.push(sep + escapedKey + ":"), this.writeProp(val, escapedKey) ? sep = "," : BUFFER.pop();
+      }
+    sep === "{" ? BUFFER.push("{}") : BUFFER.push("}"), STACK.pop();
+  }
+  writeArray(arr) {
+    let { STACK, BUFFER } = this;
+    BUFFER.push("["), STACK.push(arr), this.writeProp(arr[0], 0);
+    for (let i = 1, len = arr.length; i < len; i++)
+      BUFFER.push(","), this.writeProp(arr[i], i);
+    STACK.pop(), BUFFER.push("]");
+  }
+  getRef(cur, accessor) {
+    let { STACK, BUFFER, INDEX_OR_REF, ASSIGNMENTS, PARENTS, KEYS } = this, ref = INDEX_OR_REF.get(cur);
+    if (ref === void 0) {
+      INDEX_OR_REF.set(cur, BUFFER.length);
+      let knownParent = PARENTS.get(cur);
+      if (knownParent === void 0) {
+        let parent = STACK[STACK.length - 1];
+        return parent && (PARENTS.set(cur, parent), KEYS.set(cur, toObjectKey(accessor))), !1;
+      } else {
+        let ref2 = "";
+        for (; knownParent; )
+          ref2 = toPropertyAccess(KEYS.get(cur)) + ref2, knownParent = PARENTS.get(cur = knownParent);
+        return PARAM_SCOPE + ref2;
+      }
+    }
+    if (typeof ref == "number" && (ref = this.insertAndGetRef(cur, ref)), STACK.includes(cur)) {
+      let parent = STACK[STACK.length - 1], parentRef = INDEX_OR_REF.get(parent);
+      return typeof parentRef == "number" && (parentRef = this.insertAndGetRef(parent, parentRef)), accessor !== "" && ASSIGNMENTS.set(
+        ref,
+        (ASSIGNMENTS.get(ref) || "") + toAssignment(parentRef, accessor) + "="
+      ), !0;
+    }
+    return ref;
+  }
+  insertAndGetRef(obj, pos) {
+    let ref = toRefParam(this.REF_COUNT++);
+    return this.INDEX_OR_REF.set(obj, ref), pos ? this.BUFFER[pos - 1] += ref + "=" : this.BUFFER[pos] = ref + "=" + this.BUFFER[pos], ref;
+  }
+  refParamsString() {
+    let result = REF_START_CHARS[0];
+    for (let i = 1; i < this.REF_COUNT; i++)
+      result += "," + toRefParam(i);
+    return this.REF_COUNT = 0, result;
+  }
+};
+function toAssignment(parent, key) {
+  return parent + toPropertyAccess(key);
+}
+function toPropertyAccess(key) {
+  return typeof key == "number" || key[0] === '"' ? "[" + key + "]" : "." + key;
+}
+function toObjectKey(name) {
+  if (typeof name != "string")
+    return name;
+  let char = name[0];
+  if (char >= "0" && char <= "9") {
+    for (let i = 1, len = name.length; i < len; i++)
+      if (char = name[i], !(char >= "0" && char <= "9"))
+        return quote(name, i);
+    return parseInt(name, 10);
+  } else
+    for (let i = 0, len = name.length; i < len; i++)
+      if (char = name[i], !(char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "$" || char === "_"))
+        return quote(name, i);
+  return name;
+}
+function quote(str, startPos) {
+  let result = "", lastPos = 0;
+  for (let i = startPos, len = str.length; i < len; i++) {
+    let replacement;
+    switch (str[i]) {
+      case '"':
+        replacement = '\\"';
+        break;
+      case "\\":
+        replacement = "\\\\";
+        break;
+      case "<":
+        replacement = "\\x3C";
+        break;
+      case `
+`:
+        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 ? result = str : result += str.slice(lastPos), '"' + result + '"';
+}
+function toRefParam(index) {
+  let mod = index % REF_START_CHARS_LEN, ref = REF_START_CHARS[mod];
+  for (index = (index - mod) / REF_START_CHARS_LEN; index > 0; )
+    mod = index % REF_CHARS_LEN, ref += REF_CHARS[mod], index = (index - mod) / REF_CHARS_LEN;
+  return ref;
+}
+
+// src/html/reorder-runtime.ts
+function reorder_runtime_default(id, doc, walker, node, replacementNode, targetParent, targetNode, refNode, nextNode, runtimePrefix) {
+  for (runtimePrefix = "RUNTIME_ID$", id = runtimePrefix + id, doc = document, walker = doc[runtimePrefix + "w"] || (doc[runtimePrefix + "w"] = doc.createTreeWalker(
+    doc,
+    128
+  )); node = walker.nextNode(); )
+    node.data.indexOf(runtimePrefix) === 0 && (walker[node.data] = node);
+  for (replacementNode = doc.getElementById(id), targetNode = walker[id], targetParent = targetNode.parentNode; refNode = replacementNode.firstChild; )
+    targetParent.insertBefore(refNode, targetNode);
+  for (nextNode = replacementNode.parentNode, nextNode.removeChild(replacementNode.nextSibling), nextNode.removeChild(replacementNode), refNode = walker[id + "/"]; targetNode && (nextNode = targetNode.nextSibling, targetParent.removeChild(targetNode) !== refNode); )
+    targetNode = nextNode;
+}
+
+// src/html/writer.ts
+var runtimeId = "M" /* DefaultRuntimeId */, reorderRuntimeString = String(reorder_runtime_default).replace(
+  "RUNTIME_ID",
+  runtimeId
+), $_buffer = null, $_streamData = null;
+function createRenderFn(renderer) {
+  return (stream, input = {}, $global, streamState = {}) => {
+    let remainingChildren = 1, originalBuffer = $_buffer, originalStreamState = $_streamData, reject = (err) => {
+      stream.emit("error", err);
+    }, async = (complete) => {
+      remainingChildren += complete ? -1 : 1, remainingChildren || setImmediate(() => stream.end());
+    };
+    $_buffer = createInitialBuffer(stream), streamState.global = $global, $_streamData = createStreamState(streamState), $_buffer.onReject = reject, $_buffer.onAsync = async;
+    try {
+      scheduleFlush(), renderer(input), async(!0);
+    } catch (err) {
+      reject(err);
+    } finally {
+      $_buffer = originalBuffer, $_streamData = originalStreamState;
+    }
+  };
+}
+function write(data) {
+  $_buffer.content += data;
+}
+var TARGET_BUFFER_SIZE = 64e3;
+function maybeFlush() {
+  !$_buffer.prev && $_buffer.content.length > TARGET_BUFFER_SIZE;
+}
+function scheduleFlush() {
+  let buffer = $_buffer, streamState = $_streamData;
+  buffer.prev || setImmediate(() => flushToStream(buffer, streamState));
+}
+function flushToStream(buffer, streamState) {
+  for (; buffer.prev; )
+    buffer = buffer.prev;
+  if (buffer.disabled)
+    return;
+  let stream = buffer.stream, { content, calls, scopes } = buffer;
+  for (buffer.flushed = !0; !buffer.pending && buffer.next; )
+    clearBuffer(buffer), buffer = buffer.next, buffer.prev = null, buffer.flushed = !0, content += buffer.content, calls += buffer.calls, buffer.scopes && (scopes ? Object.assign(scopes, buffer.scopes) : scopes = buffer.scopes);
+  let data = content + getResumeScript(calls, scopes, streamState);
+  data && (stream.write(data), stream.flush?.()), clearBuffer(buffer);
+}
+function createStreamState(state) {
+  return state.scopeId ??= 0, state.tagId ??= 0, state.placeholderId ??= 0, state.scopeLookup ??= /* @__PURE__ */ new Map(), state.runtimeFlushed ??= !1, state;
+}
+function createNextBuffer(prevBuffer) {
+  let newBuffer = {
+    stream: prevBuffer.stream,
+    pending: !1,
+    flushed: !1,
+    disabled: !1,
+    prev: prevBuffer,
+    next: prevBuffer?.next ?? null,
+    content: "",
+    calls: "",
+    scopes: null,
+    onReject: prevBuffer.onReject,
+    onAsync: prevBuffer.onAsync
+  };
+  return prevBuffer.next && (prevBuffer.next.prev = prevBuffer), prevBuffer.next = newBuffer, newBuffer;
+}
+function createDetatchedBuffer(parentBuffer) {
+  return {
+    stream: parentBuffer.stream,
+    pending: !1,
+    flushed: !1,
+    disabled: !0,
+    prev: null,
+    next: null,
+    content: "",
+    calls: "",
+    scopes: null,
+    onReject: parentBuffer.onReject,
+    onAsync: parentBuffer.onAsync
+  };
+}
+function createInitialBuffer(stream) {
+  return {
+    stream,
+    pending: !1,
+    flushed: !1,
+    disabled: !1,
+    prev: null,
+    next: null,
+    content: "",
+    calls: "",
+    scopes: null,
+    onReject: void 0,
+    onAsync: void 0
+  };
+}
+async function fork(promise, renderResult) {
+  let originalBuffer = $_buffer, originalStreamState = $_streamData;
+  scheduleFlush(), $_buffer.pending = !0, $_buffer.onAsync?.(!1), $_buffer = createNextBuffer($_buffer);
+  try {
+    let result;
+    try {
+      result = await promise, originalBuffer.pending = !1;
+    } finally {
+      $_buffer = originalBuffer, $_streamData = originalStreamState, scheduleFlush();
+    }
+    renderResult(result);
+  } catch (err) {
+    $_buffer.onReject?.(err);
+  } finally {
+    $_buffer.onAsync?.(!0), clearScope();
+  }
+}
+function tryCatch(renderBody, renderError) {
+  let id = nextPlaceholderId(), err = null, originalBuffer = $_buffer, tryBuffer = createDetatchedBuffer(originalBuffer), finalTryBuffer;
+  tryBuffer.onReject = (asyncErr) => {
+    let errorBuffer = createDetatchedBuffer(originalBuffer);
+    $_buffer = errorBuffer, renderError(asyncErr), replaceBuffers(
+      id,
+      tryBuffer,
+      finalTryBuffer,
+      errorBuffer,
+      $_buffer
+    );
+  };
+  try {
+    $_buffer = tryBuffer, renderBody();
+  } catch (_err) {
+    err = _err;
+  } finally {
+    err ? ($_buffer = originalBuffer, renderError(err)) : (tryBuffer.disabled = !1, originalBuffer.next = tryBuffer, tryBuffer.prev = originalBuffer, $_buffer !== tryBuffer && (tryBuffer.content = `<!${marker(id)}>` + tryBuffer.content, markReplaceEnd(id), finalTryBuffer = $_buffer, $_buffer = createNextBuffer(finalTryBuffer)), $_buffer.onReject = originalBuffer.onReject);
+  }
+}
+function tryPlaceholder(renderBody, renderPlaceholder) {
+  let originalBuffer = $_buffer, asyncBuffer = createDetatchedBuffer(originalBuffer), id, placeholderBuffer, finalPlaceholderBuffer, finalAsyncBuffer, remainingChildren = 0, remainingPlaceholders = 0;
+  asyncBuffer.onAsync = (complete, isPlaceholder) => {
+    let delta = complete ? -1 : 1;
+    isPlaceholder ? remainingPlaceholders += delta : remainingChildren += delta, remainingChildren || (isPlaceholder || replaceBuffers(
+      id,
+      placeholderBuffer,
+      finalPlaceholderBuffer,
+      asyncBuffer,
+      finalAsyncBuffer
+    ), remainingPlaceholders || originalBuffer.onAsync?.(!0, !0));
+  }, $_buffer = asyncBuffer, renderBody(), $_buffer === asyncBuffer ? (originalBuffer.next = asyncBuffer, asyncBuffer.prev = originalBuffer, asyncBuffer.disabled = !1, asyncBuffer.onAsync = originalBuffer.onAsync) : (id = nextPlaceholderId(), placeholderBuffer = createNextBuffer(originalBuffer), finalAsyncBuffer = $_buffer, $_buffer = placeholderBuffer, markReplaceStart(id), renderPlaceholder(), markReplaceEnd(id), finalPlaceholderBuffer = $_buffer, $_buffer = createNextBuffer(finalPlaceholderBuffer), originalBuffer.onAsync?.(!1, !0));
+}
+function clearBuffer(buffer) {
+  buffer.content = "", buffer.calls = "", buffer.scopes = null;
+}
+function clearScope() {
+  $_buffer = $_streamData = null;
+}
+function markReplaceStart(id) {
+  return $_buffer.content += `<!${marker(id)}>`;
+}
+function markReplaceEnd(id) {
+  return $_buffer.content += `<!${marker(id)}/>`;
+}
+function replaceBuffers(id, placeholderStart, placeholderEnd, replacementStart, replacementEnd) {
+  if (placeholderStart.flushed) {
+    addReplacementWrapper(id, replacementStart, replacementEnd);
+    let next = placeholderEnd.next;
+    if (placeholderEnd.flushed)
+      for (; next && !next.pending && next.flushed; )
+        next = next.next;
+    next && (replacementStart.next = next, next.prev = replacementEnd), $_buffer = replacementStart, scheduleFlush();
+  } else {
+    let prev = placeholderStart.prev, next = placeholderEnd.next;
+    prev && (prev.next = replacementStart, replacementStart.prev = prev), next && (next.prev = replacementEnd, replacementEnd.next = next);
+  }
+  replacementStart.disabled = !1;
+}
+function addReplacementWrapper(id, replacementStart, replacementEnd) {
+  let runtimeCall = runtimeId + "$r" /* VarReorderRuntime */;
+  $_streamData.runtimeFlushed || (runtimeCall = `(${runtimeCall}=${reorderRuntimeString})`, $_streamData.runtimeFlushed = !0), replacementStart.content = `<t id="${marker(id)}">` + replacementStart.content, replacementEnd.content += `</t><script>${runtimeCall}(${id})</script>`;
+}
+function marker(id) {
+  return `${runtimeId}$${id}`;
+}
+function nextTagId() {
+  return "s" + $_streamData.tagId++;
+}
+function nextPlaceholderId() {
+  return $_streamData.placeholderId++;
+}
+function nextScopeId() {
+  return $_streamData.scopeId++;
+}
+function peekNextScopeId() {
+  return $_streamData.scopeId;
+}
+function peekSerializedScope() {
+  return serializedScope(peekNextScopeId());
+}
+function writeEffect(scopeId, fnId) {
+  $_buffer.calls += `${scopeId},"${fnId}",`;
+}
+function writeScope(scopeId, scope, assignTo = $_streamData.scopeLookup.get(scopeId)) {
+  assignTo !== void 0 && (Array.isArray(assignTo) ? assignTo.push(scope) : scope = Object.assign(assignTo, scope)), $_buffer.scopes ??= {
+    $global: getFilteredGlobals($_streamData.global)
+  }, $_buffer.scopes[scopeId] = scope, $_streamData.scopeLookup.set(scopeId, scope);
+}
+function markResumeNode(scopeId, index) {
+  return `<!${runtimeId}*${scopeId} ${index}>`;
+}
+function markResumeScopeStart(scopeId, key) {
+  return `<!${runtimeId}[${scopeId}${key ? " " + key : ""}>`;
+}
+function markResumeControlEnd(scopeId, index) {
+  return `<!${runtimeId}]${scopeId} ${index}>`;
+}
+function markResumeControlSingleNodeEnd(scopeId, index, childScopeIds) {
+  return `<!${runtimeId}|${scopeId} ${index} ${childScopeIds ?? ""}>`;
+}
+function getResumeScript(calls, scopes, streamState) {
+  if (calls || scopes) {
+    let isFirstFlush, serializer = streamState.serializer;
+    return (isFirstFlush = !serializer) && (serializer = streamState.serializer = new Serializer(
+      streamState.scopeLookup
+    )), `<script>${isFirstFlush ? `(${runtimeId + "$h" /* VarResume */}=[])` : runtimeId + "$h" /* VarResume */}.push(${serializer.stringify(scopes)},[${calls}])</script>`;
+  }
+  return "";
+}
+function getFilteredGlobals($global) {
+  if (!$global)
+    return;
+  let serializedGlobals = $global.serializedGlobals;
+  if (!serializedGlobals)
+    return;
+  let filtered;
+  if (Array.isArray(serializedGlobals))
+    for (let key of serializedGlobals) {
+      let value = $global[key];
+      value !== void 0 && (filtered ? filtered[key] = value : filtered = { [key]: value });
+    }
+  else
+    for (let key in serializedGlobals)
+      if (serializedGlobals[key]) {
+        let value = $global[key];
+        value !== void 0 && (filtered ? filtered[key] = value : filtered = { [key]: value });
+      }
+  return filtered;
+}
+
+// src/html/dynamic-tag.ts
+var voidElements = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function dynamicTagInput(tag, input, renderBody) {
+  if (!tag && !renderBody)
+    return;
+  let futureScopeId = peekNextScopeId(), futureScope = serializedScope(futureScopeId);
+  if (write(`${markResumeScopeStart(futureScopeId)}`), writeScope(futureScopeId, {}), !tag)
+    return renderBody(), futureScope;
+  if (typeof tag == "string")
+    return nextScopeId(), write(`<${tag}${attrs(input)}>`), voidElements.has(tag) || (renderBody && renderBody(), write(`</${tag}>`)), futureScope;
+  let renderer = getDynamicRenderer(tag);
+  if (typeof renderer == "function")
+    return renderer(renderBody ? { ...input, renderBody } : input), futureScope;
+}
+function dynamicTagArgs(tag, args) {
+  if (!tag)
+    return;
+  let futureScopeId = peekNextScopeId(), futureScope = serializedScope(futureScopeId);
+  if (write(`${markResumeScopeStart(futureScopeId)}`), writeScope(futureScopeId, {}), typeof tag == "string")
+    return nextScopeId(), write(`<${tag}${attrs(args[0])}></${tag}>`), futureScope;
+  let renderer = getDynamicRenderer(tag);
+  if (typeof renderer == "function")
+    return renderer(...args), futureScope;
+}
+var getDynamicRenderer = (tag) => tag._ || tag.renderBody || tag, createRenderer = (fn) => fn;
+function patchDynamicTag(newGetDynamicRenderer, newCreateRenderer) {
+  getDynamicRenderer = newGetDynamicRenderer, createRenderer = newCreateRenderer;
+}
+
+// src/html/template.ts
+var createTemplate = (renderer, id = "") => register(new ServerTemplate(renderer), id);
+function deferred() {
+  let resolve, reject;
+  return { promise: new Promise((res, rej) => {
+    resolve = res, reject = rej;
+  }), resolve, reject };
+}
+async function stringFromAsync(iterable) {
+  let str = "";
+  for await (let part of iterable)
+    str += part;
+  return str;
+}
+var ServerRenderResult = class {
+  #iterable;
+  #promise;
+  constructor(iterable) {
+    this.#iterable = iterable;
+  }
+  [Symbol.asyncIterator]() {
+    return this.#iterable;
+  }
+  [Symbol.toStringTag] = "RenderResult";
+  then(onfulfilled, onrejected) {
+    return (this.#promise ||= stringFromAsync(this.#iterable)).then(
+      onfulfilled,
+      onrejected
+    );
+  }
+  catch(onrejected) {
+    return this.then(void 0, onrejected);
+  }
+  finally(onfinally) {
+    return this.then(void 0, void 0).finally(onfinally);
+  }
+  toReadable() {
+    return new ReadableStream({
+      start: async (controller) => {
+        try {
+          for await (let chunk of this.#iterable)
+            chunk && controller.enqueue(chunk);
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+  }
+}, ServerTemplate = class {
+  #writeTo;
+  _;
+  constructor(renderer) {
+    this._ = renderer, this.#writeTo = createRenderFn(renderer);
+  }
+  mount() {
+    throw new Error(
+      "mount() is not implemented for the HTML compilation of a Marko template"
+    );
+  }
+  render(templateInput = {}) {
+    let { $global, ...input } = templateInput, buffer = "", done = !1, pending = deferred();
+    return this.#writeTo(
+      {
+        write(data) {
+          buffer += data;
+        },
+        flush() {
+          pending.resolve({
+            value: buffer,
+            done: !1
+          }), buffer = "", pending = deferred();
+        },
+        emit(name, error) {
+          name === "error" && pending.reject(error);
+        },
+        end() {
+          done = !0, pending.resolve({
+            value: "",
+            done
+          });
+        }
+      },
+      input,
+      $global
+    ), new ServerRenderResult({
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (buffer || done) {
+          let value = buffer;
+          return buffer = "", { value, done };
+        }
+        return pending.promise;
+      }
+    });
+  }
+};
+export {
+  $_streamData,
+  attr,
+  attrs,
+  classAttr,
+  createRenderFn,
+  createRenderer,
+  createTemplate,
+  dynamicTagArgs,
+  dynamicTagInput,
+  escapeAttrValue,
+  escapeScript,
+  escapeStyle,
+  escapeXML,
+  fork,
+  getRegistryInfo,
+  makeSerializable,
+  markResumeControlEnd,
+  markResumeControlSingleNodeEnd,
+  markResumeNode,
+  markResumeScopeStart,
+  maybeFlush,
+  nextScopeId,
+  nextTagId,
+  patchDynamicTag,
+  peekSerializedScope,
+  register,
+  serializedScope,
+  styleAttr,
+  toString,
+  tryCatch,
+  tryPlaceholder,
+  write,
+  writeEffect,
+  writeScope
+};
+//# sourceMappingURL=html.mjs.map