@collie-lang/compiler 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,40 +17,47 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  applyFixes: () => applyFixes,
   compile: () => compile,
+  compileTemplate: () => compileTemplate,
   compileToHtml: () => compileToHtml,
   compileToJsx: () => compileToJsx,
   compileToTsx: () => compileToTsx,
+  convertCollieToTsx: () => convertCollieToTsx,
+  convertTsxToCollie: () => convertTsxToCollie,
+  defineConfig: () => import_config.defineConfig,
+  fixAllFromDiagnostics: () => fixAllFromDiagnostics,
+  formatCollie: () => formatCollie,
+  loadAndNormalizeConfig: () => import_config.loadAndNormalizeConfig,
+  loadConfig: () => import_config.loadConfig,
+  normalizeConfig: () => import_config.normalizeConfig,
   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));
+function generateRenderModule(root, options) {
+  const { prelude, propsType, propsDestructure, jsx, isTsx } = buildModuleParts(root, options);
+  const parts = [...prelude, propsType];
   if (!isTsx) {
-    parts.push(`/** @param {Props} props */`);
+    parts.push(`/** @param {any} props */`);
   }
   const functionLines = [
-    isTsx ? `export default function ${componentName}(props: Props) {` : `export default function ${componentName}(props) {`
+    isTsx ? "export function render(props: any) {" : "export function render(props) {"
   ];
   if (propsDestructure) {
     functionLines.push(`  ${propsDestructure}`);
@@ -57,6 +66,22 @@ function generateModule(root, options) {
   parts.push(functionLines.join("\n"));
   return parts.join("\n\n");
 }
+function buildModuleParts(root, options) {
+  const { jsxRuntime, flavor } = options;
+  const isTsx = flavor === "tsx";
+  const aliasEnv = buildClassAliasEnvironment(root.classAliases);
+  const jsx = renderRootChildren(root.children, aliasEnv);
+  const propsDestructure = emitPropsDestructure(root.props);
+  const prelude = [];
+  if (root.clientComponent) {
+    prelude.push(`"use client";`);
+  }
+  if (jsxRuntime === "classic" && templateUsesJsx(root)) {
+    prelude.push(`import React from "react";`);
+  }
+  const propsType = emitPropsType(root.props, flavor);
+  return { prelude, propsType, propsDestructure, jsx, isTsx };
+}
 function buildClassAliasEnvironment(decl) {
   const env = /* @__PURE__ */ new Map();
   if (!decl) {
@@ -68,7 +93,7 @@ function buildClassAliasEnvironment(decl) {
   return env;
 }
 function renderRootChildren(children, aliasEnv) {
-  return emitNodesExpression(children, aliasEnv);
+  return emitNodesExpression(children, aliasEnv, /* @__PURE__ */ new Set());
 }
 function templateUsesJsx(root) {
   if (root.children.length === 0) {
@@ -100,58 +125,58 @@ function branchUsesJsx(branch) {
   }
   return branch.body.some((child) => nodeUsesJsx(child));
 }
-function emitNodeInJsx(node, aliasEnv) {
+function emitNodeInJsx(node, aliasEnv, locals) {
   if (node.type === "Text") {
-    return emitText(node);
+    return emitText(node, locals);
   }
   if (node.type === "Expression") {
-    return `{${node.value}}`;
+    return `{${emitExpressionValue(node.value, locals)}}`;
   }
   if (node.type === "JSXPassthrough") {
-    return `{${node.expression}}`;
+    return `{${emitJsxExpression(node.expression, locals)}}`;
   }
   if (node.type === "Conditional") {
-    return `{${emitConditionalExpression(node, aliasEnv)}}`;
+    return `{${emitConditionalExpression(node, aliasEnv, locals)}}`;
   }
   if (node.type === "For") {
-    return `{${emitForExpression(node, aliasEnv)}}`;
+    return `{${emitForExpression(node, aliasEnv, locals)}}`;
   }
   if (node.type === "Component") {
-    return wrapWithGuard(emitComponent(node, aliasEnv), node.guard, "jsx");
+    return wrapWithGuard(emitComponent(node, aliasEnv, locals), node.guard, "jsx", locals);
   }
-  return wrapWithGuard(emitElement(node, aliasEnv), node.guard, "jsx");
+  return wrapWithGuard(emitElement(node, aliasEnv, locals), node.guard, "jsx", locals);
 }
-function emitElement(node, aliasEnv) {
+function emitElement(node, aliasEnv, locals) {
   const expanded = expandClasses(node.classes, aliasEnv);
   const classAttr = expanded.length ? ` className="${expanded.join(" ")}"` : "";
-  const attrs = emitAttributes(node.attributes, aliasEnv);
+  const attrs = emitAttributes(node.attributes, aliasEnv, locals);
   const allAttrs = classAttr + attrs;
-  const children = emitChildrenWithSpacing(node.children, aliasEnv);
+  const children = emitChildrenWithSpacing(node.children, aliasEnv, locals);
   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);
+function emitComponent(node, aliasEnv, locals) {
+  const attrs = emitAttributes(node.attributes, aliasEnv, locals);
+  const slotProps = emitSlotProps(node, aliasEnv, locals);
   const allAttrs = `${attrs}${slotProps}`;
-  const children = emitChildrenWithSpacing(node.children, aliasEnv);
+  const children = emitChildrenWithSpacing(node.children, aliasEnv, locals);
   if (children.length > 0) {
     return `<${node.name}${allAttrs}>${children}</${node.name}>`;
   } else {
     return `<${node.name}${allAttrs} />`;
   }
 }
-function emitChildrenWithSpacing(children, aliasEnv) {
+function emitChildrenWithSpacing(children, aliasEnv, locals) {
   if (children.length === 0) {
     return "";
   }
   const parts = [];
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
-    const emitted = emitNodeInJsx(child, aliasEnv);
+    const emitted = emitNodeInJsx(child, aliasEnv, locals);
     parts.push(emitted);
     if (i < children.length - 1) {
       const nextChild = children[i + 1];
@@ -163,7 +188,7 @@ function emitChildrenWithSpacing(children, aliasEnv) {
   }
   return parts.join("");
 }
-function emitAttributes(attributes, aliasEnv) {
+function emitAttributes(attributes, aliasEnv, locals) {
   if (attributes.length === 0) {
     return "";
   }
@@ -171,28 +196,32 @@ function emitAttributes(attributes, aliasEnv) {
     if (attr.value === null) {
       return ` ${attr.name}`;
     }
-    return ` ${attr.name}=${attr.value}`;
+    return ` ${attr.name}=${emitAttributeValue(attr.value, locals)}`;
   }).join("");
 }
-function emitSlotProps(node, aliasEnv) {
+function emitSlotProps(node, aliasEnv, locals) {
   if (!node.slots || node.slots.length === 0) {
     return "";
   }
   return node.slots.map((slot) => {
-    const expr = emitNodesExpression(slot.children, aliasEnv);
+    const expr = emitNodesExpression(slot.children, aliasEnv, locals);
     return ` ${slot.name}={${expr}}`;
   }).join("");
 }
-function wrapWithGuard(rendered, guard, context) {
+function wrapWithGuard(rendered, guard, context, locals) {
   if (!guard) {
     return rendered;
   }
-  const expression = `(${guard}) && ${rendered}`;
+  const condition = emitExpressionValue(guard, locals);
+  const expression = `(${condition}) && ${rendered}`;
   return context === "jsx" ? `{${expression}}` : expression;
 }
-function emitForExpression(node, aliasEnv) {
-  const body = emitNodesExpression(node.body, aliasEnv);
-  return `${node.arrayExpr}.map((${node.itemName}) => ${body})`;
+function emitForExpression(node, aliasEnv, locals) {
+  const arrayExpr = emitExpressionValue(node.arrayExpr, locals);
+  const nextLocals = new Set(locals);
+  nextLocals.add(node.itemName);
+  const body = emitNodesExpression(node.body, aliasEnv, nextLocals);
+  return `(${arrayExpr} ?? []).map((${node.itemName}) => ${body})`;
 }
 function expandClasses(classes, aliasEnv) {
   const result = [];
@@ -210,7 +239,29 @@ function expandClasses(classes, aliasEnv) {
   }
   return result;
 }
-function emitText(node) {
+function emitExpressionValue(expression, locals) {
+  return rewriteExpression(expression, locals);
+}
+function emitJsxExpression(expression, locals) {
+  const trimmed = expression.trimStart();
+  if (trimmed.startsWith("<")) {
+    return rewriteJsxExpression(expression, locals);
+  }
+  return rewriteExpression(expression, locals);
+}
+function emitAttributeValue(value, locals) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+    return value;
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    const inner = trimmed.slice(1, -1);
+    const rewritten = rewriteExpression(inner, locals);
+    return `{${rewritten}}`;
+  }
+  return rewriteExpression(trimmed, locals);
+}
+function emitText(node, locals) {
   if (!node.parts.length) {
     return "";
   }
@@ -218,65 +269,66 @@ function emitText(node) {
     if (part.type === "text") {
       return escapeText(part.value);
     }
-    return `{${part.value}}`;
+    return `{${emitExpressionValue(part.value, locals)}}`;
   }).join("");
 }
-function emitConditionalExpression(node, aliasEnv) {
+function emitConditionalExpression(node, aliasEnv, locals) {
   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 test = emitExpressionValue(first.test, locals);
+    return `(${test}) && ${emitBranchExpression(first, aliasEnv, locals)}`;
   }
   const hasElse = node.branches[node.branches.length - 1].test === void 0;
-  let fallback = hasElse ? emitBranchExpression(node.branches[node.branches.length - 1], aliasEnv) : "null";
+  let fallback = hasElse ? emitBranchExpression(node.branches[node.branches.length - 1], aliasEnv, locals) : "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}`;
+    const test = branch.test ? emitExpressionValue(branch.test, locals) : "false";
+    fallback = `(${test}) ? ${emitBranchExpression(branch, aliasEnv, locals)} : ${fallback}`;
   }
   return fallback;
 }
-function emitBranchExpression(branch, aliasEnv) {
-  return emitNodesExpression(branch.body, aliasEnv);
+function emitBranchExpression(branch, aliasEnv, locals) {
+  return emitNodesExpression(branch.body, aliasEnv, locals);
 }
-function emitNodesExpression(children, aliasEnv) {
+function emitNodesExpression(children, aliasEnv, locals) {
   if (children.length === 0) {
     return "null";
   }
   if (children.length === 1) {
-    return emitSingleNodeExpression(children[0], aliasEnv);
+    return emitSingleNodeExpression(children[0], aliasEnv, locals);
   }
-  return `<>${children.map((child) => emitNodeInJsx(child, aliasEnv)).join("")}</>`;
+  return `<>${children.map((child) => emitNodeInJsx(child, aliasEnv, locals)).join("")}</>`;
 }
-function emitSingleNodeExpression(node, aliasEnv) {
+function emitSingleNodeExpression(node, aliasEnv, locals) {
   if (node.type === "Expression") {
-    return node.value;
+    return emitExpressionValue(node.value, locals);
   }
   if (node.type === "JSXPassthrough") {
-    return node.expression;
+    return emitJsxExpression(node.expression, locals);
   }
   if (node.type === "Conditional") {
-    return emitConditionalExpression(node, aliasEnv);
+    return emitConditionalExpression(node, aliasEnv, locals);
   }
   if (node.type === "For") {
-    return emitForExpression(node, aliasEnv);
+    return emitForExpression(node, aliasEnv, locals);
   }
   if (node.type === "Element") {
-    return wrapWithGuard(emitElement(node, aliasEnv), node.guard, "expression");
+    return wrapWithGuard(emitElement(node, aliasEnv, locals), node.guard, "expression", locals);
   }
   if (node.type === "Component") {
-    return wrapWithGuard(emitComponent(node, aliasEnv), node.guard, "expression");
+    return wrapWithGuard(emitComponent(node, aliasEnv, locals), node.guard, "expression", locals);
   }
   if (node.type === "Text") {
-    return `<>${emitNodeInJsx(node, aliasEnv)}</>`;
+    return `<>${emitNodeInJsx(node, aliasEnv, locals)}</>`;
   }
-  return emitNodeInJsx(node, aliasEnv);
+  return emitNodeInJsx(node, aliasEnv, locals);
 }
 function emitPropsType(props, flavor) {
   if (flavor === "tsx") {
@@ -312,7 +364,7 @@ function emitPropsDestructure(props) {
     return null;
   }
   const names = props.fields.map((field) => field.name);
-  return `const { ${names.join(", ")} } = props;`;
+  return `const { ${names.join(", ")} } = props ?? {};`;
 }
 function escapeText(value) {
   return value.replace(/[&<>{}]/g, (char) => {
@@ -332,177 +384,463 @@ function escapeText(value) {
     }
   });
 }
-
-// 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");
+var IGNORED_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "null",
+  "undefined",
+  "true",
+  "false",
+  "NaN",
+  "Infinity",
+  "this",
+  "props"
+]);
+var RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+function emitIdentifier(name) {
+  return `props?.${name}`;
 }
-function emitNodesString(children, aliasEnv) {
-  if (children.length === 0) {
-    return '""';
+function rewriteExpression(expression, locals) {
+  let i = 0;
+  let state = "code";
+  let output = "";
+  while (i < expression.length) {
+    const ch = expression[i];
+    if (state === "code") {
+      if (ch === "'" || ch === '"') {
+        state = ch === "'" ? "single" : "double";
+        output += ch;
+        i++;
+        continue;
+      }
+      if (ch === "`") {
+        state = "template";
+        output += ch;
+        i++;
+        continue;
+      }
+      if (ch === "/" && expression[i + 1] === "/") {
+        state = "line";
+        output += ch;
+        i++;
+        continue;
+      }
+      if (ch === "/" && expression[i + 1] === "*") {
+        state = "block";
+        output += ch;
+        i++;
+        continue;
+      }
+      if (isIdentifierStart(ch)) {
+        const start = i;
+        i++;
+        while (i < expression.length && isIdentifierPart(expression[i])) {
+          i++;
+        }
+        const name = expression.slice(start, i);
+        const prevNonSpace = findPreviousNonSpace(expression, start - 1);
+        const nextNonSpace = findNextNonSpace(expression, i);
+        const isMemberAccess = prevNonSpace === ".";
+        const isObjectKey = nextNonSpace === ":";
+        if (isMemberAccess || isObjectKey || locals.has(name) || shouldIgnoreIdentifier(name)) {
+          output += name;
+          continue;
+        }
+        output += emitIdentifier(name);
+        continue;
+      }
+      output += ch;
+      i++;
+      continue;
+    }
+    if (state === "line") {
+      output += ch;
+      if (ch === "\n") {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
+    if (state === "block") {
+      output += ch;
+      if (ch === "*" && expression[i + 1] === "/") {
+        output += "/";
+        i += 2;
+        state = "code";
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (state === "single") {
+      output += ch;
+      if (ch === "\\") {
+        if (i + 1 < expression.length) {
+          output += expression[i + 1];
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "'") {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
+    if (state === "double") {
+      output += ch;
+      if (ch === "\\") {
+        if (i + 1 < expression.length) {
+          output += expression[i + 1];
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === '"') {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
+    if (state === "template") {
+      output += ch;
+      if (ch === "\\") {
+        if (i + 1 < expression.length) {
+          output += expression[i + 1];
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "`") {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
   }
-  const segments = children.map((child) => emitNodeString(child, aliasEnv)).filter(Boolean);
-  return concatSegments(segments);
+  return output;
 }
-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 rewriteJsxExpression(expression, locals) {
+  let output = "";
+  let i = 0;
+  while (i < expression.length) {
+    const ch = expression[i];
+    if (ch === "{") {
+      const braceResult = readBalancedBraces(expression, i + 1);
+      if (!braceResult) {
+        output += expression.slice(i);
+        break;
+      }
+      const rewritten = rewriteExpression(braceResult.content, locals);
+      output += `{${rewritten}}`;
+      i = braceResult.endIndex + 1;
+      continue;
+    }
+    output += ch;
+    i++;
   }
+  return output;
 }
-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;
+function readBalancedBraces(source, startIndex) {
+  let i = startIndex;
+  let depth = 1;
+  let state = "code";
+  while (i < source.length) {
+    const ch = source[i];
+    if (state === "code") {
+      if (ch === "'" || ch === '"') {
+        state = ch === "'" ? "single" : "double";
+        i++;
+        continue;
+      }
+      if (ch === "`") {
+        state = "template";
+        i++;
+        continue;
+      }
+      if (ch === "/" && source[i + 1] === "/") {
+        state = "line";
+        i += 2;
+        continue;
+      }
+      if (ch === "/" && source[i + 1] === "*") {
+        state = "block";
+        i += 2;
+        continue;
+      }
+      if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          return { content: source.slice(startIndex, i), endIndex: i };
+        }
+      }
+      i++;
+      continue;
+    }
+    if (state === "line") {
+      if (ch === "\n") {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
+    if (state === "block") {
+      if (ch === "*" && source[i + 1] === "/") {
+        i += 2;
+        state = "code";
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (state === "single") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
+    if (state === "double") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === '"') {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
+    if (state === "template") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        state = "code";
+      }
+      i++;
+      continue;
+    }
   }
-  const children = emitNodesString(node.children, aliasEnv);
-  const end = literal(`</${node.name}>`);
-  return concatSegments([start, children, end]);
+  return null;
 }
-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));
+function findPreviousNonSpace(text, index) {
+  for (let i = index; i >= 0; i--) {
+    const ch = text[i];
+    if (!/\s/.test(ch)) {
+      return ch;
+    }
   }
-  for (const slot of node.slots ?? []) {
-    childSegments.push(emitSlotTemplate(slot, aliasEnv));
+  return null;
+}
+function findNextNonSpace(text, index) {
+  for (let i = index; i < text.length; i++) {
+    const ch = text[i];
+    if (!/\s/.test(ch)) {
+      return ch;
+    }
   }
-  const children = concatSegments(childSegments);
-  const end = literal(`</${node.name}>`);
-  return concatSegments([start, children, end]);
+  return null;
 }
-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 isIdentifierStart(ch) {
+  return /[A-Za-z_$]/.test(ch);
 }
-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 isIdentifierPart(ch) {
+  return /[A-Za-z0-9_$]/.test(ch);
 }
-function emitBranch(branch, aliasEnv) {
-  return emitNodesString(branch.body, aliasEnv);
+function shouldIgnoreIdentifier(name) {
+  return IGNORED_IDENTIFIERS.has(name) || RESERVED_KEYWORDS.has(name);
 }
-function emitFor(node, aliasEnv) {
-  const body = emitNodesString(node.body, aliasEnv);
-  return `(${node.arrayExpr}).map((${node.itemName}) => ${body}).join("")`;
+
+// src/html-codegen.ts
+function generateHtml(root, options = {}) {
+  const indent = options.indent ?? "  ";
+  const aliasEnv = buildClassAliasEnvironment2(root.classAliases);
+  const rendered = emitNodes(root.children, aliasEnv, indent, 0);
+  return rendered.trimEnd();
 }
-function emitTextNode(node) {
-  if (!node.parts.length) {
-    return '""';
+function emitNodes(children, aliasEnv, indent, depth) {
+  let html = "";
+  for (const child of children) {
+    const chunk = emitNode(child, aliasEnv, indent, depth);
+    if (chunk) {
+      html += chunk;
+    }
   }
-  const segments = node.parts.map((part) => {
-    if (part.type === "text") {
-      return literal(escapeStaticText(part.value));
+  return html;
+}
+function emitNode(node, aliasEnv, indent, depth) {
+  switch (node.type) {
+    case "Element":
+      return emitElement2(node, aliasEnv, indent, depth);
+    case "Text":
+      return emitTextBlock(node, indent, depth);
+    default:
+      return "";
+  }
+}
+function emitElement2(node, aliasEnv, indent, depth) {
+  const indentText = indent.repeat(depth);
+  const classNames = expandClasses2(node.classes, aliasEnv);
+  const attrs = renderAttributes(node.attributes, classNames);
+  const openTag = `<${node.name}${attrs}>`;
+  if (node.children.length === 0) {
+    return `${indentText}${openTag}</${node.name}>
+`;
+  }
+  if (node.children.length === 1 && node.children[0].type === "Text") {
+    const inline = emitInlineText(node.children[0]);
+    if (inline !== null) {
+      return `${indentText}${openTag}${inline}</${node.name}>
+`;
     }
-    return `__collie_escapeHtml(${part.value})`;
-  });
-  return concatSegments(segments);
+  }
+  const children = emitNodes(node.children, aliasEnv, indent, depth + 1);
+  if (!children) {
+    return `${indentText}${openTag}</${node.name}>
+`;
+  }
+  return `${indentText}${openTag}
+${children}${indentText}</${node.name}>
+`;
 }
-function emitAttributeSegments(attributes, classNames) {
+function renderAttributes(attributes, classNames) {
   const segments = [];
   if (classNames.length) {
-    segments.push(literal(` class="${classNames.join(" ")}"`));
+    segments.push(`class="${escapeAttributeValue(classNames.join(" "))}"`);
   }
   for (const attr of attributes) {
     if (attr.value === null) {
-      segments.push(literal(` ${attr.name}`));
+      segments.push(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(" ")
-    );
+    const literal = extractStaticAttributeValue(attr.value);
+    if (literal === null) {
+      continue;
+    }
+    const name = attr.name === "className" ? "class" : attr.name;
+    segments.push(`${name}="${escapeAttributeValue(literal)}"`);
   }
-  return segments;
-}
-function attributeExpression(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-    return trimmed.slice(1, -1).trim();
+  if (!segments.length) {
+    return "";
   }
-  return trimmed;
+  return " " + segments.join(" ");
 }
-function wrapWithGuard2(rendered, guard) {
-  if (!guard) {
-    return rendered;
+function emitTextBlock(node, indent, depth) {
+  const inline = emitInlineText(node);
+  if (inline === null || inline.trim().length === 0) {
+    return "";
   }
-  return `(${guard}) ? ${rendered} : ""`;
+  return `${indent.repeat(depth)}${inline}
+`;
 }
-function literal(text) {
-  return JSON.stringify(text);
+function emitInlineText(node) {
+  if (!node.parts.length) {
+    return "";
+  }
+  let text = "";
+  for (const part of node.parts) {
+    if (part.type !== "text") {
+      return null;
+    }
+    text += escapeStaticText(part.value);
+  }
+  return text;
 }
-function concatSegments(segments) {
-  const filtered = segments.filter((segment) => segment && segment !== '""');
-  if (!filtered.length) {
-    return '""';
+function extractStaticAttributeValue(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length < 2) {
+    return null;
+  }
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'" || trimmed[trimmed.length - 1] !== quote) {
+    return null;
+  }
+  const body = trimmed.slice(1, -1);
+  let result = "";
+  let escaping = false;
+  for (const char of body) {
+    if (escaping) {
+      result += unescapeChar(char, quote);
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+    } else {
+      result += char;
+    }
   }
-  if (filtered.length === 1) {
-    return filtered[0];
+  if (escaping) {
+    result += "\\";
+  }
+  return result;
+}
+function unescapeChar(char, quote) {
+  switch (char) {
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "t":
+      return "	";
+    case "\\":
+      return "\\";
+    case '"':
+      return '"';
+    case "'":
+      return "'";
+    default:
+      if (char === quote) {
+        return quote;
+      }
+      return char;
   }
-  return filtered.join(" + ");
 }
 function buildClassAliasEnvironment2(decl) {
   const env = /* @__PURE__ */ new Map();
@@ -530,26 +868,6 @@ function expandClasses2(classes, aliasEnv) {
   }
   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) {
@@ -568,47 +886,21 @@ function escapeStaticText(value) {
     }
   });
 }
-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;",
-    "  }",
-    "}"
-  ];
+function escapeAttributeValue(value) {
+  return value.replace(/["&<>]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return char;
+    }
+  });
 }
 
 // src/diagnostics.ts
@@ -620,142 +912,902 @@ function createSpan(line, col, length, lineOffset) {
   };
 }
 
-// src/parser.ts
-function getIndentLevel(line) {
-  const match = line.match(/^\s*/);
-  return match ? match[0].length / 2 : 0;
-}
-function parse(source) {
+// src/dialect.ts
+function enforceDialect(root, config) {
   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)) {
+  if (root.idToken) {
+    diagnostics.push(
+      ...evaluateToken(
+        { kind: "id", token: root.idToken, span: root.idTokenSpan },
+        config.tokens.id
+      )
+    );
+  }
+  walkNodes(root.children, (occurrence) => {
+    const rule = config.tokens[occurrence.kind];
+    diagnostics.push(...evaluateToken(occurrence, rule));
+  });
+  return diagnostics;
+}
+function walkNodes(nodes, onToken) {
+  for (const node of nodes) {
+    if (node.type === "For") {
+      onFor(node, onToken);
+      walkNodes(node.body, onToken);
       continue;
     }
-    const tabIndex = rawLine.indexOf("	");
-    if (tabIndex !== -1) {
-      pushDiag(
-        diagnostics,
-        "COLLIE001",
-        "Tabs are not allowed; use spaces for indentation.",
-        lineNumber,
-        tabIndex + 1,
-        lineOffset
-      );
+    if (node.type === "Conditional") {
+      onConditional(node, onToken);
       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
+    if (node.type === "Element" || node.type === "Component") {
+      walkNodes(node.children, onToken);
+      if (node.type === "Component" && node.slots) {
+        for (const slot of node.slots) {
+          walkNodes(slot.children, onToken);
+        }
+      }
+      continue;
+    }
+  }
+}
+function onFor(node, onToken) {
+  if (!node.token) {
+    return;
+  }
+  onToken({ kind: "for", token: node.token, span: node.tokenSpan });
+}
+function onConditional(node, onToken) {
+  for (const branch of node.branches) {
+    onBranch(branch, onToken);
+    walkNodes(branch.body, onToken);
+  }
+}
+function onBranch(branch, onToken) {
+  if (!branch.token || !branch.kind) {
+    return;
+  }
+  onToken({ kind: branch.kind, token: branch.token, span: branch.tokenSpan });
+}
+function evaluateToken(occurrence, rule) {
+  const diagnostics = [];
+  const used = occurrence.token;
+  const preferred = rule.preferred;
+  const isAllowed = rule.allow.includes(used);
+  if (!isAllowed) {
+    const severity = levelToSeverity(rule.onDisallowed);
+    if (severity) {
+      diagnostics.push(
+        createDialectDiagnostic(
+          "dialect.token.disallowed",
+          severity,
+          used,
+          preferred,
+          occurrence.span,
+          `Token "${used}" is not allowed for ${occurrence.kind}. Preferred: "${preferred}".`
+        )
+      );
+    }
+    return diagnostics;
+  }
+  if (used !== preferred) {
+    const severity = levelToSeverity(rule.onDisallowed);
+    if (severity) {
+      diagnostics.push(
+        createDialectDiagnostic(
+          "dialect.token.nonPreferred",
+          severity,
+          used,
+          preferred,
+          occurrence.span,
+          `Token "${used}" is allowed but not preferred for ${occurrence.kind}. Preferred: "${preferred}".`
+        )
       );
+    }
+  }
+  return diagnostics;
+}
+function createDialectDiagnostic(code, severity, used, preferred, span, message) {
+  const fix = span ? {
+    range: span,
+    replacementText: preferred
+  } : void 0;
+  return {
+    severity,
+    code,
+    message: message.replace(/\\s+/g, " "),
+    span,
+    fix
+  };
+}
+function levelToSeverity(level) {
+  if (level === "off") {
+    return null;
+  }
+  if (level === "error") {
+    return "error";
+  }
+  return "warning";
+}
+
+// src/props.ts
+var IGNORED_IDENTIFIERS2 = /* @__PURE__ */ new Set([
+  "null",
+  "undefined",
+  "true",
+  "false",
+  "NaN",
+  "Infinity",
+  "this",
+  "props"
+]);
+var RESERVED_KEYWORDS2 = /* @__PURE__ */ new Set([
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+function enforceProps(root, propsConfig) {
+  const diagnostics = [];
+  const declaredProps = /* @__PURE__ */ new Map();
+  const usedLocal = /* @__PURE__ */ new Map();
+  const usedNamespace = /* @__PURE__ */ new Map();
+  const usedAny = /* @__PURE__ */ new Set();
+  const missingReported = /* @__PURE__ */ new Set();
+  const localStyleReported = /* @__PURE__ */ new Set();
+  const namespaceStyleReported = /* @__PURE__ */ new Set();
+  if (root.props?.fields) {
+    for (const field of root.props.fields) {
+      declaredProps.set(field.name, field);
+    }
+  }
+  const preferStyle = propsConfig.preferAccessStyle;
+  const flagLocalStyle = !propsConfig.allowDeclaredLocals || preferStyle === "namespace";
+  const flagNamespaceStyle = !propsConfig.allowPropsNamespace || preferStyle === "locals";
+  const walkNodes2 = (nodes, locals) => {
+    for (const node of nodes) {
+      if (node.type === "Conditional") {
+        handleConditional(node, locals);
+        continue;
+      }
+      if (node.type === "For") {
+        handleFor(node, locals);
+        continue;
+      }
+      if (node.type === "Expression") {
+        handleExpression(node.value, node.span, locals);
+        continue;
+      }
+      if (node.type === "JSXPassthrough") {
+        handleExpression(node.expression, node.span, locals);
+        continue;
+      }
+      if (node.type === "Text") {
+        handleText(node.parts, locals);
+        continue;
+      }
+      if (node.type === "Element") {
+        handleElement(node, locals);
+        continue;
+      }
+      if (node.type === "Component") {
+        handleComponent(node, locals);
+        continue;
+      }
+    }
+  };
+  const handleConditional = (node, locals) => {
+    for (const branch of node.branches) {
+      if (branch.test) {
+        handleExpression(branch.test, branch.testSpan, locals);
+      }
+      walkNodes2(branch.body, locals);
+    }
+  };
+  const handleFor = (node, locals) => {
+    handleExpression(node.arrayExpr, node.arrayExprSpan, locals);
+    const nextLocals = new Set(locals);
+    nextLocals.add(node.itemName);
+    walkNodes2(node.body, nextLocals);
+  };
+  const handleElement = (node, locals) => {
+    if (node.guard) {
+      handleExpression(node.guard, node.guardSpan, locals);
+    }
+    handleAttributes(node.attributes, locals);
+    walkNodes2(node.children, locals);
+  };
+  const handleComponent = (node, locals) => {
+    if (node.guard) {
+      handleExpression(node.guard, node.guardSpan, locals);
+    }
+    handleAttributes(node.attributes, locals);
+    if (node.slots) {
+      for (const slot of node.slots) {
+        walkNodes2(slot.children, locals);
+      }
+    }
+    walkNodes2(node.children, locals);
+  };
+  const handleText = (parts, locals) => {
+    for (const part of parts) {
+      if (part.type === "expr") {
+        handleExpression(part.value, part.span, locals);
+      }
+    }
+  };
+  const handleAttributes = (attributes, locals) => {
+    for (const attr of attributes) {
+      if (!attr.value) continue;
+      const trimmed = attr.value.trim();
+      if (!trimmed || trimmed.startsWith("'") || trimmed.startsWith('"')) {
+        continue;
+      }
+      handleExpression(trimmed, void 0, locals);
+    }
+  };
+  const handleExpression = (expression, span, locals) => {
+    const occurrences = scanExpression(expression);
+    for (const occurrence of occurrences) {
+      const name = occurrence.name;
+      if (occurrence.kind === "local" && locals.has(name)) {
+        continue;
+      }
+      if (shouldIgnoreIdentifier2(name)) {
+        continue;
+      }
+      const usageSpan = span ? offsetSpan(span, occurrence.index, occurrence.length) : void 0;
+      if (occurrence.kind === "namespace") {
+        recordUsage(usedNamespace, name, usageSpan);
+        usedAny.add(name);
+        if (propsConfig.requireDeclarationForLocals && !declaredProps.has(name) && !missingReported.has(name)) {
+          const severity = levelToSeverity2(propsConfig.diagnostics.missingDeclaration);
+          if (severity) {
+            diagnostics.push(createMissingDeclarationDiagnostic(name, severity, usageSpan));
+            missingReported.add(name);
+          }
+        }
+        if (flagNamespaceStyle && !namespaceStyleReported.has(name)) {
+          const severity = levelToSeverity2(propsConfig.diagnostics.style);
+          if (severity) {
+            diagnostics.push(
+              createStyleDiagnostic(
+                name,
+                "namespace",
+                severity,
+                usageSpan,
+                propsConfig.allowPropsNamespace
+              )
+            );
+            namespaceStyleReported.add(name);
+          }
+        }
+        continue;
+      }
+      recordUsage(usedLocal, name, usageSpan);
+      usedAny.add(name);
+      if (propsConfig.requireDeclarationForLocals && !declaredProps.has(name) && !missingReported.has(name)) {
+        const severity = levelToSeverity2(propsConfig.diagnostics.missingDeclaration);
+        if (severity) {
+          diagnostics.push(createMissingDeclarationDiagnostic(name, severity, usageSpan));
+          missingReported.add(name);
+        }
+      }
+      if (flagLocalStyle && !localStyleReported.has(name)) {
+        const severity = levelToSeverity2(propsConfig.diagnostics.style);
+        if (severity) {
+          diagnostics.push(
+            createStyleDiagnostic(name, "local", severity, usageSpan, propsConfig.allowDeclaredLocals)
+          );
+          localStyleReported.add(name);
+        }
+      }
+    }
+  };
+  walkNodes2(root.children, /* @__PURE__ */ new Set());
+  if (root.props?.fields) {
+    for (const field of root.props.fields) {
+      if (!usedAny.has(field.name)) {
+        const severity = levelToSeverity2(propsConfig.diagnostics.unusedDeclaration);
+        if (severity) {
+          diagnostics.push({
+            severity,
+            code: "props.unusedDeclaration",
+            message: `Prop "${field.name}" is declared but never used.`,
+            span: field.span
+          });
+        }
+      }
+    }
+  }
+  if (propsConfig.requirePropsBlockWhen.enabled && !root.props && usedAny.size >= propsConfig.requirePropsBlockWhen.minUniquePropsUsed) {
+    const severity = levelToSeverity2(propsConfig.requirePropsBlockWhen.severity);
+    if (severity) {
+      diagnostics.push({
+        severity,
+        code: "props.block.recommendedOrRequired",
+        message: `Props block recommended: ${usedAny.size} unique prop${usedAny.size === 1 ? "" : "s"} used.`
+      });
+    }
+  }
+  return diagnostics;
+}
+function createMissingDeclarationDiagnostic(name, severity, span) {
+  return {
+    severity,
+    code: "props.missingDeclaration",
+    message: `Prop \`${name}\` is used but not declared in \`#props\`.`,
+    span,
+    data: {
+      kind: "addPropDeclaration",
+      propName: name
+    }
+  };
+}
+function createStyleDiagnostic(name, kind, severity, span, allowed) {
+  if (kind === "namespace") {
+    const message2 = allowed ? `props.${name} is allowed but not preferred; use "${name}" instead.` : `props.${name} is disabled; use "${name}" instead.`;
+    return {
+      severity,
+      code: "props.style.nonPreferred",
+      message: message2,
+      span
+    };
+  }
+  const message = allowed ? `"${name}" is allowed but not preferred; use props.${name} instead.` : `"${name}" is disabled; use props.${name} instead.`;
+  return {
+    severity,
+    code: "props.style.nonPreferred",
+    message,
+    span
+  };
+}
+function recordUsage(map, name, span) {
+  const existing = map.get(name);
+  if (existing) {
+    existing.count += 1;
+    return;
+  }
+  map.set(name, { count: 1, span });
+}
+function scanExpression(expression) {
+  const occurrences = [];
+  let i = 0;
+  let state = "code";
+  while (i < expression.length) {
+    const ch = expression[i];
+    if (state === "code") {
+      if (ch === "'" || ch === '"') {
+        state = ch === "'" ? "single" : "double";
+        i++;
+        continue;
+      }
+      if (ch === "`") {
+        state = "template";
+        i++;
+        continue;
+      }
+      if (ch === "/" && expression[i + 1] === "/") {
+        state = "line";
+        i += 2;
+        continue;
+      }
+      if (ch === "/" && expression[i + 1] === "*") {
+        state = "block";
+        i += 2;
+        continue;
+      }
+      if (isIdentifierStart2(ch)) {
+        const start = i;
+        i++;
+        while (i < expression.length && isIdentifierPart2(expression[i])) {
+          i++;
+        }
+        const name = expression.slice(start, i);
+        const prevNonSpace = findPreviousNonSpace2(expression, start - 1);
+        if (name === "props" && prevNonSpace !== ".") {
+          const namespace = readNamespaceAccess(expression, i);
+          if (namespace) {
+            occurrences.push({
+              name: namespace.name,
+              kind: "namespace",
+              index: namespace.index,
+              length: namespace.name.length
+            });
+            i = namespace.endIndex;
+            continue;
+          }
+        }
+        if (prevNonSpace !== ".") {
+          occurrences.push({ name, kind: "local", index: start, length: name.length });
+        }
+        continue;
+      }
+      i++;
       continue;
     }
-    let level = indent / 2;
-    if (propsBlockLevel !== null && level <= propsBlockLevel) {
-      propsBlockLevel = null;
+    if (state === "line") {
+      if (ch === "\n") {
+        state = "code";
+      }
+      i++;
+      continue;
     }
-    if (classesBlockLevel !== null && level <= classesBlockLevel) {
-      classesBlockLevel = null;
+    if (state === "block") {
+      if (ch === "*" && expression[i + 1] === "/") {
+        state = "code";
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
     }
-    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;
+    if (state === "single") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        state = "code";
+      }
+      i++;
+      continue;
     }
-    while (stack.length > 1 && stack[stack.length - 1].level >= level) {
-      stack.pop();
+    if (state === "double") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === '"') {
+        state = "code";
+      }
+      i++;
+      continue;
     }
-    cleanupConditionalChains(conditionalChains, level);
-    const isElseIfLine = /^@elseIf\b/.test(trimmed);
-    const isElseLine = /^@else\b/.test(trimmed) && !isElseIfLine;
-    if (!isElseIfLine && !isElseLine) {
-      conditionalChains.delete(level);
+    if (state === "template") {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === "`") {
+        state = "code";
+        i++;
+        continue;
+      }
+      i++;
+      continue;
     }
-    if (trimmed === "classes") {
-      if (level !== 0) {
+  }
+  return occurrences;
+}
+function readNamespaceAccess(expression, startIndex) {
+  let i = startIndex;
+  while (i < expression.length && /\s/.test(expression[i])) {
+    i++;
+  }
+  if (expression[i] === "?") {
+    if (expression[i + 1] !== ".") {
+      return null;
+    }
+    i += 2;
+  } else if (expression[i] === ".") {
+    i++;
+  } else {
+    return null;
+  }
+  while (i < expression.length && /\s/.test(expression[i])) {
+    i++;
+  }
+  if (!isIdentifierStart2(expression[i])) {
+    return null;
+  }
+  const propStart = i;
+  i++;
+  while (i < expression.length && isIdentifierPart2(expression[i])) {
+    i++;
+  }
+  return {
+    name: expression.slice(propStart, i),
+    index: propStart,
+    endIndex: i
+  };
+}
+function findPreviousNonSpace2(text, index) {
+  for (let i = index; i >= 0; i--) {
+    const ch = text[i];
+    if (!/\s/.test(ch)) {
+      return ch;
+    }
+  }
+  return null;
+}
+function isIdentifierStart2(ch) {
+  return /[A-Za-z_$]/.test(ch);
+}
+function isIdentifierPart2(ch) {
+  return /[A-Za-z0-9_$]/.test(ch);
+}
+function shouldIgnoreIdentifier2(name) {
+  return IGNORED_IDENTIFIERS2.has(name) || RESERVED_KEYWORDS2.has(name);
+}
+function levelToSeverity2(level) {
+  if (level === "off") {
+    return null;
+  }
+  if (level === "error") {
+    return "error";
+  }
+  return "warning";
+}
+function offsetSpan(base, index, length) {
+  const startOffset = base.start.offset + index;
+  const startCol = base.start.col + index;
+  return {
+    start: {
+      line: base.start.line,
+      col: startCol,
+      offset: startOffset
+    },
+    end: {
+      line: base.start.line,
+      col: startCol + length,
+      offset: startOffset + length
+    }
+  };
+}
+
+// src/parser.ts
+var TEMPLATE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9._-]*$/;
+function getIndentLevel(line) {
+  const match = line.match(/^\s*/);
+  return match ? match[0].length / 2 : 0;
+}
+function getIdValueSpan(lineContent, indent, lineNumber, lineOffset, tokenLength, valueLength) {
+  if (valueLength <= 0) {
+    return void 0;
+  }
+  let cursor = tokenLength;
+  while (cursor < lineContent.length && /\s/.test(lineContent[cursor])) {
+    cursor++;
+  }
+  if (lineContent[cursor] === ":" || lineContent[cursor] === "=") {
+    cursor++;
+    while (cursor < lineContent.length && /\s/.test(lineContent[cursor])) {
+      cursor++;
+    }
+  }
+  const column = indent + cursor + 1;
+  return createSpan(lineNumber, column, valueLength, lineOffset);
+}
+function parse(source, options = {}) {
+  const diagnostics = [];
+  const templates = [];
+  const normalized = source.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  const lineOffsets = buildLineOffsets(lines);
+  let currentHeader = null;
+  let sawIdBlock = false;
+  const seenIds = /* @__PURE__ */ new Map();
+  const finalizeTemplate = (endIndex) => {
+    if (!currentHeader) {
+      return;
+    }
+    const result = parseTemplateBlock(lines, lineOffsets, currentHeader.bodyStartIndex, endIndex, options);
+    const prefixedDiagnostics = prefixDiagnostics(result.diagnostics, currentHeader.id);
+    const unit = {
+      id: currentHeader.id,
+      rawId: currentHeader.rawId,
+      span: currentHeader.span,
+      ast: result.root,
+      diagnostics: prefixedDiagnostics
+    };
+    templates.push(unit);
+    diagnostics.push(...prefixedDiagnostics);
+    currentHeader = null;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const lineNumber = i + 1;
+    const lineOffset = lineOffsets[i];
+    if (/^\s*$/.test(rawLine)) {
+      continue;
+    }
+    const indentMatch = rawLine.match(/^\s*/) ?? [""];
+    const indent = indentMatch[0].length;
+    const lineContent = rawLine.slice(indent);
+    const trimmed = lineContent.trimEnd();
+    const idMatch = trimmed.match(/^#id\b(.*)$/);
+    if (idMatch) {
+      if (indent !== 0) {
         pushDiag(
           diagnostics,
-          "COLLIE301",
-          "Classes block must be at the top level.",
+          "COLLIE701",
+          "#id directives must appear at the top level.",
           lineNumber,
           indent + 1,
           lineOffset,
           trimmed.length
         );
-      } else if (sawTopLevelTemplateNode) {
+        continue;
+      }
+      finalizeTemplate(i);
+      sawIdBlock = true;
+      const remainderRaw = idMatch[1] ?? "";
+      if (remainderRaw && !/^[\s:=]/.test(remainderRaw)) {
         pushDiag(
           diagnostics,
-          "COLLIE302",
-          "Classes block must appear before any template nodes.",
+          "COLLIE702",
+          'Invalid #id directive syntax. Use "#id <id>".',
           lineNumber,
           indent + 1,
           lineOffset,
           trimmed.length
         );
-      } else {
-        if (!root.classAliases) {
-          root.classAliases = { aliases: [] };
-        }
-        classesBlockLevel = level;
       }
-      continue;
-    }
-    if (trimmed === "props") {
-      if (level !== 0) {
+      let valuePart = remainderRaw.trim();
+      if (valuePart.startsWith("=") || valuePart.startsWith(":")) {
+        valuePart = valuePart.slice(1).trim();
+      }
+      const valueSpan = getIdValueSpan(
+        lineContent,
+        indent,
+        lineNumber,
+        lineOffset,
+        "#id".length,
+        valuePart.length
+      );
+      const valueColumn = valueSpan?.start.col ?? indent + 1;
+      const valueLength = valueSpan ? valuePart.length : trimmed.length;
+      if (!valuePart) {
         pushDiag(
           diagnostics,
-          "COLLIE102",
-          "Props block must be at the top level.",
+          "COLLIE702",
+          "#id directives must specify an identifier value.",
           lineNumber,
-          indent + 1,
+          valueColumn,
           lineOffset,
-          trimmed.length
+          valueLength
         );
-      } else if (sawTopLevelTemplateNode || root.props) {
+      } else if (!TEMPLATE_ID_PATTERN.test(valuePart)) {
         pushDiag(
           diagnostics,
-          "COLLIE101",
-          "Props block must appear before any template nodes.",
+          "COLLIE702",
+          'Invalid #id value. IDs must match "^[A-Za-z][A-Za-z0-9._-]*$".',
           lineNumber,
-          indent + 1,
+          valueColumn,
+          lineOffset,
+          valueLength
+        );
+      }
+      if (valuePart && TEMPLATE_ID_PATTERN.test(valuePart)) {
+        const previous = seenIds.get(valuePart);
+        if (previous) {
+          const previousLine = previous.start.line;
+          pushDiag(
+            diagnostics,
+            "COLLIE703",
+            `Duplicate #id "${valuePart}" (first declared on line ${previousLine}).`,
+            lineNumber,
+            valueColumn,
+            lineOffset,
+            valueLength
+          );
+        } else {
+          seenIds.set(valuePart, valueSpan);
+        }
+      }
+      currentHeader = {
+        id: valuePart,
+        rawId: valuePart,
+        span: valueSpan,
+        bodyStartIndex: i + 1
+      };
+      continue;
+    }
+    if (!sawIdBlock && !currentHeader) {
+      pushDiag(
+        diagnostics,
+        "COLLIE701",
+        "Content before the first #id block is not allowed.",
+        lineNumber,
+        indent + 1,
+        lineOffset,
+        trimmed.length
+      );
+    }
+  }
+  finalizeTemplate(lines.length);
+  if (!sawIdBlock) {
+    pushDiag(
+      diagnostics,
+      "COLLIE701",
+      "A .collie file must contain at least one #id block.",
+      1,
+      1,
+      0
+    );
+  }
+  return { templates, diagnostics };
+}
+function parseTemplateBlock(lines, lineOffsets, startIndex, endIndex, options) {
+  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 = [];
+  let i = startIndex;
+  while (i < endIndex) {
+    const rawLine = lines[i];
+    const lineNumber = i + 1;
+    const lineOffset = lineOffsets[i];
+    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 isInPropsBlock = propsBlockLevel !== null && level > propsBlockLevel;
+    const isInClassesBlock = classesBlockLevel !== null && level > classesBlockLevel;
+    while (stack.length > 1 && stack[stack.length - 1].level >= level) {
+      stack.pop();
+    }
+    const parentLevel = stack[stack.length - 1].level;
+    if (level > parentLevel + 1 && !isInPropsBlock && !isInClassesBlock) {
+      pushDiag(
+        diagnostics,
+        "COLLIE003",
+        "Indentation jumped more than one level.",
+        lineNumber,
+        indent + 1,
+        lineOffset
+      );
+      level = parentLevel + 1;
+    }
+    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") {
+      pushDiag(
+        diagnostics,
+        "COLLIE103",
+        "`props` must be declared using `#props`.",
+        lineNumber,
+        indent + 1,
+        lineOffset,
+        trimmed.length
+      );
+      if (level === 0) {
+        propsBlockLevel = 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 (root.props) {
+        pushDiag(
+          diagnostics,
+          "COLLIE101",
+          "Only one #props block is allowed per #id.",
+          lineNumber,
+          indent + 1,
           lineOffset,
           trimmed.length
         );
       } else {
         root.props = { fields: [] };
+      }
+      if (level === 0) {
         propsBlockLevel = level;
       }
       continue;
@@ -801,17 +1853,13 @@ function parse(source) {
         pushDiag(
           diagnostics,
           "COLLIE102",
-          "Props lines must be indented two spaces under the props header.",
+          "#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) {
@@ -848,7 +1896,10 @@ function parse(source) {
         type: "For",
         itemName: forHeader.itemName,
         arrayExpr: forHeader.arrayExpr,
-        body: []
+        body: [],
+        token: forHeader.token,
+        tokenSpan: forHeader.tokenSpan,
+        arrayExprSpan: forHeader.arrayExprSpan
       };
       addChildToParent(parent, forNode);
       if (parent === root) {
@@ -870,7 +1921,14 @@ function parse(source) {
         continue;
       }
       const chain = { type: "Conditional", branches: [] };
-      const branch = { test: header.test, body: [] };
+      const branch = {
+        kind: "if",
+        test: header.test,
+        body: [],
+        token: header.token,
+        tokenSpan: header.tokenSpan,
+        testSpan: header.testSpan
+      };
       chain.branches.push(branch);
       addChildToParent(parent, chain);
       if (parent === root) {
@@ -937,7 +1995,14 @@ function parse(source) {
       if (!header) {
         continue;
       }
-      const branch = { test: header.test, body: [] };
+      const branch = {
+        kind: "elseIf",
+        test: header.test,
+        body: [],
+        token: header.token,
+        tokenSpan: header.tokenSpan,
+        testSpan: header.testSpan
+      };
       chain.node.branches.push(branch);
       branchLocations.push({
         branch,
@@ -992,7 +2057,13 @@ function parse(source) {
       if (!header) {
         continue;
       }
-      const branch = { test: void 0, body: [] };
+      const branch = {
+        kind: "else",
+        test: void 0,
+        body: [],
+        token: header.token,
+        tokenSpan: header.tokenSpan
+      };
       chain.node.branches.push(branch);
       chain.hasElse = true;
       branchLocations.push({
@@ -1075,10 +2146,9 @@ function parse(source) {
     }
     if (lineContent.startsWith("=")) {
       const payload = lineContent.slice(1).trim();
-      if (payload.endsWith("(") || payload.endsWith("<") || i < lines.length && level < getIndentLevel(lines[i])) {
+      if (payload.endsWith("(") || payload.endsWith("<") || i < endIndex && level < getIndentLevel(lines[i])) {
         let jsxContent = payload;
-        const jsxStartLine = i;
-        while (i < lines.length) {
+        while (i < endIndex) {
           const nextRaw = lines[i];
           const nextIndent = getIndentLevel(nextRaw);
           const nextTrimmed = nextRaw.trim();
@@ -1136,7 +2206,7 @@ function parse(source) {
     let multilineEnd = i;
     if (trimmed.includes("(") && !trimmed.includes(")")) {
       let parenDepth = (trimmed.match(/\(/g) || []).length - (trimmed.match(/\)/g) || []).length;
-      while (multilineEnd < lines.length && parenDepth > 0) {
+      while (multilineEnd < endIndex && parenDepth > 0) {
         const nextRaw = lines[multilineEnd];
         multilineEnd++;
         fullLine += "\n" + nextRaw;
@@ -1144,8 +2214,8 @@ function parse(source) {
       }
       i = multilineEnd;
     }
-    const element = parseElement(fullLine, lineNumber, indent + 1, lineOffset, diagnostics);
-    if (!element) {
+    const elementResult = parseElementWithInfo(fullLine, lineNumber, indent + 1, lineOffset, diagnostics);
+    if (!elementResult) {
       const textNode = parseTextPayload(trimmed, lineNumber, indent + 1, lineOffset, diagnostics);
       if (textNode && textNode.parts.length > 0) {
         addChildToParent(parent, textNode);
@@ -1155,11 +2225,31 @@ function parse(source) {
       }
       continue;
     }
+    const element = elementResult.node;
+    let hasIndentedAttributeLines = false;
+    if ((element.type === "Element" || element.type === "Component") && element.children.length === 0) {
+      const indentedAttributes = collectIndentedAttributeLines(
+        lines,
+        lineOffsets,
+        i,
+        endIndex,
+        level,
+        diagnostics
+      );
+      if (indentedAttributes.attributes.length > 0) {
+        element.attributes.push(...indentedAttributes.attributes);
+        hasIndentedAttributeLines = true;
+      }
+      i = indentedAttributes.nextIndex;
+    }
     addChildToParent(parent, element);
     if (parent === root) {
       sawTopLevelTemplateNode = true;
     }
     stack.push({ node: element, level });
+    if (hasIndentedAttributeLines) {
+      stack.push({ node: element, level: level + 1 });
+    }
   }
   if (root.classAliases) {
     validateClassAliasDefinitions(root.classAliases, diagnostics);
@@ -1178,8 +2268,33 @@ function parse(source) {
       );
     }
   }
+  if (options.dialect) {
+    diagnostics.push(...enforceDialect(root, options.dialect));
+    diagnostics.push(...enforceProps(root, options.dialect.props));
+  }
   return { root, diagnostics };
 }
+function buildLineOffsets(lines) {
+  const offsets = [];
+  let offset = 0;
+  for (const line of lines) {
+    offsets.push(offset);
+    offset += line.length + 1;
+  }
+  return offsets;
+}
+function prefixDiagnostics(diagnostics, templateId) {
+  if (!templateId) {
+    return diagnostics;
+  }
+  const prefix = `In template "${templateId}": `;
+  return diagnostics.map((diag) => {
+    if (diag.message.startsWith(prefix)) {
+      return diag;
+    }
+    return { ...diag, message: `${prefix}${diag.message}` };
+  });
+}
 function cleanupConditionalChains(state, level) {
   for (const key of Array.from(state.keys())) {
     if (key > level) {
@@ -1202,21 +2317,59 @@ function isComponentNode(parent) {
 }
 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) {
+  const token = kind === "if" ? "@if" : "@elseIf";
+  if (!trimmed.startsWith(token)) {
     pushDiag(
       diagnostics,
       "COLLIE201",
-      kind === "if" ? "Invalid @if syntax. Use @if (condition)." : "Invalid @elseIf syntax. Use @elseIf (condition).",
+      kind === "if" ? "Invalid @if syntax. Use @if <condition>." : "Invalid @elseIf syntax. Use @elseIf <condition>.",
       lineNumber,
       column,
       lineOffset,
-      trimmed.length || 3
+      trimmed.length || token.length
+    );
+    return null;
+  }
+  const tokenSpan = createSpan(lineNumber, column, token.length, lineOffset);
+  const remainder = trimmed.slice(token.length);
+  if (!remainder.trim()) {
+    pushDiag(
+      diagnostics,
+      "COLLIE201",
+      kind === "if" ? "@if condition cannot be empty." : "@elseIf condition cannot be empty.",
+      lineNumber,
+      column,
+      lineOffset,
+      trimmed.length || token.length
     );
     return null;
   }
-  const test = match[1].trim();
+  const remainderTrimmed = remainder.trimStart();
+  const usesParens = remainderTrimmed.startsWith("(");
+  let testRaw = "";
+  let remainderRaw = "";
+  if (usesParens) {
+    const openIndex = trimmed.indexOf("(", token.length);
+    const closeIndex = trimmed.lastIndexOf(")");
+    if (openIndex === -1 || closeIndex <= openIndex) {
+      pushDiag(
+        diagnostics,
+        "COLLIE201",
+        kind === "if" ? "Invalid @if syntax. Use @if <condition>." : "Invalid @elseIf syntax. Use @elseIf <condition>.",
+        lineNumber,
+        column,
+        lineOffset,
+        trimmed.length || token.length
+      );
+      return null;
+    }
+    testRaw = trimmed.slice(openIndex + 1, closeIndex);
+    remainderRaw = trimmed.slice(closeIndex + 1);
+  } else {
+    testRaw = remainderTrimmed;
+    remainderRaw = "";
+  }
+  const test = testRaw.trim();
   if (!test) {
     pushDiag(
       diagnostics,
@@ -1229,7 +2382,9 @@ function parseConditionalHeader(kind, lineContent, lineNumber, column, lineOffse
     );
     return null;
   }
-  const remainderRaw = match[2] ?? "";
+  const testLeadingWhitespace = testRaw.length - testRaw.trimStart().length;
+  const testColumn = usesParens ? column + trimmed.indexOf("(", token.length) + 1 + testLeadingWhitespace : column + token.length + (remainder.length - remainder.trimStart().length) + testLeadingWhitespace;
+  const testSpan = createSpan(lineNumber, testColumn, test.length, lineOffset);
   const inlineBody = remainderRaw.trim();
   const remainderOffset = trimmed.length - remainderRaw.length;
   const leadingWhitespace = remainderRaw.length - inlineBody.length;
@@ -1238,7 +2393,10 @@ function parseConditionalHeader(kind, lineContent, lineNumber, column, lineOffse
     test,
     inlineBody: inlineBody.length ? inlineBody : void 0,
     inlineColumn,
-    directiveLength: trimmed.length || 3
+    directiveLength: trimmed.length || 3,
+    token,
+    tokenSpan,
+    testSpan
   };
 }
 function parseElseHeader(lineContent, lineNumber, column, lineOffset, diagnostics) {
@@ -1256,6 +2414,8 @@ function parseElseHeader(lineContent, lineNumber, column, lineOffset, diagnostic
     );
     return null;
   }
+  const token = "@else";
+  const tokenSpan = createSpan(lineNumber, column, token.length, lineOffset);
   const remainderRaw = match[1] ?? "";
   const inlineBody = remainderRaw.trim();
   const remainderOffset = trimmed.length - remainderRaw.length;
@@ -1264,7 +2424,9 @@ function parseElseHeader(lineContent, lineNumber, column, lineOffset, diagnostic
   return {
     inlineBody: inlineBody.length ? inlineBody : void 0,
     inlineColumn,
-    directiveLength: trimmed.length || 4
+    directiveLength: trimmed.length || 4,
+    token,
+    tokenSpan
   };
 }
 function parseForHeader(lineContent, lineNumber, column, lineOffset, diagnostics) {
@@ -1282,6 +2444,8 @@ function parseForHeader(lineContent, lineNumber, column, lineOffset, diagnostics
     );
     return null;
   }
+  const token = "@for";
+  const tokenSpan = createSpan(lineNumber, column, token.length, lineOffset);
   const itemName = match[1];
   const arrayExprRaw = match[2];
   if (!itemName || !arrayExprRaw) {
@@ -1309,7 +2473,11 @@ function parseForHeader(lineContent, lineNumber, column, lineOffset, diagnostics
     );
     return null;
   }
-  return { itemName, arrayExpr };
+  const arrayExprLeadingWhitespace = arrayExprRaw.length - arrayExprRaw.trimStart().length;
+  const arrayExprStart = trimmed.length - arrayExprRaw.length;
+  const arrayExprColumn = column + arrayExprStart + arrayExprLeadingWhitespace;
+  const arrayExprSpan = createSpan(lineNumber, arrayExprColumn, arrayExpr.length, lineOffset);
+  return { itemName, arrayExpr, token, tokenSpan, arrayExprSpan };
 }
 function parseInlineNode(source, lineNumber, column, lineOffset, diagnostics) {
   const trimmed = source.trim();
@@ -1417,7 +2585,14 @@ function parseTextPayload(payload, lineNumber, payloadColumn, lineOffset, diagno
             exprEnd2 - exprStart2
           );
         } else {
-          parts.push({ type: "expr", value: inner2 });
+          const innerRaw = payload.slice(exprStart2 + 2, exprEnd2);
+          const leadingWhitespace = innerRaw.length - innerRaw.trimStart().length;
+          const exprColumn = payloadColumn + exprStart2 + 2 + leadingWhitespace;
+          parts.push({
+            type: "expr",
+            value: inner2,
+            span: createSpan(lineNumber, exprColumn, inner2.length, lineOffset)
+          });
         }
         cursor = exprEnd2 + 2;
         continue;
@@ -1448,7 +2623,14 @@ function parseTextPayload(payload, lineNumber, payloadColumn, lineOffset, diagno
           exprEnd - exprStart
         );
       } else {
-        parts.push({ type: "expr", value: inner });
+        const innerRaw = payload.slice(exprStart + 1, exprEnd);
+        const leadingWhitespace = innerRaw.length - innerRaw.trimStart().length;
+        const exprColumn = payloadColumn + exprStart + 1 + leadingWhitespace;
+        parts.push({
+          type: "expr",
+          value: inner,
+          span: createSpan(lineNumber, exprColumn, inner.length, lineOffset)
+        });
       }
       cursor = exprEnd + 1;
       continue;
@@ -1523,474 +2705,1529 @@ function parseExpressionLine(line, lineNumber, column, lineOffset, diagnostics)
     );
     return null;
   }
-  return { type: "Expression", value: inner };
+  const innerRaw = trimmed.slice(2, closeIndex);
+  const leadingWhitespace = innerRaw.length - innerRaw.trimStart().length;
+  const exprColumn = column + 2 + leadingWhitespace;
+  return {
+    type: "Expression",
+    value: inner,
+    span: createSpan(lineNumber, exprColumn, inner.length, lineOffset)
+  };
+}
+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;
+  }
+  const rawPayload = line.slice(1);
+  const leadingWhitespace = rawPayload.length - rawPayload.trimStart().length;
+  const exprColumn = column + 1 + leadingWhitespace;
+  return {
+    type: "JSXPassthrough",
+    expression: payload,
+    span: createSpan(lineNumber, exprColumn, payload.length, lineOffset)
+  };
+}
+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 parseAttributeTokensFromStart(source, lineNumber, column, lineOffset, diagnostics) {
+  let remaining = source;
+  let consumed = 0;
+  let parsedAny = false;
+  const attributes = [];
+  while (remaining.length > 0) {
+    if (!/^([A-Za-z][A-Za-z0-9_-]*)\s*=/.test(remaining)) {
+      break;
+    }
+    parsedAny = true;
+    const before = remaining;
+    const next = parseAndAddAttribute(
+      remaining,
+      attributes,
+      diagnostics,
+      lineNumber,
+      column + consumed,
+      lineOffset
+    );
+    if (next.length === before.length) {
+      break;
+    }
+    consumed += before.length - next.length;
+    remaining = next;
+  }
+  if (!parsedAny) {
+    return null;
+  }
+  return {
+    attributes,
+    rest: remaining,
+    restColumn: column + consumed
+  };
+}
+function parseAttributeLine(source, lineNumber, column, lineOffset, diagnostics) {
+  const result = parseAttributeTokensFromStart(
+    source,
+    lineNumber,
+    column,
+    lineOffset,
+    diagnostics
+  );
+  if (!result || result.rest.length > 0) {
+    return null;
+  }
+  return result.attributes;
+}
+function parseElementWithInfo(line, lineNumber, column, lineOffset, diagnostics) {
+  let name;
+  let cursor = 0;
+  let hasAttributeGroup = false;
+  if (line[cursor] === ".") {
+    name = "div";
+  } else {
+    const nameMatch = line.match(/^([A-Za-z][A-Za-z0-9_]*)/);
+    if (!nameMatch) {
+      return null;
+    }
+    name = nameMatch[1];
+    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);
+    hasAttributeGroup = true;
+    cursor = attrResult.endIndex;
+  }
+  let guard;
+  let guardSpan;
+  const guardProbeStart = cursor;
+  while (cursor < line.length && /\s/.test(line[cursor])) {
+    cursor++;
+  }
+  if (cursor < line.length && line[cursor] === "?") {
+    const guardColumn = column + cursor;
+    cursor++;
+    const guardRaw = line.slice(cursor);
+    const guardExpr = guardRaw.trim();
+    if (!guardExpr) {
+      pushDiag(
+        diagnostics,
+        "COLLIE601",
+        "Guard expressions require a condition after '?'.",
+        lineNumber,
+        guardColumn,
+        lineOffset
+      );
+    } else {
+      guard = guardExpr;
+      const leadingWhitespace = guardRaw.length - guardRaw.trimStart().length;
+      const guardExprColumn = column + cursor + leadingWhitespace;
+      guardSpan = createSpan(lineNumber, guardExprColumn, guardExpr.length, lineOffset);
+    }
+    cursor = line.length;
+  } else {
+    cursor = guardProbeStart;
+  }
+  const restRaw = line.slice(cursor);
+  let rest = restRaw.trimStart();
+  let restColumn = column + cursor + (restRaw.length - rest.length);
+  const children = [];
+  if (rest.length > 0) {
+    const inlineAttrs = parseAttributeTokensFromStart(
+      rest,
+      lineNumber,
+      restColumn,
+      lineOffset,
+      diagnostics
+    );
+    if (inlineAttrs) {
+      attributes.push(...inlineAttrs.attributes);
+      rest = inlineAttrs.rest;
+      restColumn = inlineAttrs.restColumn;
+    }
+    if (rest.length > 0) {
+      if (!rest.startsWith("|")) {
+        pushDiag(
+          diagnostics,
+          "COLLIE004",
+          "Inline text must start with '|'.",
+          lineNumber,
+          restColumn,
+          lineOffset,
+          Math.max(rest.length, 1)
+        );
+      } else {
+        let payload = rest.slice(1);
+        let payloadColumn = restColumn + 1;
+        if (payload.startsWith(" ")) {
+          payload = payload.slice(1);
+          payloadColumn += 1;
+        }
+        const textNode = parseTextPayload(
+          payload,
+          lineNumber,
+          payloadColumn,
+          lineOffset,
+          diagnostics
+        );
+        if (textNode) {
+          children.push(textNode);
+        }
+      }
+    }
+  }
+  if (isComponent) {
+    const component = {
+      type: "Component",
+      name,
+      attributes,
+      children
+    };
+    if (guard) {
+      component.guard = guard;
+      component.guardSpan = guardSpan;
+    }
+    return { node: component, hasAttributeGroup };
+  } else {
+    const element = {
+      type: "Element",
+      name,
+      classes,
+      attributes,
+      children
+    };
+    if (classSpans.length) {
+      element.classSpans = classSpans;
+    }
+    if (guard) {
+      element.guard = guard;
+      element.guardSpan = guardSpan;
+    }
+    return { node: element, hasAttributeGroup };
+  }
+}
+function parseElement(line, lineNumber, column, lineOffset, diagnostics) {
+  const result = parseElementWithInfo(line, lineNumber, column, lineOffset, diagnostics);
+  return result ? result.node : null;
+}
+function collectIndentedAttributeLines(lines, lineOffsets, startIndex, endIndex, parentLevel, diagnostics) {
+  const attributes = [];
+  let index = startIndex;
+  while (index < endIndex) {
+    const rawLine = lines[index];
+    if (/^\s*$/.test(rawLine)) {
+      break;
+    }
+    if (rawLine.includes("	")) {
+      break;
+    }
+    const indentMatch = rawLine.match(/^\s*/) ?? [""];
+    const indent = indentMatch[0].length;
+    if (indent % 2 !== 0) {
+      break;
+    }
+    const level = indent / 2;
+    if (level !== parentLevel + 1) {
+      break;
+    }
+    const lineContent = rawLine.slice(indent);
+    const trimmed = lineContent.trimEnd();
+    const leadingWhitespace = trimmed.length - trimmed.trimStart().length;
+    const attrLine = trimmed.trimStart();
+    if (!attrLine) {
+      break;
+    }
+    const lineNumber = index + 1;
+    const lineOffset = lineOffsets[index];
+    const attrColumn = indent + 1 + leadingWhitespace;
+    const lineAttributes = parseAttributeLine(
+      attrLine,
+      lineNumber,
+      attrColumn,
+      lineOffset,
+      diagnostics
+    );
+    if (!lineAttributes) {
+      break;
+    }
+    attributes.push(...lineAttributes);
+    index++;
+  }
+  return { attributes, nextIndex: index };
+}
+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) {
+        let remaining = parseAndAddAttribute(currentAttr, attributes, diagnostics, lineNumber, column, lineOffset);
+        while (remaining) {
+          remaining = parseAndAddAttribute(remaining, attributes, diagnostics, lineNumber, column, lineOffset);
+        }
+        currentAttr = "";
+      }
+      currentAttr = trimmedLine;
+    } else {
+      if (currentAttr) {
+        currentAttr += " " + trimmedLine;
+      } else {
+        currentAttr = trimmedLine;
+      }
+    }
+  }
+  if (currentAttr) {
+    let remaining = parseAndAddAttribute(currentAttr, attributes, diagnostics, lineNumber, column, lineOffset);
+    while (remaining) {
+      remaining = parseAndAddAttribute(remaining, attributes, diagnostics, lineNumber, column, lineOffset);
+    }
+  }
+  return { attributes, endIndex: cursor };
+}
+function scanBraceAttributeValue(source, diagnostics, lineNumber, column, lineOffset) {
+  if (!source.startsWith("{")) {
+    return null;
+  }
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") {
+      braceDepth++;
+      continue;
+    }
+    if (char === "}") {
+      braceDepth--;
+      if (braceDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+        return { value: source.slice(0, i + 1), rest: source.slice(i + 1).trim() };
+      }
+      continue;
+    }
+    if (char === "(") {
+      parenDepth++;
+      continue;
+    }
+    if (char === ")") {
+      if (parenDepth > 0) {
+        parenDepth--;
+      }
+      continue;
+    }
+    if (char === "[") {
+      bracketDepth++;
+      continue;
+    }
+    if (char === "]") {
+      if (bracketDepth > 0) {
+        bracketDepth--;
+      }
+    }
+  }
+  pushDiag(
+    diagnostics,
+    "COLLIE004",
+    "Unclosed brace in attribute value.",
+    lineNumber,
+    column,
+    lineOffset
+  );
+  return null;
+}
+function parseAndAddAttribute(attrStr, attributes, diagnostics, lineNumber, column, lineOffset) {
+  const trimmed = attrStr.trim();
+  const nameMatch = trimmed.match(/^([A-Za-z][A-Za-z0-9_-]*)\s*=\s*/);
+  if (nameMatch) {
+    const attrName = nameMatch[1];
+    const afterEquals = trimmed.slice(nameMatch[0].length);
+    if (afterEquals.length === 0) {
+      pushDiag(
+        diagnostics,
+        "COLLIE004",
+        `Attribute ${attrName} missing value`,
+        lineNumber,
+        column,
+        lineOffset
+      );
+      return "";
+    }
+    const braceValue = scanBraceAttributeValue(afterEquals, diagnostics, lineNumber, column, lineOffset);
+    if (braceValue) {
+      attributes.push({ name: attrName, value: braceValue.value });
+      return braceValue.rest;
+    }
+    const quoteChar = afterEquals[0];
+    if (quoteChar === '"' || quoteChar === "'") {
+      let i = 1;
+      let value = "";
+      let escaped = false;
+      while (i < afterEquals.length) {
+        const char = afterEquals[i];
+        if (escaped) {
+          value += char;
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === quoteChar) {
+          attributes.push({ name: attrName, value: quoteChar + value + quoteChar });
+          return afterEquals.slice(i + 1).trim();
+        } else {
+          value += char;
+        }
+        i++;
+      }
+      pushDiag(
+        diagnostics,
+        "COLLIE004",
+        `Unclosed quote in attribute ${attrName}`,
+        lineNumber,
+        column,
+        lineOffset
+      );
+      return "";
+    } else {
+      const unquotedMatch = afterEquals.match(/^(\S+)/);
+      if (unquotedMatch) {
+        attributes.push({ name: attrName, value: unquotedMatch[1] });
+        return afterEquals.slice(unquotedMatch[1].length).trim();
+      }
+      return "";
+    }
+  } else {
+    const boolMatch = trimmed.match(/^([A-Za-z][A-Za-z0-9_-]*)(\s+.*)?$/);
+    if (boolMatch) {
+      attributes.push({ name: boolMatch[1], value: null });
+      return boolMatch[2] ? boolMatch[2].trim() : "";
+    } else {
+      pushDiag(
+        diagnostics,
+        "COLLIE004",
+        `Invalid attribute syntax: ${trimmed.slice(0, 30)}`,
+        lineNumber,
+        column,
+        lineOffset
+      );
+      return "";
+    }
+  }
+}
+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
+var import_config = require("@collie-lang/config");
+
+// src/fixes.ts
+function applyFixes(sourceText, fixes) {
+  const normalized = [];
+  const skipped = [];
+  for (const fix of fixes) {
+    const offsets = getSpanOffsets(fix.range);
+    if (!offsets) {
+      skipped.push(fix);
+      continue;
+    }
+    if (offsets.start < 0 || offsets.end < offsets.start || offsets.end > sourceText.length) {
+      skipped.push(fix);
+      continue;
+    }
+    normalized.push({ fix, start: offsets.start, end: offsets.end });
+  }
+  normalized.sort((a, b) => a.start === b.start ? a.end - b.end : a.start - b.start);
+  const accepted = [];
+  let currentEnd = -1;
+  for (const item of normalized) {
+    if (item.start < currentEnd) {
+      skipped.push(item.fix);
+      continue;
+    }
+    accepted.push(item);
+    currentEnd = item.end;
+  }
+  let text = sourceText;
+  for (let i = accepted.length - 1; i >= 0; i--) {
+    const { start, end, fix } = accepted[i];
+    text = `${text.slice(0, start)}${fix.replacementText}${text.slice(end)}`;
+  }
+  return { text, applied: accepted.map((item) => item.fix), skipped };
 }
-function parseJSXPassthrough(line, lineNumber, column, lineOffset, diagnostics) {
-  if (!line.startsWith("=")) {
+function fixAllFromDiagnostics(sourceText, diagnostics) {
+  const fixes = diagnostics.flatMap((diag) => diag.fix ? [diag.fix] : []);
+  return applyFixes(sourceText, fixes);
+}
+function getSpanOffsets(span) {
+  if (!span) {
     return null;
   }
-  const payload = line.slice(1).trim();
-  if (!payload) {
-    pushDiag(
-      diagnostics,
-      "COLLIE005",
-      "JSX passthrough expression cannot be empty.",
-      lineNumber,
-      column,
-      lineOffset
-    );
+  const start = span.start?.offset;
+  const end = span.end?.offset;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
     return null;
   }
-  return { type: "JSXPassthrough", expression: payload };
+  return { start, end };
 }
-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(
+
+// src/format.ts
+function formatCollie(source, options = {}) {
+  const indentSize = validateIndentOption(options.indent);
+  const normalized = source.replace(/\r\n?/g, "\n");
+  const parseResult = parse(normalized);
+  const diagnostics = normalizeDiagnostics(parseResult.diagnostics);
+  const hasErrors2 = diagnostics.some((diag) => diag.severity === "error");
+  if (hasErrors2) {
+    return {
+      formatted: source,
       diagnostics,
-      "COLLIE102",
-      "Props lines must provide a type after the colon.",
-      lineNumber,
-      column,
-      lineOffset,
-      Math.max(line.length, 1)
-    );
-    return null;
+      success: false
+    };
   }
+  const serialized = serializeTemplates(parseResult.templates, indentSize);
+  const formatted = ensureTrailingNewline(serialized);
   return {
-    name,
-    optional: optionalFlag === "?",
-    typeText
+    formatted,
+    diagnostics,
+    success: true
   };
 }
-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;
+function normalizeDiagnostics(diagnostics) {
+  return diagnostics.map((diag) => {
+    if (diag.range || !diag.span) {
+      return diag;
+    }
+    return {
+      ...diag,
+      range: diag.span
+    };
+  });
+}
+function validateIndentOption(indent) {
+  if (indent === void 0) {
+    return 2;
   }
-  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;
+  if (!Number.isFinite(indent) || indent < 1) {
+    throw new Error("Indent width must be a positive integer.");
   }
-  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;
+  return Math.floor(indent);
+}
+function serializeTemplates(templates, indentSize) {
+  const lines = [];
+  for (const template of templates) {
+    if (lines.length && lines[lines.length - 1] !== "") {
+      lines.push("");
+    }
+    const idValue = template.rawId || template.id;
+    lines.push(cleanLine(`#id ${idValue}`));
+    const body = serializeRoot(template.ast, indentSize);
+    if (body.trim().length > 0) {
+      lines.push(...body.split("\n"));
+    }
   }
-  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 };
+  while (lines.length && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines.join("\n");
 }
-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 [];
+function serializeRoot(root, indentSize) {
+  const sections = [];
+  if (root.classAliases && root.classAliases.aliases.length > 0) {
+    sections.push(formatClassAliases(root.classAliases, indentSize));
+  }
+  if (root.props && root.props.fields.length > 0) {
+    sections.push(formatProps(root.props, indentSize));
+  }
+  if (root.children.length > 0) {
+    sections.push(formatNodes(root.children, 0, indentSize));
+  }
+  const lines = [];
+  for (const section of sections) {
+    if (!section.length) continue;
+    if (lines.length && lines[lines.length - 1] !== "") {
+      lines.push("");
+    }
+    for (const line of section) {
+      lines.push(line);
+    }
   }
-  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)
-      );
+  while (lines.length && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines.join("\n");
+}
+function formatClassAliases(decl, indentSize) {
+  const indent = indentString(1, indentSize);
+  const lines = ["classes"];
+  for (const alias of decl.aliases) {
+    const rhs = alias.classes.join(".");
+    lines.push(cleanLine(`${indent}${alias.name} = ${rhs}`));
+  }
+  return lines;
+}
+function formatProps(props, indentSize) {
+  const indent = indentString(1, indentSize);
+  const lines = ["props"];
+  for (const field of props.fields) {
+    const optionalFlag = field.optional ? "?" : "";
+    lines.push(cleanLine(`${indent}${field.name}${optionalFlag}: ${field.typeText.trim()}`));
+  }
+  return lines;
+}
+function formatNodes(nodes, level, indentSize) {
+  const lines = [];
+  for (const node of nodes) {
+    lines.push(...formatNode(node, level, indentSize));
+  }
+  return lines;
+}
+function formatNode(node, level, indentSize) {
+  switch (node.type) {
+    case "Element":
+      return formatElement(node, level, indentSize);
+    case "Component":
+      return formatComponent(node, level, indentSize);
+    case "Text":
+      return [formatTextNode(node, level, indentSize)];
+    case "Expression":
+      return [cleanLine(`${indentString(level, indentSize)}{{ ${node.value} }}`)];
+    case "JSXPassthrough":
+      return formatJsxPassthrough(node.expression, level, indentSize);
+    case "For":
+      return formatFor(node, level, indentSize);
+    case "Conditional":
+      return formatConditional(node, level, indentSize);
+    default:
       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);
-      }
+function formatElement(node, level, indentSize) {
+  const indent = indentString(level, indentSize);
+  let line = `${indent}${node.name}${formatClassList(node.classes)}`;
+  const attrs = formatAttributes(node.attributes);
+  if (attrs) {
+    line += `(${attrs})`;
+  }
+  const children = formatNodes(node.children, level + 1, indentSize);
+  if (children.length === 0) {
+    return [cleanLine(line)];
+  }
+  return [cleanLine(line), ...children];
+}
+function formatComponent(node, level, indentSize) {
+  const indent = indentString(level, indentSize);
+  let line = `${indent}${node.name}`;
+  const attrs = formatAttributes(node.attributes);
+  if (attrs) {
+    line += `(${attrs})`;
+  }
+  const children = formatNodes(node.children, level + 1, indentSize);
+  if (children.length === 0) {
+    return [cleanLine(line)];
+  }
+  return [cleanLine(line), ...children];
+}
+function formatTextNode(node, level, indentSize) {
+  const indent = indentString(level, indentSize);
+  const text = renderTextParts(node.parts);
+  return cleanLine(`${indent}| ${text}`);
+}
+function renderTextParts(parts) {
+  return parts.map((part) => {
+    if (part.type === "text") {
+      return part.value;
+    }
+    return `{${part.value}}`;
+  }).join("");
+}
+function formatJsxPassthrough(expression, level, indentSize) {
+  const indent = indentString(level, indentSize);
+  const childIndent = indentString(level + 1, indentSize);
+  const normalized = expression.replace(/\r\n?/g, "\n").trimEnd();
+  if (!normalized.trim()) {
+    return [cleanLine(`${indent}= ${normalized.trim()}`)];
+  }
+  const lines = normalized.split("\n");
+  const [first, ...rest] = lines;
+  const result = [cleanLine(`${indent}= ${first.trim()}`)];
+  if (rest.length === 0) {
+    return result;
+  }
+  const dedent = computeDedent(rest);
+  for (const raw of rest) {
+    if (!raw.trim()) {
+      result.push("");
       continue;
     }
-    seen.set(alias.name, alias);
+    const withoutIndent = raw.slice(Math.min(dedent, raw.length)).trimEnd();
+    result.push(cleanLine(`${childIndent}${withoutIndent}`));
   }
+  return result;
 }
-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 computeDedent(lines) {
+  let min = Number.POSITIVE_INFINITY;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const indentMatch = line.match(/^\s*/);
+    const indentLength = indentMatch ? indentMatch[0].length : 0;
+    min = Math.min(min, indentLength);
+  }
+  return Number.isFinite(min) ? min : 0;
+}
+function formatFor(node, level, indentSize) {
+  const indent = indentString(level, indentSize);
+  const header = cleanLine(`${indent}@for ${node.itemName} in ${node.arrayExpr}`);
+  const body = formatNodes(node.body, level + 1, indentSize);
+  return body.length ? [header, ...body] : [header];
+}
+function formatConditional(node, level, indentSize) {
+  const indent = indentString(level, indentSize);
+  const lines = [];
+  node.branches.forEach((branch, index) => {
+    let directive;
+    if (index === 0) {
+      directive = `@if (${branch.test ?? ""})`;
+    } else if (branch.test) {
+      directive = `@elseIf (${branch.test})`;
+    } else {
+      directive = "@else";
+    }
+    lines.push(cleanLine(`${indent}${directive}`));
+    const body = formatNodes(branch.body, level + 1, indentSize);
+    lines.push(...body);
+  });
+  return lines;
+}
+function formatAttributes(attributes) {
+  if (!attributes.length) {
+    return "";
   }
+  const sorted = [...attributes].sort((a, b) => {
+    if (a.name === b.name) return 0;
+    if (a.name === "class") return -1;
+    if (b.name === "class") return 1;
+    return a.name.localeCompare(b.name);
+  });
+  return sorted.map((attr) => {
+    if (attr.value === null) {
+      return attr.name;
+    }
+    return `${attr.name}=${normalizeAttributeValue(attr.value)}`;
+  }).join(" ");
 }
-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);
+function normalizeAttributeValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("<")) {
+    return trimmed;
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    const inner = trimmed.slice(1, -1).replace(/"/g, '\\"');
+    return `"${inner}"`;
+  }
+  return trimmed;
+}
+function formatClassList(classes) {
+  if (!classes.length) return "";
+  return classes.map((cls) => `.${cls}`).join("");
+}
+function indentString(level, indentSize) {
+  return " ".repeat(level * indentSize);
+}
+function ensureTrailingNewline(output) {
+  const trimmed = output.replace(/\s+$/g, "");
+  return trimmed.length ? `${trimmed}
+` : "\n";
+}
+function cleanLine(line) {
+  return line.replace(/[ \t]+$/g, "");
+}
+
+// src/convert.ts
+var import_typescript = __toESM(require("typescript"), 1);
+function convertTsxToCollie(source, options = {}) {
+  const filename = options.filename ?? "input.tsx";
+  const sourceFile = import_typescript.default.createSourceFile(
+    filename,
+    source,
+    import_typescript.default.ScriptTarget.Latest,
+    true,
+    inferScriptKind(filename)
+  );
+  const warnings = [];
+  const ctx = { sourceFile, warnings };
+  const propDeclarations = collectPropDeclarations(sourceFile);
+  const component = findComponentInfo(sourceFile, propDeclarations, ctx);
+  if (!component) {
+    throw new Error("Could not find a component that returns JSX in this file.");
+  }
+  const propsLines = buildPropsBlock(component, propDeclarations, ctx);
+  const templateLines = convertJsxNode(component.jsxRoot, ctx, 0);
+  if (!templateLines.length) {
+    throw new Error("Unable to convert JSX tree to Collie template.");
+  }
+  const sections = [];
+  if (propsLines.length) {
+    sections.push(propsLines.join("\n"));
+  }
+  sections.push(templateLines.join("\n"));
+  const collie = `${sections.join("\n\n").trimEnd()}
+`;
+  return { collie, warnings };
+}
+function inferScriptKind(filename) {
+  const dotIndex = filename.lastIndexOf(".");
+  const ext = dotIndex === -1 ? "" : filename.slice(dotIndex).toLowerCase();
+  if (ext === ".tsx") return import_typescript.default.ScriptKind.TSX;
+  if (ext === ".jsx") return import_typescript.default.ScriptKind.JSX;
+  if (ext === ".ts") return import_typescript.default.ScriptKind.TS;
+  return import_typescript.default.ScriptKind.JS;
+}
+function collectPropDeclarations(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  for (const statement of sourceFile.statements) {
+    if (import_typescript.default.isInterfaceDeclaration(statement) && statement.name) {
+      map.set(statement.name.text, extractPropsFromMembers(statement.members, sourceFile));
+    } else if (import_typescript.default.isTypeAliasDeclaration(statement) && import_typescript.default.isTypeLiteralNode(statement.type)) {
+      map.set(statement.name.text, extractPropsFromMembers(statement.type.members, sourceFile));
     }
-    if (node.type === "Component" && node.slots) {
-      for (const slot of node.slots) {
-        for (const child of slot.children) {
-          validateNodeClassAliases(child, defined, diagnostics);
+  }
+  return map;
+}
+function extractPropsFromMembers(members, sourceFile) {
+  const fields = [];
+  for (const member of members) {
+    if (!import_typescript.default.isPropertySignature(member) || member.name === void 0) {
+      continue;
+    }
+    const name = getPropertyName(member.name, sourceFile);
+    if (!name) {
+      continue;
+    }
+    const typeText = member.type ? member.type.getText(sourceFile).trim() : "any";
+    fields.push({
+      name,
+      optional: Boolean(member.questionToken),
+      typeText
+    });
+  }
+  return fields;
+}
+function findComponentInfo(sourceFile, declarations, ctx) {
+  for (const statement of sourceFile.statements) {
+    if (import_typescript.default.isFunctionDeclaration(statement) && statement.body) {
+      const jsx = findJsxReturn(statement.body);
+      if (jsx) {
+        const defaults = extractDefaultsFromParameters(statement.parameters, ctx);
+        const propsInfo = resolvePropsFromParameters(statement.parameters, declarations, ctx);
+        return {
+          jsxRoot: jsx,
+          propsTypeName: propsInfo.typeName,
+          inlineProps: propsInfo.inline,
+          defaults
+        };
+      }
+    } else if (import_typescript.default.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        const init = decl.initializer;
+        if (!init) continue;
+        if (import_typescript.default.isArrowFunction(init) || import_typescript.default.isFunctionExpression(init)) {
+          const jsx = init.body ? findJsxInFunctionBody(init.body) : void 0;
+          if (!jsx) {
+            continue;
+          }
+          const defaults = extractDefaultsFromParameters(init.parameters, ctx);
+          const propsInfo = resolvePropsFromParameters(init.parameters, declarations, ctx);
+          if (!propsInfo.typeName && !propsInfo.inline && decl.type) {
+            const inferred = resolvePropsFromTypeAnnotation(decl.type, sourceFile, declarations);
+            if (inferred.typeName && !propsInfo.typeName) {
+              propsInfo.typeName = inferred.typeName;
+            }
+            if (inferred.inline && !propsInfo.inline) {
+              propsInfo.inline = inferred.inline;
+            }
+          }
+          return {
+            jsxRoot: jsx,
+            propsTypeName: propsInfo.typeName,
+            inlineProps: propsInfo.inline,
+            defaults
+          };
         }
       }
     }
-    return;
   }
-  if (node.type === "Conditional") {
-    for (const branch of node.branches) {
-      for (const child of branch.body) {
-        validateNodeClassAliases(child, defined, diagnostics);
-      }
+  return null;
+}
+function resolvePropsFromParameters(parameters, declarations, ctx) {
+  if (!parameters.length) {
+    return {};
+  }
+  const param = parameters[0];
+  if (param.type) {
+    const inferred = resolvePropsFromTypeAnnotation(param.type, ctx.sourceFile, declarations);
+    if (inferred.inline) {
+      return inferred;
+    }
+    if (inferred.typeName) {
+      return inferred;
     }
   }
-  if (node.type === "For") {
-    for (const child of node.body) {
-      validateNodeClassAliases(child, defined, diagnostics);
+  return {};
+}
+function resolvePropsFromTypeAnnotation(typeNode, sourceFile, declarations) {
+  if (import_typescript.default.isTypeReferenceNode(typeNode)) {
+    const referenced = getTypeReferenceName(typeNode.typeName);
+    if (referenced && declarations.has(referenced)) {
+      return { typeName: referenced };
+    }
+    const typeArg = typeNode.typeArguments?.[0];
+    if (typeArg) {
+      if (import_typescript.default.isTypeReferenceNode(typeArg)) {
+        const nested = getTypeReferenceName(typeArg.typeName);
+        if (nested && declarations.has(nested)) {
+          return { typeName: nested };
+        }
+      } else if (import_typescript.default.isTypeLiteralNode(typeArg)) {
+        return { inline: extractPropsFromMembers(typeArg.members, sourceFile) };
+      }
     }
   }
+  if (import_typescript.default.isTypeLiteralNode(typeNode)) {
+    return { inline: extractPropsFromMembers(typeNode.members, sourceFile) };
+  }
+  return {};
 }
-function parseElement(line, lineNumber, column, lineOffset, diagnostics) {
-  const nameMatch = line.match(/^([A-Za-z][A-Za-z0-9_]*)/);
-  if (!nameMatch) {
-    return null;
+function getTypeReferenceName(typeName) {
+  if (import_typescript.default.isIdentifier(typeName)) {
+    return typeName.text;
   }
-  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 (import_typescript.default.isQualifiedName(typeName)) {
+    return typeName.right.text;
   }
-  if (cursor < line.length) {
-    const nextChar = line[cursor];
-    if (nextChar !== "." && nextChar !== "(" && !/\s/.test(nextChar)) {
-      return null;
-    }
+  if (import_typescript.default.isPropertyAccessExpression(typeName)) {
+    return getTypeReferenceName(typeName.name);
   }
-  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;
+  return void 0;
+}
+function findJsxReturn(body) {
+  for (const statement of body.statements) {
+    if (import_typescript.default.isReturnStatement(statement) && statement.expression) {
+      const jsx = unwrapJsx(statement.expression);
+      if (jsx) {
+        return jsx;
       }
-      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;
+  return void 0;
+}
+function findJsxInFunctionBody(body) {
+  if (import_typescript.default.isBlock(body)) {
+    return findJsxReturn(body);
   }
-  let guard;
-  const guardProbeStart = cursor;
-  while (cursor < line.length && /\s/.test(line[cursor])) {
-    cursor++;
+  return unwrapJsx(body);
+}
+function unwrapJsx(expression) {
+  let current = expression;
+  while (import_typescript.default.isParenthesizedExpression(current)) {
+    current = current.expression;
   }
-  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;
+  if (import_typescript.default.isJsxElement(current) || import_typescript.default.isJsxFragment(current) || import_typescript.default.isJsxSelfClosingElement(current)) {
+    return current;
   }
-  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);
-    }
+  return void 0;
+}
+function extractDefaultsFromParameters(parameters, ctx) {
+  const defaults = /* @__PURE__ */ new Map();
+  if (!parameters.length) {
+    return defaults;
   }
-  if (isComponent) {
-    const component = {
-      type: "Component",
-      name,
-      attributes,
-      children
-    };
-    if (guard) {
-      component.guard = guard;
+  const param = parameters[0];
+  if (!import_typescript.default.isObjectBindingPattern(param.name)) {
+    return defaults;
+  }
+  for (const element of param.name.elements) {
+    if (!element.initializer) {
+      continue;
     }
-    return component;
-  } else {
-    const element = {
-      type: "Element",
-      name,
-      classes,
-      attributes,
-      children
-    };
-    if (classSpans.length) {
-      element.classSpans = classSpans;
+    const propName = getBindingElementPropName(element, ctx.sourceFile);
+    if (!propName) {
+      ctx.warnings.push("Skipping complex destructured default value.");
+      continue;
     }
-    if (guard) {
-      element.guard = guard;
+    defaults.set(propName, element.initializer.getText(ctx.sourceFile).trim());
+  }
+  return defaults;
+}
+function getBindingElementPropName(element, sourceFile) {
+  const prop = element.propertyName;
+  if (prop) {
+    if (import_typescript.default.isIdentifier(prop) || import_typescript.default.isStringLiteral(prop) || import_typescript.default.isNumericLiteral(prop)) {
+      return prop.text;
     }
-    return element;
+    return prop.getText(sourceFile);
   }
+  if (import_typescript.default.isIdentifier(element.name)) {
+    return element.name.text;
+  }
+  return void 0;
 }
-function parseAttributes(line, startIndex, lineNumber, column, lineOffset, diagnostics) {
-  if (line[startIndex] !== "(") {
-    return null;
+function getPropertyName(name, sourceFile) {
+  if (import_typescript.default.isIdentifier(name)) {
+    return name.text;
   }
-  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;
+  if (import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return name.getText(sourceFile);
+}
+function buildPropsBlock(info, propDeclarations, ctx) {
+  const fields = info.inlineProps ?? (info.propsTypeName ? propDeclarations.get(info.propsTypeName) ?? [] : void 0) ?? [];
+  if (!fields.length && !info.defaults.size) {
+    return [];
+  }
+  const lines = ["props"];
+  if (fields.length) {
+    for (const field of fields) {
+      const def = info.defaults.get(field.name);
+      let line = `  ${field.name}${field.optional ? "?" : ""}: ${field.typeText}`;
+      if (def) {
+        line += ` = ${def}`;
       }
-    } else {
-      attrBuffer += ch;
+      lines.push(line);
+    }
+  } else {
+    for (const [name, defValue] of info.defaults.entries()) {
+      lines.push(`  ${name}: any = ${defValue}`);
     }
-    cursor++;
   }
-  if (depth !== 0) {
-    pushDiag(
-      diagnostics,
-      "COLLIE004",
-      "Unclosed attribute parentheses.",
-      lineNumber,
-      column + startIndex,
-      lineOffset
-    );
-    return null;
+  return lines;
+}
+function convertJsxNode(node, ctx, indent) {
+  if (import_typescript.default.isJsxElement(node)) {
+    return convertJsxElement(node, ctx, indent);
   }
-  const trimmedAttrs = attrBuffer.trim();
-  if (trimmedAttrs.length === 0) {
-    return { attributes: [], endIndex: cursor };
+  if (import_typescript.default.isJsxSelfClosingElement(node)) {
+    return convertJsxSelfClosing(node, ctx, indent);
   }
-  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 = "";
+  if (import_typescript.default.isJsxFragment(node)) {
+    return convertJsxFragment(node, ctx, indent);
+  }
+  if (import_typescript.default.isJsxText(node)) {
+    return convertJsxText(node, ctx, indent);
+  }
+  if (import_typescript.default.isJsxExpression(node)) {
+    return convertJsxExpression(node, ctx, indent);
+  }
+  return [];
+}
+function convertJsxFragment(fragment, ctx, indent) {
+  const lines = [];
+  for (const child of fragment.children) {
+    lines.push(...convertJsxNode(child, ctx, indent));
+  }
+  return lines;
+}
+function convertJsxElement(element, ctx, indent) {
+  const line = buildElementLine(element.openingElement, ctx, indent);
+  const children = [];
+  for (const child of element.children) {
+    children.push(...convertJsxNode(child, ctx, indent + 1));
+  }
+  if (!children.length) {
+    return [line];
+  }
+  return [line, ...children];
+}
+function convertJsxSelfClosing(element, ctx, indent) {
+  return [buildElementLine(element, ctx, indent)];
+}
+function buildElementLine(element, ctx, indent) {
+  const indentStr = "  ".repeat(indent);
+  const tagName = getTagName(element.tagName, ctx);
+  const { classSegments, attributes } = convertAttributes(element.attributes, ctx);
+  const classes = classSegments.length ? classSegments.map((cls) => `.${cls}`).join("") : "";
+  const attrString = attributes.length ? `(${attributes.join(" ")})` : "";
+  return `${indentStr}${tagName}${classes}${attrString}`;
+}
+function getTagName(tag, ctx) {
+  const fallback = tag.getText(ctx.sourceFile);
+  if (import_typescript.default.isIdentifier(tag)) {
+    return tag.text;
+  }
+  if (import_typescript.default.isPropertyAccessExpression(tag)) {
+    const left = getTagName(tag.expression, ctx);
+    return `${left}.${tag.name.text}`;
+  }
+  if (tag.kind === import_typescript.default.SyntaxKind.ThisKeyword) {
+    return "this";
+  }
+  if (import_typescript.default.isJsxNamespacedName(tag)) {
+    return `${tag.namespace.text}:${tag.name.text}`;
+  }
+  return fallback;
+}
+function convertAttributes(attributes, ctx) {
+  const classSegments = [];
+  const attrs = [];
+  for (const attr of attributes.properties) {
+    if (import_typescript.default.isJsxAttribute(attr)) {
+      const attrName = getAttributeName(attr.name, ctx);
+      if (!attrName) {
+        ctx.warnings.push("Skipping unsupported attribute name.");
+        continue;
       }
-      currentAttr = trimmedLine;
-    } else {
-      if (currentAttr) {
-        currentAttr += " " + trimmedLine;
-      } else {
-        currentAttr = trimmedLine;
+      if (attrName === "className" || attrName === "class") {
+        const handled = handleClassAttribute(attr, ctx, classSegments, attrs);
+        if (!handled) {
+          attrs.push(formatAttribute(attrName === "className" ? "className" : attrName, attr.initializer, ctx));
+        }
+        continue;
       }
+      attrs.push(formatAttribute(attrName, attr.initializer, ctx));
+    } else if (import_typescript.default.isJsxSpreadAttribute(attr)) {
+      ctx.warnings.push("Spread attributes are not supported and were skipped.");
     }
   }
-  if (currentAttr) {
-    parseAndAddAttribute(currentAttr, attributes, diagnostics, lineNumber, column, lineOffset);
+  return { classSegments, attributes: attrs.filter(Boolean) };
+}
+function handleClassAttribute(attr, ctx, classSegments, attrs) {
+  if (!attr.initializer) {
+    return false;
   }
-  return { attributes, endIndex: cursor };
+  if (import_typescript.default.isStringLiteral(attr.initializer)) {
+    classSegments.push(...splitClassNames(attr.initializer.text));
+    return true;
+  }
+  if (import_typescript.default.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+    const expressionText = attr.initializer.expression.getText(ctx.sourceFile).trim();
+    attrs.push(`className={${expressionText}}`);
+    return true;
+  }
+  ctx.warnings.push("Unsupported class attribute value; leaving as-is.");
+  return false;
 }
-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 splitClassNames(value) {
+  return value.split(/\s+/).map((cls) => cls.trim()).filter(Boolean);
+}
+function formatAttribute(name, initializer, ctx) {
+  if (!initializer) {
+    return name;
+  }
+  if (import_typescript.default.isStringLiteral(initializer)) {
+    return `${name}="${initializer.text}"`;
+  }
+  if (import_typescript.default.isJsxExpression(initializer)) {
+    if (initializer.expression) {
+      const expr = initializer.expression.getText(ctx.sourceFile).trim();
+      return `${name}={${expr}}`;
     }
+    return name;
   }
+  ctx.warnings.push("Unsupported JSX attribute value; leaving as-is.");
+  return name;
 }
-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)
-  });
+function getAttributeName(name, ctx) {
+  if (import_typescript.default.isIdentifier(name)) {
+    return name.text;
+  }
+  if (import_typescript.default.isJsxNamespacedName(name)) {
+    return `${name.namespace.text}:${name.name.text}`;
+  }
+  return null;
+}
+function convertJsxText(textNode, ctx, indent) {
+  const text = textNode.getText(ctx.sourceFile).replace(/\s+/g, " ").trim();
+  if (!text) {
+    return [];
+  }
+  return [`${"  ".repeat(indent)}| ${text}`];
+}
+function convertJsxExpression(expressionNode, ctx, indent) {
+  if (!expressionNode.expression) {
+    return [];
+  }
+  const exprText = expressionNode.expression.getText(ctx.sourceFile).trim();
+  if (!exprText) {
+    return [];
+  }
+  return [`${"  ".repeat(indent)}{{ ${exprText} }}`];
 }
 
 // src/index.ts
 function parseCollie(source, options = {}) {
-  const result = parse(source);
+  const result = parse(source, { dialect: options.dialect });
   if (!options.filename) {
-    return result;
+    return {
+      templates: result.templates.map((template) => ({
+        ...template,
+        diagnostics: normalizeDiagnostics2(template.diagnostics)
+      })),
+      diagnostics: normalizeDiagnostics2(result.diagnostics)
+    };
+  }
+  return {
+    templates: result.templates.map((template) => ({
+      ...template,
+      diagnostics: normalizeDiagnostics2(template.diagnostics, options.filename)
+    })),
+    diagnostics: normalizeDiagnostics2(result.diagnostics, options.filename)
+  };
+}
+function compileTemplate(template, options = {}) {
+  const diagnostics = normalizeDiagnostics2(template.diagnostics, options.filename);
+  const jsxRuntime = options.jsxRuntime ?? "automatic";
+  const flavor = options.flavor ?? "tsx";
+  let code = createStubRender(flavor);
+  if (!hasErrors(diagnostics)) {
+    code = generateRenderModule(template.ast, { jsxRuntime, flavor });
   }
-  return { root: result.root, diagnostics: attachFilename(result.diagnostics, options.filename) };
+  const meta = buildCompileMeta(template, options.filename);
+  return { code, diagnostics, map: void 0, meta };
 }
 function compileToJsx(sourceOrAst, options = {}) {
-  const document = normalizeDocument(sourceOrAst, options.filename);
-  const diagnostics = options.filename ? attachFilename(document.diagnostics, options.filename) : document.diagnostics;
+  const document = normalizeDocument(sourceOrAst, options.filename, options.dialect);
+  const diagnostics = normalizeDiagnostics2(document.diagnostics, options.filename);
+  const template = document.templates[0];
   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" });
+  if (!hasErrors(diagnostics) && template) {
+    const renderResult = compileTemplate(template, {
+      filename: options.filename,
+      jsxRuntime,
+      flavor: "jsx"
+    });
+    code = wrapRenderModuleAsComponent(renderResult.code, componentName, "jsx");
   }
-  return { code, diagnostics, map: void 0 };
+  const meta = buildCompileMeta(template, options.filename);
+  return { code, diagnostics, map: void 0, meta };
 }
 function compileToTsx(sourceOrAst, options = {}) {
-  const document = normalizeDocument(sourceOrAst, options.filename);
-  const diagnostics = options.filename ? attachFilename(document.diagnostics, options.filename) : document.diagnostics;
+  const document = normalizeDocument(sourceOrAst, options.filename, options.dialect);
+  const diagnostics = normalizeDiagnostics2(document.diagnostics, options.filename);
+  const template = document.templates[0];
   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" });
+  if (!hasErrors(diagnostics) && template) {
+    const renderResult = compileTemplate(template, {
+      filename: options.filename,
+      jsxRuntime,
+      flavor: "tsx"
+    });
+    code = wrapRenderModuleAsComponent(renderResult.code, componentName, "tsx");
   }
-  return { code, diagnostics, map: void 0 };
+  const meta = buildCompileMeta(template, options.filename);
+  return { code, diagnostics, map: void 0, meta };
+}
+function convertCollieToTsx(source, options = {}) {
+  const result = compileToTsx(source, options);
+  return {
+    tsx: result.code,
+    diagnostics: result.diagnostics,
+    meta: result.meta
+  };
 }
 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 };
+  const document = normalizeDocument(sourceOrAst, options.filename, options.dialect);
+  const diagnostics = normalizeDiagnostics2(document.diagnostics, options.filename);
+  const template = document.templates[0];
+  let code = createStubHtml();
+  if (!hasErrors(diagnostics) && template) {
+    code = generateHtml(template.ast);
+  }
+  const meta = buildCompileMeta(template, options.filename);
+  return { code, diagnostics, map: void 0, meta };
 }
 function compile(source, options = {}) {
   return compileToJsx(source, options);
 }
-function normalizeDocument(sourceOrAst, filename) {
+function normalizeDocument(sourceOrAst, filename, dialect) {
   if (typeof sourceOrAst === "string") {
-    return parseCollie(sourceOrAst, { filename });
+    return parseCollie(sourceOrAst, { filename, dialect });
   }
   if (isCollieDocument(sourceOrAst)) {
     if (!filename) {
       return sourceOrAst;
     }
-    return { root: sourceOrAst.root, diagnostics: attachFilename(sourceOrAst.diagnostics, filename) };
+    return attachFilenameToDocument(sourceOrAst, filename);
   }
   if (isRootNode(sourceOrAst)) {
-    return { root: sourceOrAst, diagnostics: [] };
+    const id = sourceOrAst.id ?? sourceOrAst.rawId ?? "";
+    const rawId = sourceOrAst.rawId ?? sourceOrAst.id ?? "";
+    const template = {
+      id,
+      rawId,
+      span: sourceOrAst.idTokenSpan,
+      ast: sourceOrAst,
+      diagnostics: []
+    };
+    return { templates: [template], diagnostics: [] };
   }
   throw new TypeError("Collie compiler expected source text, a parsed document, or a root node.");
 }
@@ -1998,7 +4235,7 @@ 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);
+  return !!value && typeof value === "object" && Array.isArray(value.templates) && Array.isArray(value.diagnostics);
 }
 function hasErrors(diagnostics) {
   return diagnostics.some((diag) => diag.severity === "error");
@@ -2014,21 +4251,87 @@ function createStubComponent(name, flavor) {
   }
   return [`export default function ${name}(props) {`, "  return null;", "}"].join("\n");
 }
-function createStubHtml(name) {
-  return [`export default function ${name}(props = {}) {`, '  return "";', "}"].join("\n");
+function createStubRender(flavor) {
+  if (flavor === "tsx") {
+    return [
+      "export type Props = Record<string, never>;",
+      "export function render(props: any) {",
+      "  return null;",
+      "}"
+    ].join("\n");
+  }
+  return ["export function render(props) {", "  return null;", "}"].join("\n");
+}
+function wrapRenderModuleAsComponent(renderModule, name, flavor) {
+  const signature = flavor === "tsx" ? `export default function ${name}(props: Props) {` : `export default function ${name}(props) {`;
+  const wrapper = [signature, "  return render(props);", "}"].join("\n");
+  return `${renderModule}
+
+${wrapper}`;
+}
+function createStubHtml() {
+  return "";
+}
+function buildCompileMeta(template, filename) {
+  const meta = {};
+  if (filename) {
+    meta.filename = filename;
+  }
+  if (template?.rawId) {
+    meta.rawId = template.rawId;
+  }
+  if (template?.id) {
+    meta.id = template.id;
+  }
+  if (template?.span) {
+    meta.span = template.span;
+  }
+  return meta.id || meta.rawId || meta.filename ? meta : void 0;
 }
-function attachFilename(diagnostics, filename) {
+function attachFilenameToDocument(document, filename) {
   if (!filename) {
-    return diagnostics;
+    return document;
   }
-  return diagnostics.map((diag) => diag.file ? diag : { ...diag, file: filename });
+  return {
+    templates: document.templates.map((template) => ({
+      ...template,
+      diagnostics: normalizeDiagnostics2(template.diagnostics, filename)
+    })),
+    diagnostics: normalizeDiagnostics2(document.diagnostics, filename)
+  };
+}
+function normalizeDiagnostics2(diagnostics, filename) {
+  return diagnostics.map((diag) => {
+    const filePath = diag.filePath ?? diag.file ?? filename;
+    const file = diag.file ?? filename;
+    const range = diag.range ?? diag.span;
+    if (filePath === diag.filePath && file === diag.file && range === diag.range) {
+      return diag;
+    }
+    return {
+      ...diag,
+      filePath,
+      file,
+      range
+    };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  applyFixes,
   compile,
+  compileTemplate,
   compileToHtml,
   compileToJsx,
   compileToTsx,
+  convertCollieToTsx,
+  convertTsxToCollie,
+  defineConfig,
+  fixAllFromDiagnostics,
+  formatCollie,
+  loadAndNormalizeConfig,
+  loadConfig,
+  normalizeConfig,
   parse,
   parseCollie
 });