@collie-lang/compiler 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2035 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  compile: () => compile,
+  compileToHtml: () => compileToHtml,
+  compileToJsx: () => compileToJsx,
+  compileToTsx: () => compileToTsx,
+  parse: () => parseCollie,
+  parseCollie: () => parseCollie
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/codegen.ts
+function generateModule(root, options) {
+  const { componentName, jsxRuntime, flavor } = options;
+  const isTsx = flavor === "tsx";
+  const aliasEnv = buildClassAliasEnvironment(root.classAliases);
+  const jsx = renderRootChildren(root.children, aliasEnv);
+  const propsDestructure = emitPropsDestructure(root.props);
+  const parts = [];
+  if (root.clientComponent) {
+    parts.push(`"use client";`);
+  }
+  if (jsxRuntime === "classic" && templateUsesJsx(root)) {
+    parts.push(`import React from "react";`);
+  }
+  parts.push(emitPropsType(root.props, flavor));
+  if (!isTsx) {
+    parts.push(`/** @param {Props} props */`);
+  }
+  const functionLines = [
+    isTsx ? `export default function ${componentName}(props: Props) {` : `export default function ${componentName}(props) {`
+  ];
+  if (propsDestructure) {
+    functionLines.push(`  ${propsDestructure}`);
+  }
+  functionLines.push(`  return ${jsx};`, `}`);
+  parts.push(functionLines.join("\n"));
+  return parts.join("\n\n");
+}
+function buildClassAliasEnvironment(decl) {
+  const env = /* @__PURE__ */ new Map();
+  if (!decl) {
+    return env;
+  }
+  for (const alias of decl.aliases) {
+    env.set(alias.name, alias.classes);
+  }
+  return env;
+}
+function renderRootChildren(children, aliasEnv) {
+  return emitNodesExpression(children, aliasEnv);
+}
+function templateUsesJsx(root) {
+  if (root.children.length === 0) {
+    return false;
+  }
+  if (root.children.length > 1) {
+    return true;
+  }
+  return nodeUsesJsx(root.children[0]);
+}
+function nodeUsesJsx(node) {
+  if (node.type === "Element" || node.type === "Text" || node.type === "Component") {
+    return true;
+  }
+  if (node.type === "Expression" || node.type === "JSXPassthrough") {
+    return false;
+  }
+  if (node.type === "Conditional") {
+    return node.branches.some((branch) => branchUsesJsx(branch));
+  }
+  if (node.type === "For") {
+    return node.body.some((child) => nodeUsesJsx(child));
+  }
+  return false;
+}
+function branchUsesJsx(branch) {
+  if (!branch.body.length) {
+    return false;
+  }
+  return branch.body.some((child) => nodeUsesJsx(child));
+}
+function emitNodeInJsx(node, aliasEnv) {
+  if (node.type === "Text") {
+    return emitText(node);
+  }
+  if (node.type === "Expression") {
+    return `{${node.value}}`;
+  }
+  if (node.type === "JSXPassthrough") {
+    return `{${node.expression}}`;
+  }
+  if (node.type === "Conditional") {
+    return `{${emitConditionalExpression(node, aliasEnv)}}`;
+  }
+  if (node.type === "For") {
+    return `{${emitForExpression(node, aliasEnv)}}`;
+  }
+  if (node.type === "Component") {
+    return wrapWithGuard(emitComponent(node, aliasEnv), node.guard, "jsx");
+  }
+  return wrapWithGuard(emitElement(node, aliasEnv), node.guard, "jsx");
+}
+function emitElement(node, aliasEnv) {
+  const expanded = expandClasses(node.classes, aliasEnv);
+  const classAttr = expanded.length ? ` className="${expanded.join(" ")}"` : "";
+  const attrs = emitAttributes(node.attributes, aliasEnv);
+  const allAttrs = classAttr + attrs;
+  const children = emitChildrenWithSpacing(node.children, aliasEnv);
+  if (children.length > 0) {
+    return `<${node.name}${allAttrs}>${children}</${node.name}>`;
+  } else {
+    return `<${node.name}${allAttrs} />`;
+  }
+}
+function emitComponent(node, aliasEnv) {
+  const attrs = emitAttributes(node.attributes, aliasEnv);
+  const slotProps = emitSlotProps(node, aliasEnv);
+  const allAttrs = `${attrs}${slotProps}`;
+  const children = emitChildrenWithSpacing(node.children, aliasEnv);
+  if (children.length > 0) {
+    return `<${node.name}${allAttrs}>${children}</${node.name}>`;
+  } else {
+    return `<${node.name}${allAttrs} />`;
+  }
+}
+function emitChildrenWithSpacing(children, aliasEnv) {
+  if (children.length === 0) {
+    return "";
+  }
+  const parts = [];
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    const emitted = emitNodeInJsx(child, aliasEnv);
+    parts.push(emitted);
+    if (i < children.length - 1) {
+      const nextChild = children[i + 1];
+      const needsSpace = child.type === "Text" && (nextChild.type === "Element" || nextChild.type === "Component" || nextChild.type === "Expression" || nextChild.type === "JSXPassthrough");
+      if (needsSpace) {
+        parts.push(" ");
+      }
+    }
+  }
+  return parts.join("");
+}
+function emitAttributes(attributes, aliasEnv) {
+  if (attributes.length === 0) {
+    return "";
+  }
+  return attributes.map((attr) => {
+    if (attr.value === null) {
+      return ` ${attr.name}`;
+    }
+    return ` ${attr.name}=${attr.value}`;
+  }).join("");
+}
+function emitSlotProps(node, aliasEnv) {
+  if (!node.slots || node.slots.length === 0) {
+    return "";
+  }
+  return node.slots.map((slot) => {
+    const expr = emitNodesExpression(slot.children, aliasEnv);
+    return ` ${slot.name}={${expr}}`;
+  }).join("");
+}
+function wrapWithGuard(rendered, guard, context) {
+  if (!guard) {
+    return rendered;
+  }
+  const expression = `(${guard}) && ${rendered}`;
+  return context === "jsx" ? `{${expression}}` : expression;
+}
+function emitForExpression(node, aliasEnv) {
+  const body = emitNodesExpression(node.body, aliasEnv);
+  return `${node.arrayExpr}.map((${node.itemName}) => ${body})`;
+}
+function expandClasses(classes, aliasEnv) {
+  const result = [];
+  for (const cls of classes) {
+    const match = cls.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (!match) {
+      result.push(cls);
+      continue;
+    }
+    const aliasClasses = aliasEnv.get(match[1]);
+    if (!aliasClasses) {
+      continue;
+    }
+    result.push(...aliasClasses);
+  }
+  return result;
+}
+function emitText(node) {
+  if (!node.parts.length) {
+    return "";
+  }
+  return node.parts.map((part) => {
+    if (part.type === "text") {
+      return escapeText(part.value);
+    }
+    return `{${part.value}}`;
+  }).join("");
+}
+function emitConditionalExpression(node, aliasEnv) {
+  if (!node.branches.length) {
+    return "null";
+  }
+  const first = node.branches[0];
+  if (node.branches.length === 1 && first.test) {
+    return `(${first.test}) && ${emitBranchExpression(first, aliasEnv)}`;
+  }
+  const hasElse = node.branches[node.branches.length - 1].test === void 0;
+  let fallback = hasElse ? emitBranchExpression(node.branches[node.branches.length - 1], aliasEnv) : "null";
+  const startIndex = hasElse ? node.branches.length - 2 : node.branches.length - 1;
+  if (startIndex < 0) {
+    return fallback;
+  }
+  for (let i = startIndex; i >= 0; i--) {
+    const branch = node.branches[i];
+    const test = branch.test ?? "false";
+    fallback = `(${test}) ? ${emitBranchExpression(branch, aliasEnv)} : ${fallback}`;
+  }
+  return fallback;
+}
+function emitBranchExpression(branch, aliasEnv) {
+  return emitNodesExpression(branch.body, aliasEnv);
+}
+function emitNodesExpression(children, aliasEnv) {
+  if (children.length === 0) {
+    return "null";
+  }
+  if (children.length === 1) {
+    return emitSingleNodeExpression(children[0], aliasEnv);
+  }
+  return `<>${children.map((child) => emitNodeInJsx(child, aliasEnv)).join("")}</>`;
+}
+function emitSingleNodeExpression(node, aliasEnv) {
+  if (node.type === "Expression") {
+    return node.value;
+  }
+  if (node.type === "JSXPassthrough") {
+    return node.expression;
+  }
+  if (node.type === "Conditional") {
+    return emitConditionalExpression(node, aliasEnv);
+  }
+  if (node.type === "For") {
+    return emitForExpression(node, aliasEnv);
+  }
+  if (node.type === "Element") {
+    return wrapWithGuard(emitElement(node, aliasEnv), node.guard, "expression");
+  }
+  if (node.type === "Component") {
+    return wrapWithGuard(emitComponent(node, aliasEnv), node.guard, "expression");
+  }
+  if (node.type === "Text") {
+    return `<>${emitNodeInJsx(node, aliasEnv)}</>`;
+  }
+  return emitNodeInJsx(node, aliasEnv);
+}
+function emitPropsType(props, flavor) {
+  if (flavor === "tsx") {
+    return emitTsPropsType(props);
+  }
+  return emitJsDocPropsType(props);
+}
+function emitJsDocPropsType(props) {
+  if (!props) {
+    return "/** @typedef {any} Props */";
+  }
+  if (!props.fields.length) {
+    return "/** @typedef {{}} Props */";
+  }
+  const fields = props.fields.map((field) => {
+    const optional = field.optional ? "?" : "";
+    return `${field.name}${optional}: ${field.typeText}`;
+  }).join("; ");
+  return `/** @typedef {{ ${fields} }} Props */`;
+}
+function emitTsPropsType(props) {
+  if (!props || props.fields.length === 0) {
+    return "export type Props = Record<string, never>;";
+  }
+  const lines = props.fields.map((field) => {
+    const optional = field.optional ? "?" : "";
+    return `  ${field.name}${optional}: ${field.typeText};`;
+  });
+  return ["export interface Props {", ...lines, "}"].join("\n");
+}
+function emitPropsDestructure(props) {
+  if (!props || props.fields.length === 0) {
+    return null;
+  }
+  const names = props.fields.map((field) => field.name);
+  return `const { ${names.join(", ")} } = props;`;
+}
+function escapeText(value) {
+  return value.replace(/[&<>{}]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "{":
+        return "&#123;";
+      case "}":
+        return "&#125;";
+      default:
+        return char;
+    }
+  });
+}
+
+// src/html-codegen.ts
+function generateHtmlModule(root, options) {
+  const aliasEnv = buildClassAliasEnvironment2(root.classAliases);
+  const htmlExpression = emitNodesString(root.children, aliasEnv);
+  const propsType = emitJsDocPropsType2(root.props);
+  const propsDestructure = emitPropsDestructure2(root.props);
+  const parts = [];
+  if (root.clientComponent) {
+    parts.push(`"use client";`);
+  }
+  parts.push(...createHtmlHelpers());
+  parts.push(propsType);
+  parts.push(`/** @param {Props} props */`);
+  parts.push(`/** @returns {string} */`);
+  const lines = [`export default function ${options.componentName}(props = {}) {`];
+  if (propsDestructure) {
+    lines.push(`  ${propsDestructure}`);
+  }
+  lines.push(`  const __collie_html = ${htmlExpression};`);
+  lines.push("  return __collie_html;", "}");
+  parts.push(lines.join("\n"));
+  return parts.join("\n\n");
+}
+function emitNodesString(children, aliasEnv) {
+  if (children.length === 0) {
+    return '""';
+  }
+  const segments = children.map((child) => emitNodeString(child, aliasEnv)).filter(Boolean);
+  return concatSegments(segments);
+}
+function emitNodeString(node, aliasEnv) {
+  switch (node.type) {
+    case "Text":
+      return emitTextNode(node);
+    case "Expression":
+      return `__collie_escapeHtml(${node.value})`;
+    case "JSXPassthrough":
+      return `String(${node.expression})`;
+    case "Element":
+      return wrapWithGuard2(emitElement2(node, aliasEnv), node.guard);
+    case "Component":
+      return wrapWithGuard2(emitComponent2(node, aliasEnv), node.guard);
+    case "Conditional":
+      return emitConditional(node, aliasEnv);
+    case "For":
+      return emitFor(node, aliasEnv);
+    default:
+      return '""';
+  }
+}
+function emitElement2(node, aliasEnv) {
+  const classSegments = expandClasses2(node.classes, aliasEnv);
+  const attributeSegments = emitAttributeSegments(node.attributes, classSegments);
+  const start = concatSegments([literal(`<${node.name}`), ...attributeSegments, literal(node.children.length > 0 ? ">" : " />")]);
+  if (node.children.length === 0) {
+    return start;
+  }
+  const children = emitNodesString(node.children, aliasEnv);
+  const end = literal(`</${node.name}>`);
+  return concatSegments([start, children, end]);
+}
+function emitComponent2(node, aliasEnv) {
+  const attributeSegments = emitAttributeSegments(node.attributes, []);
+  const hasChildren = node.children.length > 0 || (node.slots?.length ?? 0) > 0;
+  const closingToken = hasChildren ? ">" : " />";
+  const start = concatSegments([literal(`<${node.name}`), ...attributeSegments, literal(closingToken)]);
+  if (!hasChildren) {
+    return start;
+  }
+  const childSegments = [];
+  if (node.children.length) {
+    childSegments.push(emitNodesString(node.children, aliasEnv));
+  }
+  for (const slot of node.slots ?? []) {
+    childSegments.push(emitSlotTemplate(slot, aliasEnv));
+  }
+  const children = concatSegments(childSegments);
+  const end = literal(`</${node.name}>`);
+  return concatSegments([start, children, end]);
+}
+function emitSlotTemplate(slot, aliasEnv) {
+  const start = literal(`<template slot="${slot.name}">`);
+  const body = emitNodesString(slot.children, aliasEnv);
+  const end = literal("</template>");
+  return concatSegments([start, body, end]);
+}
+function emitConditional(node, aliasEnv) {
+  if (node.branches.length === 0) {
+    return '""';
+  }
+  const first = node.branches[0];
+  if (node.branches.length === 1 && first.test) {
+    return `(${first.test}) ? ${emitBranch(first, aliasEnv)} : ""`;
+  }
+  const hasElse = node.branches[node.branches.length - 1].test === void 0;
+  let fallback = hasElse ? emitBranch(node.branches[node.branches.length - 1], aliasEnv) : '""';
+  const limit = hasElse ? node.branches.length - 2 : node.branches.length - 1;
+  for (let i = limit; i >= 0; i--) {
+    const branch = node.branches[i];
+    const test = branch.test ?? "false";
+    fallback = `(${test}) ? ${emitBranch(branch, aliasEnv)} : ${fallback}`;
+  }
+  return fallback;
+}
+function emitBranch(branch, aliasEnv) {
+  return emitNodesString(branch.body, aliasEnv);
+}
+function emitFor(node, aliasEnv) {
+  const body = emitNodesString(node.body, aliasEnv);
+  return `(${node.arrayExpr}).map((${node.itemName}) => ${body}).join("")`;
+}
+function emitTextNode(node) {
+  if (!node.parts.length) {
+    return '""';
+  }
+  const segments = node.parts.map((part) => {
+    if (part.type === "text") {
+      return literal(escapeStaticText(part.value));
+    }
+    return `__collie_escapeHtml(${part.value})`;
+  });
+  return concatSegments(segments);
+}
+function emitAttributeSegments(attributes, classNames) {
+  const segments = [];
+  if (classNames.length) {
+    segments.push(literal(` class="${classNames.join(" ")}"`));
+  }
+  for (const attr of attributes) {
+    if (attr.value === null) {
+      segments.push(literal(` ${attr.name}`));
+      continue;
+    }
+    const expr = attributeExpression(attr.value);
+    segments.push(
+      [
+        "(() => {",
+        `  const __collie_attr = ${expr};`,
+        `  return __collie_attr == null ? "" : ${literal(` ${attr.name}="`)} + __collie_escapeAttr(__collie_attr) + ${literal(`"`)};`,
+        "})()"
+      ].join(" ")
+    );
+  }
+  return segments;
+}
+function attributeExpression(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function wrapWithGuard2(rendered, guard) {
+  if (!guard) {
+    return rendered;
+  }
+  return `(${guard}) ? ${rendered} : ""`;
+}
+function literal(text) {
+  return JSON.stringify(text);
+}
+function concatSegments(segments) {
+  const filtered = segments.filter((segment) => segment && segment !== '""');
+  if (!filtered.length) {
+    return '""';
+  }
+  if (filtered.length === 1) {
+    return filtered[0];
+  }
+  return filtered.join(" + ");
+}
+function buildClassAliasEnvironment2(decl) {
+  const env = /* @__PURE__ */ new Map();
+  if (!decl) {
+    return env;
+  }
+  for (const alias of decl.aliases) {
+    env.set(alias.name, alias.classes);
+  }
+  return env;
+}
+function expandClasses2(classes, aliasEnv) {
+  const result = [];
+  for (const cls of classes) {
+    const match = cls.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (!match) {
+      result.push(cls);
+      continue;
+    }
+    const aliasClasses = aliasEnv.get(match[1]);
+    if (!aliasClasses) {
+      continue;
+    }
+    result.push(...aliasClasses);
+  }
+  return result;
+}
+function emitJsDocPropsType2(props) {
+  if (!props) {
+    return "/** @typedef {any} Props */";
+  }
+  if (!props.fields.length) {
+    return "/** @typedef {{}} Props */";
+  }
+  const fields = props.fields.map((field) => {
+    const optional = field.optional ? "?" : "";
+    return `${field.name}${optional}: ${field.typeText}`;
+  }).join("; ");
+  return `/** @typedef {{ ${fields} }} Props */`;
+}
+function emitPropsDestructure2(props) {
+  if (!props || props.fields.length === 0) {
+    return null;
+  }
+  const names = props.fields.map((field) => field.name);
+  return `const { ${names.join(", ")} } = props;`;
+}
+function escapeStaticText(value) {
+  return value.replace(/[&<>{}]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "{":
+        return "&#123;";
+      case "}":
+        return "&#125;";
+      default:
+        return char;
+    }
+  });
+}
+function createHtmlHelpers() {
+  return [
+    "function __collie_escapeHtml(value) {",
+    "  if (value === null || value === undefined) {",
+    '    return "";',
+    "  }",
+    "  return String(value).replace(/[&<>]/g, __collie_escapeHtmlChar);",
+    "}",
+    "function __collie_escapeHtmlChar(char) {",
+    "  switch (char) {",
+    '    case "&":',
+    '      return "&amp;";',
+    '    case "<":',
+    '      return "&lt;";',
+    '    case ">":',
+    '      return "&gt;";',
+    "    default:",
+    "      return char;",
+    "  }",
+    "}",
+    "function __collie_escapeAttr(value) {",
+    "  if (value === null || value === undefined) {",
+    '    return "";',
+    "  }",
+    '  return String(value).replace(/["&<>]/g, __collie_escapeAttrChar);',
+    "}",
+    "function __collie_escapeAttrChar(char) {",
+    "  switch (char) {",
+    '    case "&":',
+    '      return "&amp;";',
+    '    case "<":',
+    '      return "&lt;";',
+    '    case ">":',
+    '      return "&gt;";',
+    `    case '"':`,
+    '      return "&quot;";',
+    "    default:",
+    "      return char;",
+    "  }",
+    "}"
+  ];
+}
+
+// src/diagnostics.ts
+function createSpan(line, col, length, lineOffset) {
+  const startOffset = lineOffset + col - 1;
+  return {
+    start: { line, col, offset: startOffset },
+    end: { line, col: col + length, offset: startOffset + length }
+  };
+}
+
+// src/parser.ts
+function getIndentLevel(line) {
+  const match = line.match(/^\s*/);
+  return match ? match[0].length / 2 : 0;
+}
+function parse(source) {
+  const diagnostics = [];
+  const root = { type: "Root", children: [] };
+  const stack = [{ node: root, level: -1 }];
+  let propsBlockLevel = null;
+  let classesBlockLevel = null;
+  let sawTopLevelTemplateNode = false;
+  const conditionalChains = /* @__PURE__ */ new Map();
+  const branchLocations = [];
+  const normalized = source.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  let offset = 0;
+  let i = 0;
+  while (i < lines.length) {
+    const rawLine = lines[i];
+    const lineNumber = i + 1;
+    const lineOffset = offset;
+    offset += rawLine.length + 1;
+    i++;
+    if (/^\s*$/.test(rawLine)) {
+      continue;
+    }
+    const tabIndex = rawLine.indexOf("	");
+    if (tabIndex !== -1) {
+      pushDiag(
+        diagnostics,
+        "COLLIE001",
+        "Tabs are not allowed; use spaces for indentation.",
+        lineNumber,
+        tabIndex + 1,
+        lineOffset
+      );
+      continue;
+    }
+    const indentMatch = rawLine.match(/^\s*/) ?? [""];
+    const indent = indentMatch[0].length;
+    const lineContent = rawLine.slice(indent);
+    const trimmed = lineContent.trimEnd();
+    if (indent % 2 !== 0) {
+      pushDiag(
+        diagnostics,
+        "COLLIE002",
+        "Indentation must be multiples of two spaces.",
+        lineNumber,
+        indent + 1,
+        lineOffset
+      );
+      continue;
+    }
+    let level = indent / 2;
+    if (propsBlockLevel !== null && level <= propsBlockLevel) {
+      propsBlockLevel = null;
+    }
+    if (classesBlockLevel !== null && level <= classesBlockLevel) {
+      classesBlockLevel = null;
+    }
+    const top = stack[stack.length - 1];
+    const isInPropsBlock = propsBlockLevel !== null && level > propsBlockLevel;
+    const isInClassesBlock = classesBlockLevel !== null && level > classesBlockLevel;
+    if (level > top.level + 1 && !isInPropsBlock && !isInClassesBlock) {
+      pushDiag(
+        diagnostics,
+        "COLLIE003",
+        "Indentation jumped more than one level.",
+        lineNumber,
+        indent + 1,
+        lineOffset
+      );
+      level = top.level + 1;
+    }
+    while (stack.length > 1 && stack[stack.length - 1].level >= level) {
+      stack.pop();
+    }
+    cleanupConditionalChains(conditionalChains, level);
+    const isElseIfLine = /^@elseIf\b/.test(trimmed);
+    const isElseLine = /^@else\b/.test(trimmed) && !isElseIfLine;
+    if (!isElseIfLine && !isElseLine) {
+      conditionalChains.delete(level);
+    }
+    if (trimmed === "classes") {
+      if (level !== 0) {
+        pushDiag(
+          diagnostics,
+          "COLLIE301",
+          "Classes block must be at the top level.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else if (sawTopLevelTemplateNode) {
+        pushDiag(
+          diagnostics,
+          "COLLIE302",
+          "Classes block must appear before any template nodes.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else {
+        if (!root.classAliases) {
+          root.classAliases = { aliases: [] };
+        }
+        classesBlockLevel = level;
+      }
+      continue;
+    }
+    if (trimmed === "props") {
+      if (level !== 0) {
+        pushDiag(
+          diagnostics,
+          "COLLIE102",
+          "Props block must be at the top level.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else if (sawTopLevelTemplateNode || root.props) {
+        pushDiag(
+          diagnostics,
+          "COLLIE101",
+          "Props block must appear before any template nodes.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else {
+        root.props = { fields: [] };
+        propsBlockLevel = level;
+      }
+      continue;
+    }
+    if (trimmed === "@client") {
+      if (level !== 0) {
+        pushDiag(
+          diagnostics,
+          "COLLIE401",
+          "@client must appear at the top level before any other blocks.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else if (sawTopLevelTemplateNode) {
+        pushDiag(
+          diagnostics,
+          "COLLIE401",
+          "@client must appear before any template nodes.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else if (root.clientComponent) {
+        pushDiag(
+          diagnostics,
+          "COLLIE402",
+          "@client can only appear once per file.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      } else {
+        root.clientComponent = true;
+      }
+      continue;
+    }
+    if (propsBlockLevel !== null && level > propsBlockLevel) {
+      if (level !== propsBlockLevel + 1) {
+        pushDiag(
+          diagnostics,
+          "COLLIE102",
+          "Props lines must be indented two spaces under the props header.",
+          lineNumber,
+          indent + 1,
+          lineOffset
+        );
+        continue;
+      }
+      const field = parsePropsField(trimmed, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (field && root.props) {
+        root.props.fields.push(field);
+      }
+      continue;
+    }
+    if (classesBlockLevel !== null && level > classesBlockLevel) {
+      if (level !== classesBlockLevel + 1) {
+        pushDiag(
+          diagnostics,
+          "COLLIE303",
+          "Classes lines must be indented two spaces under the classes header.",
+          lineNumber,
+          indent + 1,
+          lineOffset
+        );
+        continue;
+      }
+      const alias = parseClassAliasLine(trimmed, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (alias && root.classAliases) {
+        root.classAliases.aliases.push(alias);
+      }
+      continue;
+    }
+    const parent = stack[stack.length - 1].node;
+    if (trimmed.startsWith("@for")) {
+      const forHeader = parseForHeader(
+        lineContent,
+        lineNumber,
+        indent + 1,
+        lineOffset,
+        diagnostics
+      );
+      if (!forHeader) {
+        continue;
+      }
+      const forNode = {
+        type: "For",
+        itemName: forHeader.itemName,
+        arrayExpr: forHeader.arrayExpr,
+        body: []
+      };
+      addChildToParent(parent, forNode);
+      if (parent === root) {
+        sawTopLevelTemplateNode = true;
+      }
+      stack.push({ node: forNode, level });
+      continue;
+    }
+    if (trimmed.startsWith("@if")) {
+      const header = parseConditionalHeader(
+        "if",
+        lineContent,
+        lineNumber,
+        indent + 1,
+        lineOffset,
+        diagnostics
+      );
+      if (!header) {
+        continue;
+      }
+      const chain = { type: "Conditional", branches: [] };
+      const branch = { test: header.test, body: [] };
+      chain.branches.push(branch);
+      addChildToParent(parent, chain);
+      if (parent === root) {
+        sawTopLevelTemplateNode = true;
+      }
+      conditionalChains.set(level, { node: chain, level, hasElse: false });
+      branchLocations.push({
+        branch,
+        line: lineNumber,
+        column: indent + 1,
+        lineOffset,
+        length: header.directiveLength
+      });
+      if (header.inlineBody) {
+        const inlineNode = parseInlineNode(
+          header.inlineBody,
+          lineNumber,
+          header.inlineColumn ?? indent + 1,
+          lineOffset,
+          diagnostics
+        );
+        if (inlineNode) {
+          branch.body.push(inlineNode);
+        }
+      } else {
+        stack.push({ node: createConditionalBranchContext(chain, branch), level });
+      }
+      continue;
+    }
+    if (isElseIfLine) {
+      const chain = conditionalChains.get(level);
+      if (!chain) {
+        pushDiag(
+          diagnostics,
+          "COLLIE205",
+          "@elseIf must follow an @if at the same indentation level.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+        continue;
+      }
+      if (chain.hasElse) {
+        pushDiag(
+          diagnostics,
+          "COLLIE207",
+          "@elseIf cannot appear after an @else in the same chain.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+        continue;
+      }
+      const header = parseConditionalHeader(
+        "elseIf",
+        lineContent,
+        lineNumber,
+        indent + 1,
+        lineOffset,
+        diagnostics
+      );
+      if (!header) {
+        continue;
+      }
+      const branch = { test: header.test, body: [] };
+      chain.node.branches.push(branch);
+      branchLocations.push({
+        branch,
+        line: lineNumber,
+        column: indent + 1,
+        lineOffset,
+        length: header.directiveLength
+      });
+      if (header.inlineBody) {
+        const inlineNode = parseInlineNode(
+          header.inlineBody,
+          lineNumber,
+          header.inlineColumn ?? indent + 1,
+          lineOffset,
+          diagnostics
+        );
+        if (inlineNode) {
+          branch.body.push(inlineNode);
+        }
+      } else {
+        stack.push({ node: createConditionalBranchContext(chain.node, branch), level });
+      }
+      continue;
+    }
+    if (isElseLine) {
+      const chain = conditionalChains.get(level);
+      if (!chain) {
+        pushDiag(
+          diagnostics,
+          "COLLIE206",
+          "@else must follow an @if at the same indentation level.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+        continue;
+      }
+      if (chain.hasElse) {
+        pushDiag(
+          diagnostics,
+          "COLLIE203",
+          "An @if chain can only have one @else branch.",
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+        continue;
+      }
+      const header = parseElseHeader(lineContent, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (!header) {
+        continue;
+      }
+      const branch = { test: void 0, body: [] };
+      chain.node.branches.push(branch);
+      chain.hasElse = true;
+      branchLocations.push({
+        branch,
+        line: lineNumber,
+        column: indent + 1,
+        lineOffset,
+        length: header.directiveLength
+      });
+      if (header.inlineBody) {
+        const inlineNode = parseInlineNode(
+          header.inlineBody,
+          lineNumber,
+          header.inlineColumn ?? indent + 1,
+          lineOffset,
+          diagnostics
+        );
+        if (inlineNode) {
+          branch.body.push(inlineNode);
+        }
+      } else {
+        stack.push({ node: createConditionalBranchContext(chain.node, branch), level });
+      }
+      continue;
+    }
+    const slotMatch = trimmed.match(/^@([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (slotMatch) {
+      const slotName = slotMatch[1];
+      if (!isComponentNode(parent)) {
+        pushDiag(
+          diagnostics,
+          "COLLIE501",
+          `Slot '${slotName}' must be a direct child of a component.`,
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+        stack.push({ node: createStandaloneSlotContext(slotName), level });
+        continue;
+      }
+      if (!parent.slots) {
+        parent.slots = [];
+      }
+      const existing = parent.slots.find((slot) => slot.name === slotName);
+      const slotBlock = existing ?? {
+        type: "Slot",
+        name: slotName,
+        children: []
+      };
+      if (!existing) {
+        parent.slots.push(slotBlock);
+      } else {
+        pushDiag(
+          diagnostics,
+          "COLLIE503",
+          `Duplicate slot '${slotName}' inside ${parent.name}.`,
+          lineNumber,
+          indent + 1,
+          lineOffset,
+          trimmed.length
+        );
+      }
+      stack.push({ node: createSlotContext(parent, slotBlock), level });
+      continue;
+    }
+    if (trimmed.startsWith("@")) {
+      pushDiag(
+        diagnostics,
+        "COLLIE502",
+        "Invalid slot syntax. Use @slotName on its own line.",
+        lineNumber,
+        indent + 1,
+        lineOffset,
+        trimmed.length
+      );
+      const fallbackName = trimmed.slice(1).split(/\s+/)[0] || "slot";
+      stack.push({ node: createStandaloneSlotContext(fallbackName), level });
+      continue;
+    }
+    if (lineContent.startsWith("=")) {
+      const payload = lineContent.slice(1).trim();
+      if (payload.endsWith("(") || payload.endsWith("<") || i < lines.length && level < getIndentLevel(lines[i])) {
+        let jsxContent = payload;
+        const jsxStartLine = i;
+        while (i < lines.length) {
+          const nextRaw = lines[i];
+          const nextIndent = getIndentLevel(nextRaw);
+          const nextTrimmed = nextRaw.trim();
+          if (nextIndent > level && nextTrimmed.length > 0) {
+            jsxContent += "\n" + nextRaw;
+            i++;
+          } else if (nextIndent === level && /^[)\]}]+$/.test(nextTrimmed)) {
+            jsxContent += "\n" + nextRaw;
+            i++;
+            break;
+          } else {
+            break;
+          }
+        }
+        const jsxNode2 = {
+          type: "JSXPassthrough",
+          expression: jsxContent
+        };
+        addChildToParent(parent, jsxNode2);
+        if (parent === root) {
+          sawTopLevelTemplateNode = true;
+        }
+        continue;
+      }
+      const jsxNode = parseJSXPassthrough(lineContent, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (jsxNode) {
+        addChildToParent(parent, jsxNode);
+        if (parent === root) {
+          sawTopLevelTemplateNode = true;
+        }
+      }
+      continue;
+    }
+    if (lineContent.startsWith("|")) {
+      const textNode = parseTextLine(lineContent, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (textNode) {
+        addChildToParent(parent, textNode);
+        if (parent === root) {
+          sawTopLevelTemplateNode = true;
+        }
+      }
+      continue;
+    }
+    if (lineContent.startsWith("{{")) {
+      const exprNode = parseExpressionLine(lineContent, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (exprNode) {
+        addChildToParent(parent, exprNode);
+        if (parent === root) {
+          sawTopLevelTemplateNode = true;
+        }
+      }
+      continue;
+    }
+    let fullLine = trimmed;
+    let multilineEnd = i;
+    if (trimmed.includes("(") && !trimmed.includes(")")) {
+      let parenDepth = (trimmed.match(/\(/g) || []).length - (trimmed.match(/\)/g) || []).length;
+      while (multilineEnd < lines.length && parenDepth > 0) {
+        const nextRaw = lines[multilineEnd];
+        multilineEnd++;
+        fullLine += "\n" + nextRaw;
+        parenDepth += (nextRaw.match(/\(/g) || []).length - (nextRaw.match(/\)/g) || []).length;
+      }
+      i = multilineEnd;
+    }
+    const element = parseElement(fullLine, lineNumber, indent + 1, lineOffset, diagnostics);
+    if (!element) {
+      const textNode = parseTextPayload(trimmed, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (textNode && textNode.parts.length > 0) {
+        addChildToParent(parent, textNode);
+        if (parent === root) {
+          sawTopLevelTemplateNode = true;
+        }
+      }
+      continue;
+    }
+    addChildToParent(parent, element);
+    if (parent === root) {
+      sawTopLevelTemplateNode = true;
+    }
+    stack.push({ node: element, level });
+  }
+  if (root.classAliases) {
+    validateClassAliasDefinitions(root.classAliases, diagnostics);
+  }
+  validateClassAliasUsages(root, diagnostics);
+  for (const info of branchLocations) {
+    if (info.branch.body.length === 0) {
+      pushDiag(
+        diagnostics,
+        "COLLIE208",
+        "Conditional branches must include an inline body or indented block.",
+        info.line,
+        info.column,
+        info.lineOffset,
+        info.length || 3
+      );
+    }
+  }
+  return { root, diagnostics };
+}
+function cleanupConditionalChains(state, level) {
+  for (const key of Array.from(state.keys())) {
+    if (key > level) {
+      state.delete(key);
+    }
+  }
+}
+function addChildToParent(parent, child) {
+  if (isForParent(parent)) {
+    parent.body.push(child);
+  } else {
+    parent.children.push(child);
+  }
+}
+function isForParent(parent) {
+  return "type" in parent && parent.type === "For";
+}
+function isComponentNode(parent) {
+  return "type" in parent && parent.type === "Component";
+}
+function parseConditionalHeader(kind, lineContent, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = lineContent.trimEnd();
+  const pattern = kind === "if" ? /^@if\s*\((.*)\)(.*)$/ : /^@elseIf\s*\((.*)\)(.*)$/;
+  const match = trimmed.match(pattern);
+  if (!match) {
+    pushDiag(
+      diagnostics,
+      "COLLIE201",
+      kind === "if" ? "Invalid @if syntax. Use @if (condition)." : "Invalid @elseIf syntax. Use @elseIf (condition).",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || 3
+    );
+    return null;
+  }
+  const test = match[1].trim();
+  if (!test) {
+    pushDiag(
+      diagnostics,
+      "COLLIE201",
+      kind === "if" ? "@if condition cannot be empty." : "@elseIf condition cannot be empty.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || 3
+    );
+    return null;
+  }
+  const remainderRaw = match[2] ?? "";
+  const inlineBody = remainderRaw.trim();
+  const remainderOffset = trimmed.length - remainderRaw.length;
+  const leadingWhitespace = remainderRaw.length - inlineBody.length;
+  const inlineColumn = inlineBody.length > 0 ? column + remainderOffset + leadingWhitespace : void 0;
+  return {
+    test,
+    inlineBody: inlineBody.length ? inlineBody : void 0,
+    inlineColumn,
+    directiveLength: trimmed.length || 3
+  };
+}
+function parseElseHeader(lineContent, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = lineContent.trimEnd();
+  const match = trimmed.match(/^@else\b(.*)$/);
+  if (!match) {
+    pushDiag(
+      diagnostics,
+      "COLLIE203",
+      "Invalid @else syntax.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || 4
+    );
+    return null;
+  }
+  const remainderRaw = match[1] ?? "";
+  const inlineBody = remainderRaw.trim();
+  const remainderOffset = trimmed.length - remainderRaw.length;
+  const leadingWhitespace = remainderRaw.length - inlineBody.length;
+  const inlineColumn = inlineBody.length > 0 ? column + remainderOffset + leadingWhitespace : void 0;
+  return {
+    inlineBody: inlineBody.length ? inlineBody : void 0,
+    inlineColumn,
+    directiveLength: trimmed.length || 4
+  };
+}
+function parseForHeader(lineContent, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = lineContent.trimEnd();
+  const match = trimmed.match(/^@for\s+([A-Za-z_][A-Za-z0-9_]*)\s+in\s+(.+)$/);
+  if (!match) {
+    pushDiag(
+      diagnostics,
+      "COLLIE210",
+      "Invalid @for syntax. Use @for itemName in arrayExpr.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || 4
+    );
+    return null;
+  }
+  const itemName = match[1];
+  const arrayExprRaw = match[2];
+  if (!itemName || !arrayExprRaw) {
+    pushDiag(
+      diagnostics,
+      "COLLIE210",
+      "Invalid @for syntax. Use @for itemName in arrayExpr.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || 4
+    );
+    return null;
+  }
+  const arrayExpr = arrayExprRaw.trim();
+  if (!arrayExpr) {
+    pushDiag(
+      diagnostics,
+      "COLLIE210",
+      "@for array expression cannot be empty.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || 4
+    );
+    return null;
+  }
+  return { itemName, arrayExpr };
+}
+function parseInlineNode(source, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("|")) {
+    return parseTextLine(trimmed, lineNumber, column, lineOffset, diagnostics);
+  }
+  if (trimmed.startsWith("{{")) {
+    return parseExpressionLine(trimmed, lineNumber, column, lineOffset, diagnostics);
+  }
+  if (trimmed.startsWith("@")) {
+    pushDiag(
+      diagnostics,
+      "COLLIE209",
+      "Inline conditional bodies may only contain elements, text, or expressions.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length
+    );
+    return null;
+  }
+  return parseElement(trimmed, lineNumber, column, lineOffset, diagnostics);
+}
+function createConditionalBranchContext(owner, branch) {
+  return {
+    kind: "ConditionalBranch",
+    owner,
+    branch,
+    children: branch.body
+  };
+}
+function createSlotContext(owner, slot) {
+  return {
+    kind: "Slot",
+    owner,
+    slot,
+    children: slot.children
+  };
+}
+function createStandaloneSlotContext(name) {
+  const owner = {
+    type: "Component",
+    name: "__invalid_slot__",
+    attributes: [],
+    children: []
+  };
+  const slot = { type: "Slot", name, children: [] };
+  return createSlotContext(owner, slot);
+}
+function parseTextLine(lineContent, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = lineContent.trimEnd();
+  let payload = trimmed;
+  let payloadColumn = column;
+  if (payload.startsWith("|")) {
+    payload = payload.slice(1);
+    payloadColumn += 1;
+    if (payload.startsWith(" ")) {
+      payload = payload.slice(1);
+      payloadColumn += 1;
+    }
+  }
+  return parseTextPayload(payload, lineNumber, payloadColumn, lineOffset, diagnostics);
+}
+function parseTextPayload(payload, lineNumber, payloadColumn, lineOffset, diagnostics) {
+  const parts = [];
+  let cursor = 0;
+  let textBuffer = "";
+  const flushText = () => {
+    if (textBuffer.length) {
+      parts.push({ type: "text", value: textBuffer });
+      textBuffer = "";
+    }
+  };
+  while (cursor < payload.length) {
+    const ch = payload[cursor];
+    if (ch === "{") {
+      flushText();
+      if (payload[cursor + 1] === "{") {
+        const exprStart2 = cursor;
+        const exprEnd2 = payload.indexOf("}}", cursor + 2);
+        if (exprEnd2 === -1) {
+          pushDiag(
+            diagnostics,
+            "COLLIE005",
+            "Inline expression must end with }}.",
+            lineNumber,
+            payloadColumn + exprStart2,
+            lineOffset
+          );
+          textBuffer += payload.slice(exprStart2);
+          break;
+        }
+        const inner2 = payload.slice(exprStart2 + 2, exprEnd2).trim();
+        if (!inner2) {
+          pushDiag(
+            diagnostics,
+            "COLLIE005",
+            "Inline expression cannot be empty.",
+            lineNumber,
+            payloadColumn + exprStart2,
+            lineOffset,
+            exprEnd2 - exprStart2
+          );
+        } else {
+          parts.push({ type: "expr", value: inner2 });
+        }
+        cursor = exprEnd2 + 2;
+        continue;
+      }
+      const exprStart = cursor;
+      const exprEnd = payload.indexOf("}", cursor + 1);
+      if (exprEnd === -1) {
+        pushDiag(
+          diagnostics,
+          "COLLIE005",
+          "Inline expression must end with }.",
+          lineNumber,
+          payloadColumn + exprStart,
+          lineOffset
+        );
+        textBuffer += payload.slice(exprStart);
+        break;
+      }
+      const inner = payload.slice(exprStart + 1, exprEnd).trim();
+      if (!inner) {
+        pushDiag(
+          diagnostics,
+          "COLLIE005",
+          "Inline expression cannot be empty.",
+          lineNumber,
+          payloadColumn + exprStart,
+          lineOffset,
+          exprEnd - exprStart
+        );
+      } else {
+        parts.push({ type: "expr", value: inner });
+      }
+      cursor = exprEnd + 1;
+      continue;
+    }
+    if (ch === "}") {
+      flushText();
+      if (payload[cursor + 1] === "}") {
+        pushDiag(
+          diagnostics,
+          "COLLIE005",
+          "Inline expression closing }} must follow an opening {{.",
+          lineNumber,
+          payloadColumn + cursor,
+          lineOffset,
+          2
+        );
+        cursor += 2;
+        continue;
+      }
+      pushDiag(
+        diagnostics,
+        "COLLIE005",
+        "Inline expression closing } must follow an opening {.",
+        lineNumber,
+        payloadColumn + cursor,
+        lineOffset
+      );
+      cursor += 1;
+      continue;
+    }
+    textBuffer += ch;
+    cursor += 1;
+  }
+  flushText();
+  return { type: "Text", parts };
+}
+function parseExpressionLine(line, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = line.trimEnd();
+  const closeIndex = trimmed.indexOf("}}");
+  if (closeIndex === -1) {
+    pushDiag(
+      diagnostics,
+      "COLLIE005",
+      "Expression lines must end with }}.",
+      lineNumber,
+      column,
+      lineOffset
+    );
+    return null;
+  }
+  if (trimmed.slice(closeIndex + 2).trim().length) {
+    pushDiag(
+      diagnostics,
+      "COLLIE005",
+      "Expression lines cannot contain text after the closing }}.",
+      lineNumber,
+      column + closeIndex + 2,
+      lineOffset
+    );
+    return null;
+  }
+  const inner = trimmed.slice(2, closeIndex).trim();
+  if (!inner) {
+    pushDiag(
+      diagnostics,
+      "COLLIE005",
+      "Expression cannot be empty.",
+      lineNumber,
+      column,
+      lineOffset,
+      closeIndex + 2
+    );
+    return null;
+  }
+  return { type: "Expression", value: inner };
+}
+function parseJSXPassthrough(line, lineNumber, column, lineOffset, diagnostics) {
+  if (!line.startsWith("=")) {
+    return null;
+  }
+  const payload = line.slice(1).trim();
+  if (!payload) {
+    pushDiag(
+      diagnostics,
+      "COLLIE005",
+      "JSX passthrough expression cannot be empty.",
+      lineNumber,
+      column,
+      lineOffset
+    );
+    return null;
+  }
+  return { type: "JSXPassthrough", expression: payload };
+}
+function parsePropsField(line, lineNumber, column, lineOffset, diagnostics) {
+  const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)(\??)\s*:\s*(.+)$/);
+  if (!match) {
+    pushDiag(
+      diagnostics,
+      "COLLIE102",
+      "Props lines must be in the form `name[:?] Type`.",
+      lineNumber,
+      column,
+      lineOffset,
+      Math.max(line.length, 1)
+    );
+    return null;
+  }
+  const [, name, optionalFlag, typePart] = match;
+  const typeText = typePart.trim();
+  if (!typeText) {
+    pushDiag(
+      diagnostics,
+      "COLLIE102",
+      "Props lines must provide a type after the colon.",
+      lineNumber,
+      column,
+      lineOffset,
+      Math.max(line.length, 1)
+    );
+    return null;
+  }
+  return {
+    name,
+    optional: optionalFlag === "?",
+    typeText
+  };
+}
+function parseClassAliasLine(line, lineNumber, column, lineOffset, diagnostics) {
+  const match = line.match(/^([^=]+?)\s*=\s*(.+)$/);
+  if (!match) {
+    pushDiag(
+      diagnostics,
+      "COLLIE304",
+      "Classes lines must be in the form `name = class.tokens`.",
+      lineNumber,
+      column,
+      lineOffset,
+      Math.max(line.length, 1)
+    );
+    return null;
+  }
+  const rawName = match[1].trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(rawName)) {
+    pushDiag(
+      diagnostics,
+      "COLLIE305",
+      `Class alias name '${rawName}' must be a valid identifier.`,
+      lineNumber,
+      column,
+      lineOffset,
+      Math.max(rawName.length, 1)
+    );
+    return null;
+  }
+  const rhs = match[2];
+  const rhsIndex = line.indexOf(rhs);
+  const rhsColumn = rhsIndex >= 0 ? column + rhsIndex : column;
+  const classes = parseAliasClasses(rhs, lineNumber, rhsColumn, lineOffset, diagnostics);
+  if (!classes.length) {
+    return null;
+  }
+  const nameIndex = line.indexOf(rawName);
+  const nameColumn = nameIndex >= 0 ? column + nameIndex : column;
+  const span = createSpan(lineNumber, nameColumn, rawName.length, lineOffset);
+  return { name: rawName, classes, span };
+}
+function parseAliasClasses(rhs, lineNumber, column, lineOffset, diagnostics) {
+  const trimmed = rhs.trim();
+  if (!trimmed) {
+    pushDiag(
+      diagnostics,
+      "COLLIE304",
+      "Classes lines must provide one or more class tokens after '='.",
+      lineNumber,
+      column,
+      lineOffset,
+      Math.max(rhs.length, 1)
+    );
+    return [];
+  }
+  const withoutDotPrefix = trimmed.startsWith(".") ? trimmed.slice(1) : trimmed;
+  const parts = withoutDotPrefix.split(".");
+  const classes = [];
+  for (const part of parts) {
+    const token = part.trim();
+    if (!token) {
+      pushDiag(
+        diagnostics,
+        "COLLIE304",
+        "Classes lines must provide one or more class tokens after '='.",
+        lineNumber,
+        column,
+        lineOffset,
+        Math.max(rhs.length, 1)
+      );
+      return [];
+    }
+    classes.push(token);
+  }
+  return classes;
+}
+function validateClassAliasDefinitions(classAliases, diagnostics) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const alias of classAliases.aliases) {
+    const previous = seen.get(alias.name);
+    if (previous) {
+      if (alias.span) {
+        diagnostics.push({
+          severity: "error",
+          code: "COLLIE306",
+          message: `Duplicate class alias '${alias.name}'.`,
+          span: alias.span
+        });
+      } else {
+        pushDiag(diagnostics, "COLLIE306", `Duplicate class alias '${alias.name}'.`, 1, 1, 0);
+      }
+      continue;
+    }
+    seen.set(alias.name, alias);
+  }
+}
+function validateClassAliasUsages(root, diagnostics) {
+  const defined = new Set(root.classAliases?.aliases.map((alias) => alias.name) ?? []);
+  for (const child of root.children) {
+    validateNodeClassAliases(child, defined, diagnostics);
+  }
+}
+function validateNodeClassAliases(node, defined, diagnostics) {
+  if (node.type === "Element" || node.type === "Component") {
+    const spans = node.type === "Element" ? node.classSpans ?? [] : [];
+    const classes = node.type === "Element" ? node.classes : [];
+    classes.forEach((cls, index) => {
+      const match = cls.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
+      if (!match) {
+        return;
+      }
+      const aliasName = match[1];
+      if (defined.has(aliasName)) {
+        return;
+      }
+      const span = spans[index];
+      if (span) {
+        diagnostics.push({
+          severity: "error",
+          code: "COLLIE307",
+          message: `Undefined class alias '${aliasName}'.`,
+          span
+        });
+      } else {
+        pushDiag(diagnostics, "COLLIE307", `Undefined class alias '${aliasName}'.`, 1, 1, 0);
+      }
+    });
+    for (const child of node.children) {
+      validateNodeClassAliases(child, defined, diagnostics);
+    }
+    if (node.type === "Component" && node.slots) {
+      for (const slot of node.slots) {
+        for (const child of slot.children) {
+          validateNodeClassAliases(child, defined, diagnostics);
+        }
+      }
+    }
+    return;
+  }
+  if (node.type === "Conditional") {
+    for (const branch of node.branches) {
+      for (const child of branch.body) {
+        validateNodeClassAliases(child, defined, diagnostics);
+      }
+    }
+  }
+  if (node.type === "For") {
+    for (const child of node.body) {
+      validateNodeClassAliases(child, defined, diagnostics);
+    }
+  }
+}
+function parseElement(line, lineNumber, column, lineOffset, diagnostics) {
+  const nameMatch = line.match(/^([A-Za-z][A-Za-z0-9_]*)/);
+  if (!nameMatch) {
+    return null;
+  }
+  const name = nameMatch[1];
+  let cursor = name.length;
+  const nextPart = line.slice(cursor);
+  const isComponent = /^[A-Z]/.test(name);
+  if (isComponent && nextPart.length > 0) {
+    const trimmedNext = nextPart.trimStart();
+    if (trimmedNext.length > 0 && !trimmedNext.startsWith("(")) {
+      return null;
+    }
+  }
+  if (cursor < line.length) {
+    const nextChar = line[cursor];
+    if (nextChar !== "." && nextChar !== "(" && !/\s/.test(nextChar)) {
+      return null;
+    }
+  }
+  const classes = [];
+  const classSpans = [];
+  if (!isComponent) {
+    while (cursor < line.length && line[cursor] === ".") {
+      cursor++;
+      const classMatch = line.slice(cursor).match(/^([A-Za-z0-9_$-]+)/);
+      if (!classMatch) {
+        pushDiag(
+          diagnostics,
+          "COLLIE004",
+          "Class names must contain only letters, numbers, underscores, hyphens, or `$` (for aliases).",
+          lineNumber,
+          column + cursor,
+          lineOffset
+        );
+        return null;
+      }
+      const className = classMatch[1];
+      classes.push(className);
+      classSpans.push(createSpan(lineNumber, column + cursor, className.length, lineOffset));
+      cursor += className.length;
+    }
+  }
+  const attributes = [];
+  if (cursor < line.length && line[cursor] === "(") {
+    const attrResult = parseAttributes(line, cursor, lineNumber, column, lineOffset, diagnostics);
+    if (!attrResult) {
+      return null;
+    }
+    attributes.push(...attrResult.attributes);
+    cursor = attrResult.endIndex;
+  }
+  let guard;
+  const guardProbeStart = cursor;
+  while (cursor < line.length && /\s/.test(line[cursor])) {
+    cursor++;
+  }
+  if (cursor < line.length && line[cursor] === "?") {
+    const guardColumn = column + cursor;
+    cursor++;
+    const guardExpr = line.slice(cursor).trim();
+    if (!guardExpr) {
+      pushDiag(
+        diagnostics,
+        "COLLIE601",
+        "Guard expressions require a condition after '?'.",
+        lineNumber,
+        guardColumn,
+        lineOffset
+      );
+    } else {
+      guard = guardExpr;
+    }
+    cursor = line.length;
+  } else {
+    cursor = guardProbeStart;
+  }
+  let rest = line.slice(cursor).trimStart();
+  const children = [];
+  if (rest.length > 0) {
+    const textNode = parseTextPayload(rest, lineNumber, column + cursor + (line.slice(cursor).length - rest.length), lineOffset, diagnostics);
+    if (textNode) {
+      children.push(textNode);
+    }
+  }
+  if (isComponent) {
+    const component = {
+      type: "Component",
+      name,
+      attributes,
+      children
+    };
+    if (guard) {
+      component.guard = guard;
+    }
+    return component;
+  } else {
+    const element = {
+      type: "Element",
+      name,
+      classes,
+      attributes,
+      children
+    };
+    if (classSpans.length) {
+      element.classSpans = classSpans;
+    }
+    if (guard) {
+      element.guard = guard;
+    }
+    return element;
+  }
+}
+function parseAttributes(line, startIndex, lineNumber, column, lineOffset, diagnostics) {
+  if (line[startIndex] !== "(") {
+    return null;
+  }
+  const attributes = [];
+  let cursor = startIndex + 1;
+  let depth = 1;
+  let attrBuffer = "";
+  while (cursor < line.length && depth > 0) {
+    const ch = line[cursor];
+    if (ch === "(") {
+      depth++;
+      attrBuffer += ch;
+    } else if (ch === ")") {
+      depth--;
+      if (depth > 0) {
+        attrBuffer += ch;
+      }
+    } else {
+      attrBuffer += ch;
+    }
+    cursor++;
+  }
+  if (depth !== 0) {
+    pushDiag(
+      diagnostics,
+      "COLLIE004",
+      "Unclosed attribute parentheses.",
+      lineNumber,
+      column + startIndex,
+      lineOffset
+    );
+    return null;
+  }
+  const trimmedAttrs = attrBuffer.trim();
+  if (trimmedAttrs.length === 0) {
+    return { attributes: [], endIndex: cursor };
+  }
+  const attrLines = trimmedAttrs.split("\n");
+  let currentAttr = "";
+  for (const attrLine of attrLines) {
+    const trimmedLine = attrLine.trim();
+    if (trimmedLine.length === 0) continue;
+    const eqIndex = trimmedLine.indexOf("=");
+    if (eqIndex > 0 && /^[A-Za-z][A-Za-z0-9_-]*\s*=/.test(trimmedLine)) {
+      if (currentAttr) {
+        parseAndAddAttribute(currentAttr, attributes, diagnostics, lineNumber, column, lineOffset);
+        currentAttr = "";
+      }
+      currentAttr = trimmedLine;
+    } else {
+      if (currentAttr) {
+        currentAttr += " " + trimmedLine;
+      } else {
+        currentAttr = trimmedLine;
+      }
+    }
+  }
+  if (currentAttr) {
+    parseAndAddAttribute(currentAttr, attributes, diagnostics, lineNumber, column, lineOffset);
+  }
+  return { attributes, endIndex: cursor };
+}
+function parseAndAddAttribute(attrStr, attributes, diagnostics, lineNumber, column, lineOffset) {
+  const trimmed = attrStr.trim();
+  const match = trimmed.match(/^([A-Za-z][A-Za-z0-9_-]*)\s*=\s*(.+)$/s);
+  if (match) {
+    const attrName = match[1];
+    const attrValue = match[2].trim();
+    attributes.push({ name: attrName, value: attrValue });
+  } else {
+    const nameMatch = trimmed.match(/^([A-Za-z][A-Za-z0-9_-]*)$/);
+    if (nameMatch) {
+      attributes.push({ name: nameMatch[1], value: null });
+    } else {
+      pushDiag(
+        diagnostics,
+        "COLLIE004",
+        `Invalid attribute syntax: ${trimmed.slice(0, 30)}`,
+        lineNumber,
+        column,
+        lineOffset
+      );
+    }
+  }
+}
+function pushDiag(diagnostics, code, message, line, column, lineOffset, length = 1) {
+  diagnostics.push({
+    severity: "error",
+    code,
+    message,
+    span: createSpan(line, column, Math.max(length, 1), lineOffset)
+  });
+}
+
+// src/index.ts
+function parseCollie(source, options = {}) {
+  const result = parse(source);
+  if (!options.filename) {
+    return result;
+  }
+  return { root: result.root, diagnostics: attachFilename(result.diagnostics, options.filename) };
+}
+function compileToJsx(sourceOrAst, options = {}) {
+  const document = normalizeDocument(sourceOrAst, options.filename);
+  const diagnostics = options.filename ? attachFilename(document.diagnostics, options.filename) : document.diagnostics;
+  const componentName = options.componentNameHint ?? "CollieTemplate";
+  const jsxRuntime = options.jsxRuntime ?? "automatic";
+  let code = createStubComponent(componentName, "jsx");
+  if (!hasErrors(diagnostics)) {
+    code = generateModule(document.root, { componentName, jsxRuntime, flavor: "jsx" });
+  }
+  return { code, diagnostics, map: void 0 };
+}
+function compileToTsx(sourceOrAst, options = {}) {
+  const document = normalizeDocument(sourceOrAst, options.filename);
+  const diagnostics = options.filename ? attachFilename(document.diagnostics, options.filename) : document.diagnostics;
+  const componentName = options.componentNameHint ?? "CollieTemplate";
+  const jsxRuntime = options.jsxRuntime ?? "automatic";
+  let code = createStubComponent(componentName, "tsx");
+  if (!hasErrors(diagnostics)) {
+    code = generateModule(document.root, { componentName, jsxRuntime, flavor: "tsx" });
+  }
+  return { code, diagnostics, map: void 0 };
+}
+function compileToHtml(sourceOrAst, options = {}) {
+  const document = normalizeDocument(sourceOrAst, options.filename);
+  const diagnostics = options.filename ? attachFilename(document.diagnostics, options.filename) : document.diagnostics;
+  const componentName = options.componentNameHint ?? "CollieTemplate";
+  let code = createStubHtml(componentName);
+  if (!hasErrors(diagnostics)) {
+    code = generateHtmlModule(document.root, { componentName });
+  }
+  return { code, diagnostics, map: void 0 };
+}
+function compile(source, options = {}) {
+  return compileToJsx(source, options);
+}
+function normalizeDocument(sourceOrAst, filename) {
+  if (typeof sourceOrAst === "string") {
+    return parseCollie(sourceOrAst, { filename });
+  }
+  if (isCollieDocument(sourceOrAst)) {
+    if (!filename) {
+      return sourceOrAst;
+    }
+    return { root: sourceOrAst.root, diagnostics: attachFilename(sourceOrAst.diagnostics, filename) };
+  }
+  if (isRootNode(sourceOrAst)) {
+    return { root: sourceOrAst, diagnostics: [] };
+  }
+  throw new TypeError("Collie compiler expected source text, a parsed document, or a root node.");
+}
+function isRootNode(value) {
+  return !!value && typeof value === "object" && value.type === "Root";
+}
+function isCollieDocument(value) {
+  return !!value && typeof value === "object" && isRootNode(value.root) && Array.isArray(value.diagnostics);
+}
+function hasErrors(diagnostics) {
+  return diagnostics.some((diag) => diag.severity === "error");
+}
+function createStubComponent(name, flavor) {
+  if (flavor === "tsx") {
+    return [
+      "export type Props = Record<string, never>;",
+      `export default function ${name}(props: Props) {`,
+      "  return null;",
+      "}"
+    ].join("\n");
+  }
+  return [`export default function ${name}(props) {`, "  return null;", "}"].join("\n");
+}
+function createStubHtml(name) {
+  return [`export default function ${name}(props = {}) {`, '  return "";', "}"].join("\n");
+}
+function attachFilename(diagnostics, filename) {
+  if (!filename) {
+    return diagnostics;
+  }
+  return diagnostics.map((diag) => diag.file ? diag : { ...diag, file: filename });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile,
+  compileToHtml,
+  compileToJsx,
+  compileToTsx,
+  parse,
+  parseCollie
+});
+//# sourceMappingURL=index.cjs.map