@marko/runtime-tags 0.1.1

package/dist/debug/html.js

@@ -0,0 +1,1323 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/html.ts
+var html_exports = {};
+__export(html_exports, {
+  $_streamData: () => $_streamData,
+  attr: () => attr,
+  attrs: () => attrs,
+  classAttr: () => classAttr,
+  createRenderFn: () => createRenderFn,
+  createRenderer: () => createRenderer,
+  createTemplate: () => createTemplate,
+  dynamicTagArgs: () => dynamicTagArgs,
+  dynamicTagInput: () => dynamicTagInput,
+  escapeAttrValue: () => escapeAttrValue,
+  escapeScript: () => escapeScript,
+  escapeStyle: () => escapeStyle,
+  escapeXML: () => escapeXML,
+  fork: () => fork,
+  getRegistryInfo: () => getRegistryInfo,
+  makeSerializable: () => makeSerializable,
+  markResumeControlEnd: () => markResumeControlEnd,
+  markResumeControlSingleNodeEnd: () => markResumeControlSingleNodeEnd,
+  markResumeNode: () => markResumeNode,
+  markResumeScopeStart: () => markResumeScopeStart,
+  maybeFlush: () => maybeFlush,
+  nextScopeId: () => nextScopeId,
+  nextTagId: () => nextTagId,
+  patchDynamicTag: () => patchDynamicTag,
+  peekSerializedScope: () => peekSerializedScope,
+  register: () => register,
+  serializedScope: () => serializedScope,
+  styleAttr: () => styleAttr,
+  toString: () => toString,
+  tryCatch: () => tryCatch,
+  tryPlaceholder: () => tryPlaceholder,
+  write: () => write,
+  writeEffect: () => writeEffect,
+  writeScope: () => writeScope
+});
+module.exports = __toCommonJS(html_exports);
+
+// src/html/content.ts
+function toString(val) {
+  return val || val === 0 ? val + "" : "";
+}
+var escapeXML = escapeIfNeeded((val) => {
+  let result = "";
+  let 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;
+  }
+  if (lastPos) {
+    return result + val.slice(lastPos);
+  }
+  return val;
+});
+var escapeScript = escapeIfNeeded(escapeTagEnding("script"));
+var escapeStyle = escapeIfNeeded(escapeTagEnding("style"));
+function escapeTagEnding(tagName) {
+  const openTag = `</${tagName}`;
+  const escaped = `<\\/${tagName}`;
+  return (val) => {
+    let result = "";
+    let lastPos = 0;
+    let i = val.indexOf(openTag, lastPos);
+    while (i !== -1) {
+      result += val.slice(lastPos, i) + escaped;
+      lastPos = i + 1;
+      i = val.indexOf(openTag, lastPos);
+    }
+    if (lastPos) {
+      return result + val.slice(lastPos);
+    }
+    return val;
+  };
+}
+function escapeAttrValue(val) {
+  const len = val.length;
+  let i = 0;
+  do {
+    switch (val[i]) {
+      case '"':
+        return quoteValue(val, i + 1, "'", "&#39;");
+      case "'":
+      case ">":
+      case " ":
+      case "	":
+      case "\n":
+      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;
+  let lastPos = 0;
+  for (let i = startPos, len = val.length; i < len; i++) {
+    if (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) {
+  if (isVoid(value)) {
+    return "";
+  }
+  return 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) {
+  if (isVoid(value)) {
+    return "";
+  }
+  if (typeof value === "number" && value && !NON_DIMENSIONAL.test(name)) {
+    value += "px";
+  }
+  return `${name}:${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 isVoid(value) {
+  return value == null || value === false;
+}
+
+// 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 (const name in data) {
+    if (/^on[A-Z-]/.test(name)) {
+      continue;
+    }
+    const val = data[name];
+    switch (name) {
+      case "class":
+        result += classAttr(val);
+        break;
+      case "style":
+        result += styleAttr(val);
+        break;
+      case "renderBody":
+        break;
+      default:
+        if (!(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 true;
+    }
+  }
+  return false;
+}
+
+// src/html/serializer.ts
+var { hasOwnProperty } = Object.prototype;
+var PARAM_BIND = "b";
+var PARAM_SCOPE = "s";
+var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+var REF_START_CHARS_LEN = REF_START_CHARS.length;
+var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+var REF_CHARS_LEN = REF_CHARS.length;
+var SYMBOL_REGISTRY_ID = Symbol("REGISTRY_ID");
+var SYMBOL_SCOPE = Symbol("SCOPE");
+var SYMBOL_SERIALIZE = Symbol("SERIALIZE");
+var Scope = class {
+};
+var serializedScope = (scopeId) => {
+  const scope = new Scope();
+  if (true) {
+    scope.id = scopeId;
+  }
+  return makeSerializable(scope, (s, a) => {
+    s.value(s.scopeLookup.get(scopeId), a);
+  });
+};
+function register(entry, registryId, scopeId) {
+  entry[SYMBOL_REGISTRY_ID] = registryId;
+  entry[SYMBOL_SCOPE] = scopeId;
+  return entry;
+}
+function getRegistryInfo(entry) {
+  return [entry[SYMBOL_REGISTRY_ID], entry[SYMBOL_SCOPE]];
+}
+function makeSerializable(object, serialize) {
+  object[SYMBOL_SERIALIZE] = serialize;
+  return 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, "")) {
+      const { BUFFER, REF_COUNT, ASSIGNMENTS, INDEX_OR_REF } = this;
+      let 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);
+          if (typeof ref === "number") {
+            ref = toRefParam(this.REF_COUNT++);
+            result = ref + "=" + result;
+          }
+          for (const [assignmentRef, assignments] of ASSIGNMENTS) {
+            result += "," + assignments + assignmentRef;
+          }
+          result += "," + ref;
+          this.ASSIGNMENTS = /* @__PURE__ */ new Map();
+        }
+        result = "(" + PARAM_BIND + "," + PARAM_SCOPE + "," + this.refParamsString() + ")=>(" + result + ")";
+      } else if (root && root.constructor === Object) {
+        result = "(" + PARAM_BIND + "," + PARAM_SCOPE + ")=>(" + result + ")";
+      }
+      BUFFER.length = 0;
+      this.INDEX_OR_REF = /* @__PURE__ */ new WeakMap();
+      return result;
+    }
+    return "void 0";
+  }
+  code(code) {
+    this.BUFFER.push(code);
+    return this;
+  }
+  value(value, accessor = "") {
+    if (!this.writeProp(value, accessor) && !this.STACK.includes(value)) {
+      this.BUFFER.push("void 0");
+    }
+    return this;
+  }
+  writeProp(cur, accessor) {
+    const { 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 {
+          const ref = this.getRef(cur, accessor);
+          switch (ref) {
+            case true:
+              return false;
+            case false:
+              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 false;
+    }
+    return true;
+  }
+  writeRegistered(value, accessor) {
+    const {
+      [SYMBOL_REGISTRY_ID]: registryId,
+      [SYMBOL_SCOPE]: scopeId,
+      [SYMBOL_SERIALIZE]: serialize
+    } = value;
+    const { BUFFER } = this;
+    if (registryId) {
+      const scope = scopeId !== void 0 ? this.scopeLookup.get(scopeId) ?? false : void 0;
+      const ref = scope && this.getRef(scope, "");
+      if (ref === true) {
+        const { STACK, INDEX_OR_REF, ASSIGNMENTS } = this;
+        const parent = STACK[STACK.length - 1];
+        const parentRef = INDEX_OR_REF.get(parent);
+        const resolvedRef = INDEX_OR_REF.get(scope);
+        ASSIGNMENTS.set(
+          `${PARAM_BIND}("${registryId}",${resolvedRef})`,
+          (ASSIGNMENTS.get(ref) || "") + toAssignment(parentRef, accessor) + "="
+        );
+        return false;
+      } else if (ref === false) {
+        throw new Error(
+          "The scope has not yet been defined. This needs to be fixed in the serializer."
+        );
+      } else {
+        BUFFER.push(`${PARAM_BIND}("${registryId}"${ref ? "," + ref : ""})`);
+        return true;
+      }
+    } else if (serialize) {
+      const prevSize = BUFFER.length;
+      serialize(this, accessor);
+      return prevSize !== BUFFER.length;
+    }
+    return false;
+  }
+  writeObject(obj) {
+    const { STACK, BUFFER } = this;
+    let sep = "{";
+    STACK.push(obj);
+    for (const key in obj) {
+      if (hasOwnProperty.call(obj, key)) {
+        const val = obj[key];
+        const escapedKey = toObjectKey(key);
+        BUFFER.push(sep + escapedKey + ":");
+        if (this.writeProp(val, escapedKey)) {
+          sep = ",";
+        } else {
+          BUFFER.pop();
+        }
+      }
+    }
+    if (sep === "{") {
+      BUFFER.push("{}");
+    } else {
+      BUFFER.push("}");
+    }
+    STACK.pop();
+  }
+  writeArray(arr) {
+    const { 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) {
+    const { STACK, BUFFER, INDEX_OR_REF, ASSIGNMENTS, PARENTS, KEYS } = this;
+    let 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) {
+        const parent = STACK[STACK.length - 1];
+        if (!parent) {
+        } else {
+          PARENTS.set(cur, parent);
+          KEYS.set(cur, toObjectKey(accessor));
+        }
+        return false;
+      } else {
+        let ref2 = "";
+        while (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);
+    }
+    if (STACK.includes(cur)) {
+      const parent = STACK[STACK.length - 1];
+      let parentRef = INDEX_OR_REF.get(parent);
+      if (typeof parentRef === "number") {
+        parentRef = this.insertAndGetRef(parent, parentRef);
+      }
+      if (accessor !== "") {
+        ASSIGNMENTS.set(
+          ref,
+          (ASSIGNMENTS.get(ref) || "") + toAssignment(parentRef, accessor) + "="
+        );
+      }
+      return true;
+    }
+    return ref;
+  }
+  insertAndGetRef(obj, pos) {
+    const ref = toRefParam(this.REF_COUNT++);
+    this.INDEX_OR_REF.set(obj, ref);
+    if (pos) {
+      this.BUFFER[pos - 1] += ref + "=";
+    } else {
+      this.BUFFER[pos] = ref + "=" + this.BUFFER[pos];
+    }
+    return ref;
+  }
+  refParamsString() {
+    let result = REF_START_CHARS[0];
+    for (let i = 1; i < this.REF_COUNT; i++) {
+      result += "," + toRefParam(i);
+    }
+    this.REF_COUNT = 0;
+    return 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++) {
+      char = name[i];
+      if (!(char >= "0" && char <= "9")) {
+        return quote(name, i);
+      }
+    }
+    return parseInt(name, 10);
+  } else {
+    for (let i = 0, len = name.length; i < len; i++) {
+      char = name[i];
+      if (!(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 = "";
+  let 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 "\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;
+  }
+  if (lastPos === startPos) {
+    result = str;
+  } else {
+    result += str.slice(lastPos);
+  }
+  return '"' + result + '"';
+}
+function toRefParam(index) {
+  let mod = index % REF_START_CHARS_LEN;
+  let ref = REF_START_CHARS[mod];
+  index = (index - mod) / REF_START_CHARS_LEN;
+  while (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) {
+  runtimePrefix = "RUNTIME_ID$";
+  id = runtimePrefix + id;
+  doc = document;
+  walker = doc[runtimePrefix + "w"] || (doc[runtimePrefix + "w"] = doc.createTreeWalker(
+    doc,
+    128
+  ));
+  while (node = walker.nextNode()) {
+    if (node.data.indexOf(runtimePrefix) === 0) {
+      walker[node.data] = node;
+    }
+  }
+  replacementNode = doc.getElementById(id);
+  targetNode = walker[id];
+  targetParent = targetNode.parentNode;
+  while (refNode = replacementNode.firstChild) {
+    targetParent.insertBefore(refNode, targetNode);
+  }
+  nextNode = replacementNode.parentNode;
+  nextNode.removeChild(replacementNode.nextSibling);
+  nextNode.removeChild(replacementNode);
+  refNode = walker[id + "/"];
+  while (targetNode && (nextNode = targetNode.nextSibling, targetParent.removeChild(targetNode) !== refNode)) {
+    targetNode = nextNode;
+  }
+}
+
+// src/html/writer.ts
+var runtimeId = "M" /* DefaultRuntimeId */;
+var reorderRuntimeString = String(reorder_runtime_default).replace(
+  "RUNTIME_ID",
+  runtimeId
+);
+var $_buffer = null;
+var $_streamData = null;
+function createRenderFn(renderer) {
+  return (stream, input = {}, $global, streamState = {}) => {
+    let remainingChildren = 1;
+    const originalBuffer = $_buffer;
+    const originalStreamState = $_streamData;
+    const reject = (err) => {
+      stream.emit("error", err);
+    };
+    const async = (complete) => {
+      remainingChildren += complete ? -1 : 1;
+      if (!remainingChildren) {
+        setImmediate(() => stream.end());
+      }
+    };
+    $_buffer = createInitialBuffer(stream);
+    streamState.global = $global;
+    $_streamData = createStreamState(streamState);
+    $_buffer.onReject = reject;
+    $_buffer.onAsync = async;
+    try {
+      scheduleFlush();
+      renderer(input);
+      async(true);
+    } catch (err) {
+      reject(err);
+    } finally {
+      $_buffer = originalBuffer;
+      $_streamData = originalStreamState;
+    }
+  };
+}
+function write(data) {
+  $_buffer.content += data;
+}
+var TARGET_BUFFER_SIZE = 64e3;
+function maybeFlush() {
+  if (!$_buffer.prev && $_buffer.content.length > TARGET_BUFFER_SIZE) {
+  }
+}
+function scheduleFlush() {
+  const buffer = $_buffer;
+  const streamState = $_streamData;
+  if (!buffer.prev) {
+    setImmediate(() => flushToStream(buffer, streamState));
+  }
+}
+function flushToStream(buffer, streamState) {
+  while (buffer.prev)
+    buffer = buffer.prev;
+  if (buffer.disabled)
+    return;
+  const stream = buffer.stream;
+  let { content, calls, scopes } = buffer;
+  buffer.flushed = true;
+  while (!buffer.pending && buffer.next) {
+    clearBuffer(buffer);
+    buffer = buffer.next;
+    buffer.prev = null;
+    buffer.flushed = true;
+    content += buffer.content;
+    calls += buffer.calls;
+    if (buffer.scopes) {
+      if (scopes) {
+        Object.assign(scopes, buffer.scopes);
+      } else {
+        scopes = buffer.scopes;
+      }
+    }
+  }
+  const data = content + getResumeScript(calls, scopes, streamState);
+  if (data) {
+    stream.write(data);
+    stream.flush?.();
+  }
+  clearBuffer(buffer);
+}
+function createStreamState(state) {
+  state.scopeId ??= 0;
+  state.tagId ??= 0;
+  state.placeholderId ??= 0;
+  state.scopeLookup ??= /* @__PURE__ */ new Map();
+  state.runtimeFlushed ??= false;
+  return state;
+}
+function createNextBuffer(prevBuffer) {
+  const newBuffer = {
+    stream: prevBuffer.stream,
+    pending: false,
+    flushed: false,
+    disabled: false,
+    prev: prevBuffer,
+    next: prevBuffer?.next ?? null,
+    content: "",
+    calls: "",
+    scopes: null,
+    onReject: prevBuffer.onReject,
+    onAsync: prevBuffer.onAsync
+  };
+  if (prevBuffer.next) {
+    prevBuffer.next.prev = prevBuffer;
+  }
+  prevBuffer.next = newBuffer;
+  return newBuffer;
+}
+function createDetatchedBuffer(parentBuffer) {
+  return {
+    stream: parentBuffer.stream,
+    pending: false,
+    flushed: false,
+    disabled: true,
+    prev: null,
+    next: null,
+    content: "",
+    calls: "",
+    scopes: null,
+    onReject: parentBuffer.onReject,
+    onAsync: parentBuffer.onAsync
+  };
+}
+function createInitialBuffer(stream) {
+  return {
+    stream,
+    pending: false,
+    flushed: false,
+    disabled: false,
+    prev: null,
+    next: null,
+    content: "",
+    calls: "",
+    scopes: null,
+    onReject: void 0,
+    onAsync: void 0
+  };
+}
+async function fork(promise, renderResult) {
+  const originalBuffer = $_buffer;
+  const originalStreamState = $_streamData;
+  scheduleFlush();
+  $_buffer.pending = true;
+  $_buffer.onAsync?.(false);
+  $_buffer = createNextBuffer($_buffer);
+  try {
+    let result;
+    try {
+      result = await promise;
+      originalBuffer.pending = false;
+    } finally {
+      $_buffer = originalBuffer;
+      $_streamData = originalStreamState;
+      scheduleFlush();
+    }
+    renderResult(result);
+  } catch (err) {
+    $_buffer.onReject?.(err);
+  } finally {
+    $_buffer.onAsync?.(true);
+    clearScope();
+  }
+}
+function tryCatch(renderBody, renderError) {
+  const id = nextPlaceholderId();
+  let err = null;
+  const originalBuffer = $_buffer;
+  const tryBuffer = createDetatchedBuffer(originalBuffer);
+  let finalTryBuffer;
+  tryBuffer.onReject = (asyncErr) => {
+    const errorBuffer = createDetatchedBuffer(originalBuffer);
+    $_buffer = errorBuffer;
+    renderError(asyncErr);
+    const finalErrorBuffer = $_buffer;
+    replaceBuffers(
+      id,
+      tryBuffer,
+      finalTryBuffer,
+      errorBuffer,
+      finalErrorBuffer
+    );
+  };
+  try {
+    $_buffer = tryBuffer;
+    renderBody();
+  } catch (_err) {
+    err = _err;
+  } finally {
+    if (err) {
+      $_buffer = originalBuffer;
+      renderError(err);
+    } else {
+      tryBuffer.disabled = false;
+      originalBuffer.next = tryBuffer;
+      tryBuffer.prev = originalBuffer;
+      if ($_buffer !== tryBuffer) {
+        tryBuffer.content = `<!${marker(id)}>` + tryBuffer.content;
+        markReplaceEnd(id);
+        finalTryBuffer = $_buffer;
+        $_buffer = createNextBuffer(finalTryBuffer);
+      }
+      $_buffer.onReject = originalBuffer.onReject;
+    }
+  }
+}
+function tryPlaceholder(renderBody, renderPlaceholder) {
+  const originalBuffer = $_buffer;
+  const asyncBuffer = createDetatchedBuffer(originalBuffer);
+  let id, placeholderBuffer, finalPlaceholderBuffer, finalAsyncBuffer;
+  let remainingChildren = 0;
+  let remainingPlaceholders = 0;
+  asyncBuffer.onAsync = (complete, isPlaceholder) => {
+    const delta = complete ? -1 : 1;
+    if (isPlaceholder) {
+      remainingPlaceholders += delta;
+    } else {
+      remainingChildren += delta;
+    }
+    if (!remainingChildren) {
+      if (!isPlaceholder) {
+        replaceBuffers(
+          id,
+          placeholderBuffer,
+          finalPlaceholderBuffer,
+          asyncBuffer,
+          finalAsyncBuffer
+        );
+      }
+      if (!remainingPlaceholders) {
+        originalBuffer.onAsync?.(true, true);
+      }
+    }
+  };
+  $_buffer = asyncBuffer;
+  renderBody();
+  if ($_buffer === asyncBuffer) {
+    originalBuffer.next = asyncBuffer;
+    asyncBuffer.prev = originalBuffer;
+    asyncBuffer.disabled = false;
+    asyncBuffer.onAsync = originalBuffer.onAsync;
+  } else {
+    id = nextPlaceholderId();
+    placeholderBuffer = createNextBuffer(originalBuffer);
+    finalAsyncBuffer = $_buffer;
+    $_buffer = placeholderBuffer;
+    markReplaceStart(id);
+    renderPlaceholder();
+    markReplaceEnd(id);
+    finalPlaceholderBuffer = $_buffer;
+    $_buffer = createNextBuffer(finalPlaceholderBuffer);
+    originalBuffer.onAsync?.(false, true);
+  }
+}
+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) {
+      while (next && !next.pending && next.flushed) {
+        next = next.next;
+      }
+    } else {
+    }
+    if (next) {
+      replacementStart.next = next;
+      next.prev = replacementEnd;
+    }
+    $_buffer = replacementStart;
+    scheduleFlush();
+  } else {
+    const prev = placeholderStart.prev;
+    const next = placeholderEnd.next;
+    if (prev) {
+      prev.next = replacementStart;
+      replacementStart.prev = prev;
+    }
+    if (next) {
+      next.prev = replacementEnd;
+      replacementEnd.next = next;
+    }
+  }
+  replacementStart.disabled = false;
+}
+function addReplacementWrapper(id, replacementStart, replacementEnd) {
+  let runtimeCall = runtimeId + "$r" /* VarReorderRuntime */;
+  if (!$_streamData.runtimeFlushed) {
+    runtimeCall = `(${runtimeCall}=${reorderRuntimeString})`;
+    $_streamData.runtimeFlushed = true;
+  }
+  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)) {
+  if (assignTo !== void 0) {
+    if (Array.isArray(assignTo)) {
+      assignTo.push(scope);
+    } else {
+      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}${"*" /* Node */}${scopeId} ${index}>`;
+}
+function markResumeScopeStart(scopeId, key) {
+  return `<!${runtimeId}${"[" /* SectionStart */}${scopeId}${key ? " " + key : ""}>`;
+}
+function markResumeControlEnd(scopeId, index) {
+  return `<!${runtimeId}${"]" /* SectionEnd */}${scopeId} ${index}>`;
+}
+function markResumeControlSingleNodeEnd(scopeId, index, childScopeIds) {
+  return `<!${runtimeId}${"|" /* SectionSingleNodesEnd */}${scopeId} ${index} ${childScopeIds ?? ""}>`;
+}
+function getResumeScript(calls, scopes, streamState) {
+  if (calls || scopes) {
+    let isFirstFlush;
+    let serializer = streamState.serializer;
+    if (isFirstFlush = !serializer) {
+      serializer = streamState.serializer = new Serializer(
+        streamState.scopeLookup
+      );
+    }
+    return `<script>${isFirstFlush ? `(${runtimeId + "$h" /* VarResume */}=[])` : runtimeId + "$h" /* VarResume */}.push(${serializer.stringify(scopes)},[${calls}])</script>`;
+  }
+  return "";
+}
+function getFilteredGlobals($global) {
+  if (!$global)
+    return void 0;
+  const serializedGlobals = $global.serializedGlobals;
+  if (!serializedGlobals)
+    return void 0;
+  let filtered;
+  if (Array.isArray(serializedGlobals)) {
+    for (const key of serializedGlobals) {
+      const value = $global[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 = $global[key];
+        if (value !== void 0) {
+          if (filtered) {
+            filtered[key] = value;
+          } else {
+            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 void 0;
+  const futureScopeId = peekNextScopeId();
+  const futureScope = serializedScope(futureScopeId);
+  write(`${markResumeScopeStart(futureScopeId)}`);
+  writeScope(futureScopeId, {});
+  if (!tag) {
+    renderBody();
+    return futureScope;
+  }
+  if (typeof tag === "string") {
+    nextScopeId();
+    write(`<${tag}${attrs(input)}>`);
+    if (!voidElements.has(tag)) {
+      if (renderBody) {
+        renderBody();
+      }
+      write(`</${tag}>`);
+    } else if (renderBody) {
+      throw new Error(
+        `A renderBody was provided for a "${tag}" tag, which cannot have children.`
+      );
+    }
+    return futureScope;
+  }
+  const renderer = getDynamicRenderer(tag);
+  if (typeof renderer === "function") {
+    renderer(renderBody ? { ...input, renderBody } : input);
+    return futureScope;
+  } else if (true) {
+    throw new Error(`Invalid renderer passed for dynamic tag: ${tag}`);
+  }
+}
+function dynamicTagArgs(tag, args) {
+  if (!tag)
+    return void 0;
+  const futureScopeId = peekNextScopeId();
+  const futureScope = serializedScope(futureScopeId);
+  write(`${markResumeScopeStart(futureScopeId)}`);
+  writeScope(futureScopeId, {});
+  if (typeof tag === "string") {
+    nextScopeId();
+    write(`<${tag}${attrs(args[0])}></${tag}>`);
+    return futureScope;
+  }
+  const renderer = getDynamicRenderer(tag);
+  if (typeof renderer === "function") {
+    renderer(...args);
+    return futureScope;
+  } else if (true) {
+    throw new Error(`Invalid renderer passed for dynamic tag: ${tag}`);
+  }
+}
+var getDynamicRenderer = (tag) => tag._ || tag.renderBody || tag;
+var 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;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+async function stringFromAsync(iterable) {
+  let str = "";
+  for await (const 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 (const chunk of this.#iterable) {
+            if (chunk) {
+              controller.enqueue(chunk);
+            }
+          }
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+  }
+};
+var 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 = {}) {
+    const { $global, ...input } = templateInput;
+    let buffer = "";
+    let done = false;
+    let pending = deferred();
+    this.#writeTo(
+      {
+        write(data) {
+          buffer += data;
+        },
+        flush() {
+          pending.resolve({
+            value: buffer,
+            done: false
+          });
+          buffer = "";
+          pending = deferred();
+        },
+        emit(name, error) {
+          if (name === "error") {
+            pending.reject(error);
+          }
+        },
+        end() {
+          done = true;
+          pending.resolve({
+            value: "",
+            done
+          });
+        }
+      },
+      input,
+      $global
+    );
+    return new ServerRenderResult({
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (buffer || done) {
+          const value = buffer;
+          buffer = "";
+          return { value, done };
+        }
+        return pending.promise;
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $_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.js.map