@clusterenvision/ui-framework 1.0.0

package/dist/chunk-BBAUALNU.js

@@ -0,0 +1,888 @@
+// src/compiler/html-parser.js
+var NodeType;
+(function(NodeType2) {
+  NodeType2[NodeType2["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+  NodeType2[NodeType2["TEXT_NODE"] = 3] = "TEXT_NODE";
+  NodeType2[NodeType2["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+  NodeType2[NodeType2["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
+})(NodeType || (NodeType = {}));
+var defaultVoidElementNames = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var defaultRawTextElementNames = ["script", "style", "textarea"];
+var namedEntities = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+var TreeNode = class {
+  parentNode = null;
+  previousSibling = null;
+  nextSibling = null;
+};
+var ParentNodeImpl = class extends TreeNode {
+  childNodes = [];
+  get firstChild() {
+    return this.childNodes[0];
+  }
+  get lastChild() {
+    return this.childNodes[this.childNodes.length - 1];
+  }
+  appendChild(child) {
+    if (child === this) {
+      return child;
+    }
+    detach(child);
+    const last = this.lastChild ?? null;
+    if (last) {
+      last.nextSibling = child;
+    }
+    child.previousSibling = last;
+    child.nextSibling = null;
+    child.parentNode = this;
+    this.childNodes.push(child);
+    return child;
+  }
+  insertBefore(child, reference) {
+    if (child === this) {
+      return child;
+    }
+    if (reference === null) {
+      return this.appendChild(child);
+    }
+    const index = this.childNodes.indexOf(reference);
+    if (index === -1) {
+      throw new Error("Reference node not found in parent.");
+    }
+    detach(child);
+    const prev = reference.previousSibling;
+    if (prev) {
+      prev.nextSibling = child;
+    }
+    child.previousSibling = prev;
+    child.nextSibling = reference;
+    reference.previousSibling = child;
+    child.parentNode = this;
+    this.childNodes.splice(index, 0, child);
+    return child;
+  }
+  removeChild(child) {
+    const index = this.childNodes.indexOf(child);
+    if (index === -1) {
+      return child;
+    }
+    const prev = child.previousSibling;
+    const next = child.nextSibling;
+    if (prev) {
+      prev.nextSibling = next;
+    }
+    if (next) {
+      next.previousSibling = prev;
+    }
+    child.parentNode = null;
+    child.previousSibling = null;
+    child.nextSibling = null;
+    this.childNodes.splice(index, 1);
+    return child;
+  }
+  replaceChild(newChild, oldChild) {
+    this.insertBefore(newChild, oldChild);
+    this.removeChild(oldChild);
+    return newChild;
+  }
+  clearChildren() {
+    for (const child of this.childNodes) {
+      child.parentNode = null;
+      child.previousSibling = null;
+      child.nextSibling = null;
+    }
+    this.childNodes.length = 0;
+  }
+  get textContent() {
+    return this.childNodes.map((child) => child.textContent).join("");
+  }
+  set textContent(value) {
+    this.clearChildren();
+    if (value) {
+      this.appendChild(new TextNode(value));
+    }
+  }
+};
+var TextNode = class _TextNode extends TreeNode {
+  text;
+  nodeType = NodeType.TEXT_NODE;
+  constructor(text) {
+    super();
+    this.text = text;
+  }
+  get textContent() {
+    return this.text;
+  }
+  set textContent(value) {
+    this.text = value;
+  }
+  clone() {
+    return new _TextNode(this.text);
+  }
+  toString() {
+    return escapeText(this.text);
+  }
+};
+var CommentNode = class _CommentNode extends TreeNode {
+  data;
+  nodeType = NodeType.COMMENT_NODE;
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+  get textContent() {
+    return this.data;
+  }
+  set textContent(value) {
+    this.data = value;
+  }
+  clone() {
+    return new _CommentNode(this.data);
+  }
+  toString() {
+    return `<!--${this.data}-->`;
+  }
+};
+var HTMLElement = class _HTMLElement extends ParentNodeImpl {
+  tagName;
+  nodeType = NodeType.ELEMENT_NODE;
+  attrs = {};
+  normalizedTagName;
+  isVoidElement;
+  lowerCaseAttributeName;
+  constructor(tagName, attrs = {}, options = {}) {
+    super();
+    this.tagName = tagName;
+    const shouldLowercase = options.lowerCaseTagName ?? true;
+    this.tagName = shouldLowercase ? tagName.toLowerCase() : tagName;
+    this.normalizedTagName = (options.normalizedTagName ?? this.tagName).toLowerCase();
+    this.lowerCaseAttributeName = options.lowerCaseAttributeName ?? true;
+    this.isVoidElement = options.isVoidElement ?? false;
+    for (const [key, value] of Object.entries(attrs)) {
+      const normalized = this.normalizeAttrName(key);
+      this.attrs[normalized] = options.decodeEntities ? decodeHtmlEntities(value) : value;
+    }
+  }
+  getAttribute(name) {
+    return this.attrs[this.normalizeAttrName(name)];
+  }
+  getAttributeNames() {
+    return Object.keys(this.attrs);
+  }
+  hasAttribute(name) {
+    return Object.prototype.hasOwnProperty.call(this.attrs, this.normalizeAttrName(name));
+  }
+  setAttribute(name, value) {
+    this.attrs[this.normalizeAttrName(name)] = value;
+  }
+  removeAttribute(name) {
+    Reflect.deleteProperty(this.attrs, this.normalizeAttrName(name));
+  }
+  toggleAttribute(name, force) {
+    const attr = this.normalizeAttrName(name);
+    const exists = Object.prototype.hasOwnProperty.call(this.attrs, attr);
+    if (force === true || !exists && force === void 0) {
+      this.attrs[attr] = "";
+      return true;
+    }
+    if (force === false || exists) {
+      Reflect.deleteProperty(this.attrs, attr);
+      return false;
+    }
+    return false;
+  }
+  clone(deep = true) {
+    const clone = new _HTMLElement(this.tagName, { ...this.attrs }, {
+      lowerCaseTagName: false,
+      lowerCaseAttributeName: false,
+      isVoidElement: this.isVoidElement,
+      normalizedTagName: this.normalizedTagName
+    });
+    if (deep) {
+      for (const child of this.childNodes) {
+        clone.appendChild(child.clone(true));
+      }
+    }
+    return clone;
+  }
+  toString() {
+    const attrString = Object.entries(this.attrs).map(([key, value]) => value === "" ? key : `${key}="${escapeAttribute(value)}"`).join(" ");
+    const openTag = attrString ? `<${this.tagName} ${attrString}>` : `<${this.tagName}>`;
+    if (this.isVoidElement) {
+      return openTag;
+    }
+    if (!this.childNodes.length) {
+      return `${openTag}</${this.tagName}>`;
+    }
+    const children = this.childNodes.map((child) => child.toString()).join("");
+    return `${openTag}${children}</${this.tagName}>`;
+  }
+  normalizeAttrName(name) {
+    return this.lowerCaseAttributeName ? name.toLowerCase() : name;
+  }
+};
+var DocumentFragment = class _DocumentFragment extends ParentNodeImpl {
+  nodeType = NodeType.DOCUMENT_FRAGMENT_NODE;
+  clone(deep = true) {
+    const fragment = new _DocumentFragment();
+    if (deep) {
+      for (const child of this.childNodes) {
+        fragment.appendChild(child.clone(true));
+      }
+    }
+    return fragment;
+  }
+  toString() {
+    return this.childNodes.map((child) => child.toString()).join("");
+  }
+};
+function parse(html, options = {}) {
+  const runtime = normalizeParseOptions(options);
+  const root = new DocumentFragment();
+  const stack = [root];
+  let index = 0;
+  while (index < html.length) {
+    const nextLt = html.indexOf("<", index);
+    if (nextLt === -1) {
+      appendText(html.slice(index));
+      break;
+    }
+    if (nextLt > index) {
+      appendText(html.slice(index, nextLt));
+    }
+    if (html.startsWith("<!--", nextLt)) {
+      const endComment = html.indexOf("-->", nextLt + 4);
+      if (endComment === -1) {
+        if (runtime.preserveComments) {
+          appendComment(html.slice(nextLt + 4));
+        }
+        break;
+      }
+      if (runtime.preserveComments) {
+        appendComment(html.slice(nextLt + 4, endComment));
+      }
+      index = endComment + 3;
+      continue;
+    }
+    if (html.startsWith("<![CDATA[", nextLt)) {
+      const endCdata = html.indexOf("]]>", nextLt + 9);
+      const content2 = endCdata === -1 ? html.slice(nextLt + 9) : html.slice(nextLt + 9, endCdata);
+      appendText(content2, false);
+      if (endCdata === -1) {
+        break;
+      }
+      index = endCdata + 3;
+      continue;
+    }
+    const { content, endIndex } = readTag(html, nextLt + 1);
+    if (!content) {
+      index = endIndex + 1;
+      continue;
+    }
+    if (content.startsWith("/")) {
+      const closingName = extractClosingName(content);
+      if (closingName) {
+        const normalizedClosing = closingName.toLowerCase();
+        while (stack.length > 1) {
+          const node = stack.pop();
+          if (node instanceof HTMLElement && node.normalizedTagName === normalizedClosing) {
+            break;
+          }
+        }
+      }
+      index = endIndex + 1;
+      continue;
+    }
+    if (content.startsWith("!") || content.startsWith("?")) {
+      index = endIndex + 1;
+      continue;
+    }
+    const tag = parseTag(content, runtime);
+    const element = new HTMLElement(tag.tagName, tag.attrs, {
+      lowerCaseTagName: false,
+      lowerCaseAttributeName: runtime.lowerCaseAttributeName,
+      decodeEntities: false,
+      isVoidElement: runtime.voidElements.has(tag.normalizedTagName),
+      normalizedTagName: tag.normalizedTagName
+    });
+    stack[stack.length - 1].appendChild(element);
+    if (runtime.rawTextElements.has(tag.normalizedTagName)) {
+      const rawStart = endIndex + 1;
+      const closing = findRawTextClosure(html, rawStart, tag.normalizedTagName);
+      const inner = closing ? html.slice(rawStart, closing.start) : html.slice(rawStart);
+      appendText(inner, false, element);
+      index = closing ? closing.end + 1 : html.length;
+      continue;
+    }
+    if (!tag.selfClosing && !runtime.voidElements.has(tag.normalizedTagName)) {
+      stack.push(element);
+    }
+    index = endIndex + 1;
+  }
+  return root;
+  function appendText(text, decode = true, target) {
+    if (!text) {
+      return;
+    }
+    const nodeText = decode && runtime.decodeEntities ? decodeHtmlEntities(text) : text;
+    (target ?? stack[stack.length - 1]).appendChild(new TextNode(nodeText));
+  }
+  function appendComment(value) {
+    stack[stack.length - 1].appendChild(new CommentNode(value));
+  }
+}
+function createElement(tagName, attrs = {}, options = {}) {
+  const normalizedTag = options.lowerCaseTagName ?? true ? tagName.toLowerCase() : tagName;
+  const isVoid = options.isVoidElement ?? defaultVoidSet.has(normalizedTag.toLowerCase());
+  return new HTMLElement(tagName, attrs, { ...options, isVoidElement: isVoid, normalizedTagName: normalizedTag.toLowerCase() });
+}
+function createTextNode(text) {
+  return new TextNode(text);
+}
+function createCommentNode(content) {
+  return new CommentNode(content);
+}
+function createFragment(children = [], options = {}) {
+  const fragment = new DocumentFragment();
+  for (const child of children) {
+    fragment.appendChild(options.clone ? child.clone(true) : child);
+  }
+  return fragment;
+}
+function cloneNode(node, deep = true) {
+  return node.clone(deep);
+}
+function serialize(target, options = {}) {
+  const nodes = Array.isArray(target) ? target : [target];
+  if (!options.pretty) {
+    return nodes.map((node) => node.toString()).join("");
+  }
+  const indent = options.indent ?? "  ";
+  const newline = options.newline ?? "\n";
+  return nodes.map((node) => serializePretty(node, indent, newline, 0)).filter(Boolean).join(newline);
+}
+function walk(target, visitor) {
+  const nodes = Array.isArray(target) ? target : [target];
+  traverse(nodes, visitor, null, 0);
+}
+function isElementNode(node) {
+  return node instanceof HTMLElement;
+}
+function isTextNode(node) {
+  return node instanceof TextNode;
+}
+function isCommentNode(node) {
+  return node instanceof CommentNode;
+}
+function isParentNode(node) {
+  return node instanceof HTMLElement || node instanceof DocumentFragment;
+}
+var defaultVoidSet = new Set(defaultVoidElementNames);
+function normalizeParseOptions(options) {
+  const lowerCaseTagName = options.lowerCaseTagName ?? true;
+  const lowerCaseAttributeName = options.lowerCaseAttributeName ?? true;
+  const decodeEntities = options.decodeEntities ?? false;
+  const preserveComments = options.preserveComments ?? options.comment ?? false;
+  const voidElements = createNameSet(options.voidElements ?? defaultVoidElementNames);
+  const rawTextElements = createNameSet(options.rawTextElements ?? defaultRawTextElementNames);
+  return {
+    lowerCaseTagName,
+    lowerCaseAttributeName,
+    decodeEntities,
+    preserveComments,
+    voidElements,
+    rawTextElements
+  };
+}
+function parseTag(content, options) {
+  let body = content;
+  let selfClosing = false;
+  if (body.endsWith("/")) {
+    body = body.slice(0, -1);
+    selfClosing = true;
+  }
+  const firstSpace = body.search(/\s/);
+  const rawName = firstSpace === -1 ? body : body.slice(0, firstSpace);
+  const attrsSource = firstSpace === -1 ? "" : body.slice(firstSpace).trim();
+  const normalizedTagName = rawName.toLowerCase();
+  const tagName = options.lowerCaseTagName ? normalizedTagName : rawName;
+  const attrs = parseAttributes(attrsSource, options);
+  return { tagName, normalizedTagName, attrs, selfClosing };
+}
+function parseAttributes(source, options) {
+  const attrs = {};
+  let i = 0;
+  while (i < source.length) {
+    while (i < source.length && isWhitespace(source[i])) {
+      i += 1;
+    }
+    if (i >= source.length) {
+      break;
+    }
+    const nameStart = i;
+    while (i < source.length && !isWhitespace(source[i]) && source[i] !== "=") {
+      i += 1;
+    }
+    let name = source.slice(nameStart, i);
+    while (i < source.length && isWhitespace(source[i])) {
+      i += 1;
+    }
+    let value = "";
+    if (source[i] === "=") {
+      i += 1;
+      while (i < source.length && isWhitespace(source[i])) {
+        i += 1;
+      }
+      if (source[i] === '"' || source[i] === "'") {
+        const quote = source[i];
+        i += 1;
+        const valueStart = i;
+        while (i < source.length && source[i] !== quote) {
+          i += 1;
+        }
+        value = source.slice(valueStart, i);
+        i += 1;
+      } else {
+        const valueStart = i;
+        while (i < source.length && !isWhitespace(source[i])) {
+          i += 1;
+        }
+        value = source.slice(valueStart, i);
+      }
+    }
+    if (name) {
+      if (options.lowerCaseAttributeName) {
+        name = name.toLowerCase();
+      }
+      attrs[name] = options.decodeEntities ? decodeHtmlEntities(value) : value;
+    }
+  }
+  return attrs;
+}
+function readTag(html, start) {
+  let i = start;
+  let inQuote = null;
+  while (i < html.length) {
+    const char = html[i];
+    if (char === '"' || char === "'") {
+      if (inQuote === char) {
+        inQuote = null;
+      } else if (!inQuote) {
+        inQuote = char;
+      }
+    } else if (char === ">" && !inQuote) {
+      break;
+    }
+    i += 1;
+  }
+  return {
+    content: html.slice(start, i).trim(),
+    endIndex: i
+  };
+}
+function extractClosingName(content) {
+  const body = content.slice(1).trim();
+  if (!body) {
+    return null;
+  }
+  const firstSpace = body.search(/\s/);
+  return firstSpace === -1 ? body : body.slice(0, firstSpace);
+}
+function findRawTextClosure(html, start, normalizedTagName) {
+  let index = start;
+  while (index < html.length) {
+    const lt = html.indexOf("</", index);
+    if (lt === -1) {
+      return null;
+    }
+    const { content, endIndex } = readTag(html, lt + 1);
+    if (content.startsWith("/")) {
+      const closingName = extractClosingName(content);
+      if (closingName && closingName.toLowerCase() === normalizedTagName) {
+        return { start: lt, end: endIndex };
+      }
+    }
+    index = endIndex + 1;
+  }
+  return null;
+}
+function createNameSet(input) {
+  const set = /* @__PURE__ */ new Set();
+  for (const value of input) {
+    set.add(value.toLowerCase());
+  }
+  return set;
+}
+function isWhitespace(char) {
+  return char === " " || char === "\n" || char === "	" || char === "\r" || char === "\f";
+}
+function decodeHtmlEntities(value) {
+  return value.replace(/&(#x?[0-9a-fA-F]+|[\w]+);/g, (_, entity) => {
+    if (entity.startsWith("#")) {
+      const isHex = entity.length > 1 && entity[1].toLowerCase() === "x";
+      const code = isHex ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : "";
+    }
+    return namedEntities[entity] ?? _;
+  });
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+}
+function detach(node) {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+function serializePretty(node, indent, newline, depth) {
+  const pad = indent.repeat(depth);
+  if (node instanceof TextNode || node instanceof CommentNode) {
+    const value = node.toString();
+    return value ? `${pad}${value}` : "";
+  }
+  if (node instanceof DocumentFragment) {
+    return node.childNodes.map((child) => serializePretty(child, indent, newline, depth)).filter(Boolean).join(newline);
+  }
+  if (!(node instanceof HTMLElement)) {
+    return "";
+  }
+  const element = node;
+  const attrString = Object.entries(element.attrs).map(([key, value]) => value === "" ? key : `${key}="${escapeAttribute(value)}"`).join(" ");
+  const openTag = attrString ? `<${element.tagName} ${attrString}>` : `<${element.tagName}>`;
+  if (element.isVoidElement || !element.childNodes.length) {
+    if (element.isVoidElement) {
+      return `${pad}${openTag}`;
+    }
+    return `${pad}${openTag}</${element.tagName}>`;
+  }
+  const children = element.childNodes.map((child) => serializePretty(child, indent, newline, depth + 1)).filter(Boolean).join(newline);
+  const closing = `</${element.tagName}>`;
+  if (!children) {
+    return `${pad}${openTag}${closing}`;
+  }
+  return `${pad}${openTag}${newline}${children}${newline}${pad}${closing}`;
+}
+function traverse(nodes, visitor, parent, depth) {
+  for (let i = 0; i < nodes.length; i += 1) {
+    const node = nodes[i];
+    const signal = visitor(node, { parent, depth, index: i });
+    if (signal === "stop") {
+      return true;
+    }
+    if (signal !== "skip" && isParentNode(node) && node.childNodes.length) {
+      if (traverse(node.childNodes, visitor, node, depth + 1)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/compiler/compileTemplate.js
+var structuralAttrs = /* @__PURE__ */ new Set(["ce:if", "ce:else", "ce:for", "track", "ce:slot", "ce:await", "ce:then", "ce:catch"]);
+var TemplateCompiler = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.instructions = [];
+    this.styles = [];
+  }
+  compile(source) {
+    const html = parse(`<fragment>${source}</fragment>`, {
+      comment: false,
+      lowerCaseTagName: false
+    });
+    const fragment = html.firstChild ?? html;
+    const nodes = fragment.childNodes;
+    this.walkNodes(nodes);
+    return {
+      name: this.options.name,
+      instructions: this.instructions,
+      styles: this.styles.length ? this.styles : void 0,
+      scopeId: this.options.scopeId
+    };
+  }
+  walkNodes(nodes) {
+    for (let i = 0; i < nodes.length; i += 1) {
+      const node = nodes[i];
+      if (isStyleNode(node)) {
+        const styleText = node.textContent.trim();
+        if (styleText) {
+          this.styles.push(styleText);
+        }
+        continue;
+      }
+      if (node.nodeType === NodeType.ELEMENT_NODE) {
+        const element = node;
+        if (element.hasAttribute("ce:else")) {
+          continue;
+        }
+        if (element.hasAttribute("ce:await")) {
+          this.instructions.push(this.compileAwait(element));
+          continue;
+        }
+        if (element.hasAttribute("ce:if")) {
+          const { instruction, consumedElse } = this.compileConditional(element, nodes, i);
+          this.instructions.push(instruction);
+          if (consumedElse) {
+            i += 1;
+          }
+          continue;
+        }
+        if (element.hasAttribute("ce:for")) {
+          this.instructions.push(this.compileLoop(element));
+          continue;
+        }
+        this.instructions.push(this.compileElement(element));
+        continue;
+      }
+      if (node.nodeType === NodeType.TEXT_NODE) {
+        this.instructions.push(...this.compileText(node));
+      }
+    }
+  }
+  compileConditional(element, nodes, index) {
+    const condition = element.getAttribute("ce:if") ?? "";
+    const truthy = [this.compileElement(element, true)];
+    let falsy;
+    let consumedElse = false;
+    const next = nodes[index + 1];
+    if (next && next.nodeType === NodeType.ELEMENT_NODE) {
+      const nextElement = next;
+      if (nextElement.hasAttribute("ce:else")) {
+        falsy = [this.compileElement(nextElement, true)];
+        consumedElse = true;
+      }
+    }
+    return {
+      instruction: {
+        type: "if",
+        condition,
+        truthy,
+        falsy
+      },
+      consumedElse
+    };
+  }
+  compileLoop(element) {
+    const loopExpr = element.getAttribute("ce:for") ?? "";
+    const loop = parseLoop(loopExpr);
+    return {
+      type: "for",
+      ...loop,
+      children: [this.compileElement(element, true)]
+    };
+  }
+  compileElement(element, stripStructural = false) {
+    if (element.tagName.toLowerCase() === "slot") {
+      const fallback = [];
+      for (const child of element.childNodes) {
+        if (child.nodeType === NodeType.TEXT_NODE) {
+          fallback.push(...this.compileText(child));
+        } else if (child.nodeType === NodeType.ELEMENT_NODE) {
+          fallback.push(this.compileElement(child));
+        }
+      }
+      return {
+        type: "slot",
+        name: element.getAttribute("name") ?? void 0,
+        children: fallback
+      };
+    }
+    const attributes = [];
+    const attrSource = element.attrs;
+    for (const [key, rawValue] of Object.entries(attrSource)) {
+      const value = String(rawValue);
+      if (stripStructural && structuralAttrs.has(key)) {
+        continue;
+      }
+      if (key.startsWith("on:")) {
+        const eventName = key.slice(3);
+        attributes.push({ kind: "event", name: eventName, handler: value });
+        continue;
+      }
+      if (key.startsWith("[") && key.endsWith("]")) {
+        const prop = key.slice(1, -1);
+        attributes.push({ kind: "property", name: prop, expression: value });
+        continue;
+      }
+      if (key.startsWith("bind:")) {
+        const prop = key.slice(5);
+        attributes.push({ kind: "property", name: prop, expression: value });
+        continue;
+      }
+      if (key === "class:list") {
+        attributes.push({ kind: "class-list", expression: value });
+        continue;
+      }
+      if (key === "ce:slot") {
+        attributes.push({ kind: "static", name: "slot", value });
+        continue;
+      }
+      attributes.push({ kind: "static", name: key, value });
+    }
+    const children = [];
+    for (const child of element.childNodes) {
+      if (isStyleNode(child)) {
+        continue;
+      }
+      if (child.nodeType === NodeType.ELEMENT_NODE) {
+        const childEl = child;
+        if (childEl.hasAttribute("ce:await")) {
+          children.push(this.compileAwait(childEl));
+          continue;
+        }
+        if (childEl.hasAttribute("ce:if") || childEl.hasAttribute("ce:for")) {
+          const compiledFragment = compileTemplate(childEl.toString(), this.options);
+          children.push(...compiledFragment.instructions);
+          continue;
+        }
+        children.push(this.compileElement(childEl));
+        continue;
+      }
+      if (child.nodeType === NodeType.TEXT_NODE) {
+        children.push(...this.compileText(child));
+      }
+    }
+    return {
+      type: "element",
+      tag: element.tagName.toLowerCase(),
+      attributes,
+      children
+    };
+  }
+  compileAwait(element) {
+    if (element.tagName.toLowerCase() !== "template") {
+      throw new Error("ce:await must be used on a <template> element.");
+    }
+    const expression = element.getAttribute("ce:await") ?? "";
+    const pending = [];
+    let resolved = [];
+    let rejected = [];
+    let valueName;
+    let errorName;
+    for (const child of element.childNodes) {
+      if (isStyleNode(child)) {
+        continue;
+      }
+      if (child.nodeType === NodeType.ELEMENT_NODE) {
+        const childEl = child;
+        if (childEl.tagName.toLowerCase() === "template" && childEl.hasAttribute("ce:then")) {
+          valueName = childEl.getAttribute("ce:then") ?? void 0;
+          resolved = this.compileTemplateChildren(childEl);
+          continue;
+        }
+        if (childEl.tagName.toLowerCase() === "template" && childEl.hasAttribute("ce:catch")) {
+          errorName = childEl.getAttribute("ce:catch") ?? void 0;
+          rejected = this.compileTemplateChildren(childEl);
+          continue;
+        }
+        pending.push(this.compileElement(childEl));
+        continue;
+      }
+      if (child.nodeType === NodeType.TEXT_NODE) {
+        pending.push(...this.compileText(child));
+      }
+    }
+    return {
+      type: "await",
+      expression,
+      pending,
+      resolved,
+      rejected,
+      valueName,
+      errorName
+    };
+  }
+  compileTemplateChildren(element) {
+    const children = [];
+    for (const child of element.childNodes) {
+      if (isStyleNode(child)) {
+        continue;
+      }
+      if (child.nodeType === NodeType.TEXT_NODE) {
+        children.push(...this.compileText(child));
+        continue;
+      }
+      if (child.nodeType === NodeType.ELEMENT_NODE) {
+        const childEl = child;
+        if (childEl.hasAttribute("ce:await")) {
+          children.push(this.compileAwait(childEl));
+          continue;
+        }
+        if (childEl.hasAttribute("ce:if") || childEl.hasAttribute("ce:for")) {
+          const compiledFragment = compileTemplate(childEl.toString(), this.options);
+          children.push(...compiledFragment.instructions);
+          continue;
+        }
+        children.push(this.compileElement(childEl));
+      }
+    }
+    return children;
+  }
+  compileText(node) {
+    const content = node.text;
+    if (!this.options.preserveWhitespace && !content.trim()) {
+      return [];
+    }
+    const parts = content.split(/({{[^}]+}})/g).filter(Boolean);
+    return parts.map((part) => {
+      if (part.startsWith("{{") && part.endsWith("}}")) {
+        return {
+          type: "expression",
+          expression: part.slice(2, -2).trim()
+        };
+      }
+      return {
+        type: "text",
+        value: this.options.preserveWhitespace ? part : part.trim()
+      };
+    });
+  }
+};
+function compileTemplate(source, options = {}) {
+  return new TemplateCompiler(options).compile(source);
+}
+function parseLoop(expression) {
+  const loopRegex = /^(?<item>[\w$]+)(?:\s*,\s*(?<index>[\w$]+))?\s+in\s+(?<iterator>.+)$/;
+  const match = loopRegex.exec(expression.trim());
+  const groups = match?.groups;
+  if (!groups) {
+    throw new Error(`Invalid ce:for expression: ${expression}`);
+  }
+  return {
+    item: groups.item,
+    index: groups.index,
+    iterator: groups.iterator
+  };
+}
+function isStyleNode(node) {
+  return node.nodeType === NodeType.ELEMENT_NODE && node.tagName === "STYLE";
+}
+
+export { CommentNode, DocumentFragment, HTMLElement, NodeType, TextNode, cloneNode, compileTemplate, createCommentNode, createElement, createFragment, createTextNode, isCommentNode, isElementNode, isParentNode, isTextNode, parse, serialize, walk };
+//# sourceMappingURL=chunk-BBAUALNU.js.map
+//# sourceMappingURL=chunk-BBAUALNU.js.map