@tachui/core 0.7.1-alpha → 0.8.1-alpha

package/dist/plugin-BCAdZXKq.js

@@ -0,0 +1,1680 @@
+import * as l from "typescript";
+var E = Object.defineProperty, $ = (a, e, t) => e in a ? E(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, u = (a, e, t) => $(a, typeof e != "symbol" ? e + "" : e, t);
+class b {
+  constructor(e, t) {
+    u(this, "code"), u(this, "filename"), u(this, "position", 0), u(this, "line", 1), u(this, "column", 1), this.code = e, this.filename = t;
+  }
+  /**
+   * Parse advanced SwiftUI syntax into enhanced AST
+   */
+  parse() {
+    const e = [];
+    for (; !this.isAtEnd() && (this.skipWhitespace(), !this.isAtEnd()); ) {
+      const t = this.parseAdvancedNode();
+      t && e.push(t);
+    }
+    return e;
+  }
+  /**
+   * Parse advanced AST nodes including conditionals and loops
+   */
+  parseAdvancedNode() {
+    const e = this.currentPosition(), t = this.position;
+    return this.match("if") ? this.parseConditional(e) : this.match("ForEach") ? this.parseForEach(e) : this.peek() === "@" ? this.parsePropertyWrapper(e) : this.peek() === "$" ? this.parseStateBinding(e) : this.isComponentStart() ? this.parseEnhancedComponent(e) : (this.position === t && this.advance(), null);
+  }
+  /**
+   * Parse conditional rendering (if/else)
+   */
+  parseConditional(e) {
+    this.skipWhitespace();
+    const t = this.parseComplexExpression();
+    if (!t)
+      throw new Error(`Expected condition after 'if' at line ${this.line}`);
+    this.skipWhitespace();
+    const i = [];
+    if (this.peek() === "{") {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== "}"; ) {
+        const r = this.parseAdvancedNode();
+        r && i.push(r), this.skipWhitespace();
+      }
+      this.peek() === "}" && this.advance();
+    }
+    let n;
+    if (this.skipWhitespace(), this.match("else") && (n = [], this.skipWhitespace(), this.peek() === "{")) {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== "}"; ) {
+        const r = this.parseAdvancedNode();
+        r && n.push(r), this.skipWhitespace();
+      }
+      this.peek() === "}" && this.advance();
+    }
+    const s = {
+      type: "Conditional",
+      condition: t,
+      thenBody: i,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+    return n !== void 0 && (s.elseBody = n), s;
+  }
+  /**
+   * Parse ForEach loops for list rendering
+   */
+  parseForEach(e) {
+    if (this.skipWhitespace(), this.peek() !== "(")
+      throw new Error(`Expected '(' after ForEach at line ${this.line}`);
+    this.advance(), this.skipWhitespace();
+    const t = this.parseComplexExpression();
+    if (!t)
+      throw new Error(
+        `Expected iterable expression in ForEach at line ${this.line}`
+      );
+    this.skipWhitespace(), this.peek() === "," && (this.advance(), this.skipWhitespace()), this.match("id:") && (this.skipWhitespace(), this.parseComplexExpression()), this.skipWhitespace(), this.peek() === ")" && this.advance(), this.skipWhitespace();
+    let i = "item";
+    if (this.peek() === "{") {
+      this.advance(), this.skipWhitespace();
+      const s = this.position, r = this.parseIdentifier();
+      r && this.match("in") ? i = r : this.position = s;
+    }
+    const n = [];
+    for (; !this.isAtEnd() && this.peek() !== "}"; ) {
+      const s = this.parseAdvancedNode();
+      s && n.push(s), this.skipWhitespace();
+    }
+    return this.peek() === "}" && this.advance(), {
+      type: "ForEach",
+      iterable: t,
+      itemIdentifier: i,
+      body: n,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse property wrappers (@State, @Computed, etc.)
+   */
+  parsePropertyWrapper(e) {
+    this.advance();
+    const t = this.parseIdentifier();
+    if (!t || !["State", "Computed", "Effect"].includes(t))
+      throw new Error(
+        `Unknown property wrapper @${t} at line ${this.line}`
+      );
+    this.skipWhitespace();
+    const i = this.parseIdentifier();
+    if (!i)
+      throw new Error(
+        `Expected identifier after @${t} at line ${this.line}`
+      );
+    let n;
+    if (this.skipWhitespace(), this.peek() === "=") {
+      this.advance(), this.skipWhitespace();
+      const r = this.parseComplexExpression();
+      r && (n = r);
+    }
+    const s = {
+      type: "PropertyWrapper",
+      wrapper: t,
+      identifier: i,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+    return n !== void 0 && (s.initialValue = n), s;
+  }
+  /**
+   * Parse state bindings ($variable)
+   */
+  parseStateBinding(e) {
+    this.advance();
+    const t = this.parseIdentifier();
+    if (!t)
+      throw new Error(`Expected identifier after '$' at line ${this.line}`);
+    return {
+      type: "StateBinding",
+      identifier: t,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse enhanced components with complex modifier chains
+   */
+  parseEnhancedComponent(e) {
+    const t = this.parseIdentifier();
+    this.skipWhitespace();
+    const i = [], n = [];
+    if (this.peek() === "(") {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== ")"; ) {
+        const s = this.parseComplexExpression();
+        s && i.push(s), this.skipWhitespace(), this.peek() === "," && (this.advance(), this.skipWhitespace());
+      }
+      this.peek() === ")" && this.advance();
+    } else if (this.peek() === "{") {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== "}"; ) {
+        const s = this.parseAdvancedNode();
+        s && i.push(s), this.skipWhitespace();
+      }
+      this.peek() === "}" && this.advance();
+    }
+    for (this.skipWhitespace(); this.peek() === "."; ) {
+      const s = this.parseAdvancedModifier();
+      s && n.push(s), this.skipWhitespace();
+    }
+    return {
+      type: "Component",
+      name: t,
+      children: i,
+      modifiers: n,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse advanced modifiers with complex expressions
+   */
+  parseAdvancedModifier() {
+    if (this.peek() !== ".") return null;
+    const e = this.currentPosition();
+    this.advance();
+    const t = this.parseIdentifier();
+    if (!t) return null;
+    const i = [];
+    if (this.peek() === "(") {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== ")"; ) {
+        const n = this.parseComplexExpression();
+        n && i.push(n), this.skipWhitespace(), this.peek() === "," && (this.advance(), this.skipWhitespace());
+      }
+      this.peek() === ")" && this.advance();
+    }
+    return {
+      type: "Modifier",
+      name: t,
+      arguments: i,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse complex expressions including function calls, property access, etc.
+   */
+  parseComplexExpression() {
+    this.skipWhitespace();
+    const e = this.currentPosition();
+    if (this.peek() === '"' || this.peek() === "'")
+      return this.parseStringLiteral(e);
+    if (this.isDigit(this.peek()))
+      return this.parseNumberLiteral(e);
+    if (this.match("true") || this.match("false") || this.match("null")) {
+      const i = this.code.slice(e.offset, this.position);
+      return {
+        type: "Literal",
+        value: i === "true" ? !0 : i === "false" ? !1 : null,
+        raw: i,
+        loc: {
+          start: e,
+          end: this.currentPosition(),
+          source: this.filename
+        }
+      };
+    }
+    const t = this.parseIdentifier();
+    return t ? (this.skipWhitespace(), this.peek() === "(" ? this.parseFunctionCall(t, e) : this.peek() === "." ? this.parsePropertyAccess(t, e) : {
+      type: "Identifier",
+      name: t,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    }) : this.peek() === "[" ? this.parseArrayLiteral(e) : null;
+  }
+  /**
+   * Parse function calls with arguments
+   */
+  parseFunctionCall(e, t) {
+    this.advance(), this.skipWhitespace();
+    const i = [];
+    for (; !this.isAtEnd() && this.peek() !== ")"; ) {
+      const n = this.parseComplexExpression();
+      n && i.push(n), this.skipWhitespace(), this.peek() === "," && (this.advance(), this.skipWhitespace());
+    }
+    return this.peek() === ")" && this.advance(), {
+      type: "CallExpression",
+      callee: { type: "Identifier", name: e },
+      arguments: i,
+      loc: {
+        start: t,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse property access (obj.prop)
+   */
+  parsePropertyAccess(e, t) {
+    let i = e;
+    for (; this.peek() === "."; ) {
+      this.advance();
+      const n = this.parseIdentifier();
+      n && (i = `${i}.${n}`);
+    }
+    return {
+      type: "MemberExpression",
+      object: e,
+      property: i.split(".").slice(1).join("."),
+      loc: {
+        start: t,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse array literals [1, 2, 3]
+   */
+  parseArrayLiteral(e) {
+    this.advance(), this.skipWhitespace();
+    const t = [];
+    for (; !this.isAtEnd() && this.peek() !== "]"; ) {
+      const i = this.parseComplexExpression();
+      i && t.push(i), this.skipWhitespace(), this.peek() === "," && (this.advance(), this.skipWhitespace());
+    }
+    return this.peek() === "]" && this.advance(), {
+      type: "ArrayExpression",
+      elements: t,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  // Helper methods (reuse from basic parser with enhancements)
+  parseStringLiteral(e) {
+    const t = this.peek();
+    this.advance();
+    let i = "";
+    for (; !this.isAtEnd() && this.peek() !== t; )
+      if (this.peek() === "\\") {
+        this.advance();
+        const n = this.peek();
+        switch (n) {
+          case "n":
+            i += `
+`;
+            break;
+          case "t":
+            i += "	";
+            break;
+          case "r":
+            i += "\r";
+            break;
+          case "\\":
+            i += "\\";
+            break;
+          case '"':
+            i += '"';
+            break;
+          case "'":
+            i += "'";
+            break;
+          default:
+            i += n;
+            break;
+        }
+        this.advance();
+      } else
+        i += this.peek(), this.advance();
+    return this.peek() === t && this.advance(), {
+      type: "Literal",
+      value: i,
+      raw: this.code.slice(e.offset, this.position),
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  parseNumberLiteral(e) {
+    let t = "";
+    for (; !this.isAtEnd() && (this.isDigit(this.peek()) || this.peek() === "."); )
+      t += this.peek(), this.advance();
+    return {
+      type: "Literal",
+      value: t.includes(".") ? parseFloat(t) : parseInt(t, 10),
+      raw: t,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  parseIdentifier() {
+    if (!this.isAlpha(this.peek()) && this.peek() !== "_")
+      return null;
+    let e = "";
+    for (; !this.isAtEnd() && (this.isAlphaNumeric(this.peek()) || this.peek() === "_"); )
+      e += this.peek(), this.advance();
+    return e;
+  }
+  // Utility methods
+  isComponentStart() {
+    const e = this.position, t = this.line, i = this.column, n = this.parseIdentifier();
+    return this.position = e, this.line = t, this.column = i, n ? [
+      "VStack",
+      "HStack",
+      "ZStack",
+      "List",
+      "Form",
+      "NavigationStack",
+      "Text",
+      "Button",
+      "Image",
+      "TextField",
+      "Toggle",
+      "Slider",
+      // ScrollView moved to @tachui/mobile
+      "LazyVStack",
+      "LazyHStack"
+    ].includes(n) : !1;
+  }
+  match(e) {
+    return this.code.slice(this.position, this.position + e.length) === e ? (this.position += e.length, this.column += e.length, !0) : !1;
+  }
+  skipWhitespace() {
+    for (; !this.isAtEnd() && this.isWhitespace(this.peek()); )
+      this.peek() === `
+` ? (this.line++, this.column = 1) : this.column++, this.position++;
+  }
+  peek() {
+    return this.isAtEnd() ? "\0" : this.code[this.position];
+  }
+  advance() {
+    const e = this.peek();
+    return this.isAtEnd() || (this.position++, e === `
+` ? (this.line++, this.column = 1) : this.column++), e;
+  }
+  isAtEnd() {
+    return this.position >= this.code.length;
+  }
+  isWhitespace(e) {
+    return /\s/.test(e);
+  }
+  isAlpha(e) {
+    return /[a-zA-Z]/.test(e);
+  }
+  isDigit(e) {
+    return /[0-9]/.test(e);
+  }
+  isAlphaNumeric(e) {
+    return this.isAlpha(e) || this.isDigit(e);
+  }
+  currentPosition() {
+    return {
+      line: this.line,
+      column: this.column,
+      offset: this.position
+    };
+  }
+}
+function K(a, e) {
+  return new b(a, e).parse();
+}
+var v = Object.defineProperty, y = (a, e, t) => e in a ? v(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, m = (a, e, t) => y(a, typeof e != "symbol" ? e + "" : e, t);
+function x(a, e = {}) {
+  return new S(e).generate(a);
+}
+class S {
+  constructor(e) {
+    m(this, "options"), m(this, "imports", /* @__PURE__ */ new Set()), m(this, "variables", []), m(this, "code", []), m(this, "indentLevel", 0), this.options = e;
+  }
+  /**
+   * Generate complete code from AST nodes
+   */
+  generate(e) {
+    return this.reset(), this.addImport("createSignal", "@tachui/core/reactive"), this.addImport("createEffect", "@tachui/core/reactive"), this.addImport("createComputed", "@tachui/core/reactive"), e.forEach((i) => this.generateNode(i)), {
+      code: this.buildFinalCode(),
+      map: this.options.sourceMaps ? this.generateSourceMap() : void 0
+    };
+  }
+  /**
+   * Generate code for a single AST node
+   */
+  generateNode(e) {
+    switch (e.type) {
+      case "Component":
+        this.generateComponent(e);
+        break;
+      case "Concatenation":
+        this.generateConcatenationNode(e);
+        break;
+    }
+  }
+  /**
+   * Generate code for a component node
+   */
+  generateComponent(e) {
+    switch (e.name) {
+      case "VStack":
+      case "HStack":
+      case "ZStack":
+        this.generateStackComponent(e);
+        break;
+      case "Text":
+        this.generateTextComponent(e);
+        break;
+      case "Button":
+        this.generateButtonComponent(e);
+        break;
+      case "List":
+        this.generateListComponent(e);
+        break;
+      default:
+        this.generateGenericComponent(e);
+        break;
+    }
+  }
+  /**
+   * Generate code for stack components (VStack, HStack, ZStack)
+   */
+  generateStackComponent(e) {
+    const t = e.name.toLowerCase().replace("stack", ""), i = this.createVariable("container");
+    this.addLine(`// ${e.name} component`), this.addLine(`const ${i} = document.createElement('div')`), this.addLine(
+      `${i}.className = 'tachui-${t} ${this.generateStackClasses(e.name)}'`
+    );
+    const n = this.generateModifierStyles(e.modifiers);
+    n.length > 0 && (this.addLine(`Object.assign(${i}.style, {`), this.indent(), n.forEach((s) => this.addLine(`${s},`)), this.dedent(), this.addLine("})")), e.children.forEach((s) => {
+      this.generateNode(s);
+      const r = this.getLastVariable();
+      r && this.addLine(`${i}.appendChild(${r})`);
+    }), this.addEmptyLine();
+  }
+  /**
+   * Generate code for Text component
+   */
+  generateTextComponent(e) {
+    const t = this.createVariable("textElement"), i = this.getTextContent(e.children);
+    this.addLine("// Text component"), this.addLine(`const ${t} = document.createElement('span')`), this.addLine(`${t}.className = 'tachui-text'`), this.isReactiveExpression(i) ? (this.addLine("createEffect(() => {"), this.indent(), this.addLine(`${t}.textContent = ${i}`), this.dedent(), this.addLine("})")) : this.addLine(`${t}.textContent = ${i}`);
+    const n = this.generateModifierStyles(e.modifiers);
+    n.length > 0 && (this.addLine(`Object.assign(${t}.style, {`), this.indent(), n.forEach((s) => this.addLine(`${s},`)), this.dedent(), this.addLine("})")), this.addEmptyLine();
+  }
+  /**
+   * Generate code for Button component
+   */
+  generateButtonComponent(e) {
+    const t = this.createVariable("buttonElement"), i = this.getTextContent(e.children);
+    this.addLine("// Button component"), this.addLine(`const ${t} = document.createElement('button')`), this.addLine(`${t}.className = 'tachui-button'`), this.addLine(`${t}.textContent = ${i}`);
+    const n = this.generateModifierStyles(e.modifiers), s = this.generateEventHandlers(e.modifiers);
+    n.length > 0 && (this.addLine(`Object.assign(${t}.style, {`), this.indent(), n.forEach((r) => this.addLine(`${r},`)), this.dedent(), this.addLine("})")), s.forEach((r) => this.addLine(r)), this.addEmptyLine();
+  }
+  /**
+   * Generate code for List component
+   */
+  generateListComponent(e) {
+    const t = this.createVariable("listElement");
+    this.addLine("// List component"), this.addLine(`const ${t} = document.createElement('div')`), this.addLine(`${t}.className = 'tachui-list'`), e.children.forEach((i) => {
+      this.generateNode(i);
+      const n = this.getLastVariable();
+      n && this.addLine(`${t}.appendChild(${n})`);
+    }), this.addEmptyLine();
+  }
+  /**
+   * Generate code for generic/custom components
+   */
+  generateGenericComponent(e) {
+    const t = this.createVariable("element");
+    this.addLine(`// ${e.name} component`), this.addLine(`const ${t} = document.createElement('div')`), this.addLine(
+      `${t}.className = 'tachui-${e.name.toLowerCase()}'`
+    );
+    const i = this.generateModifierStyles(e.modifiers);
+    i.length > 0 && (this.addLine(`Object.assign(${t}.style, {`), this.indent(), i.forEach((n) => this.addLine(`${n},`)), this.dedent(), this.addLine("})")), this.addEmptyLine();
+  }
+  /**
+   * Generate code for a concatenation node
+   */
+  generateConcatenationNode(e) {
+    e.optimizable && e.staticContent ? this.generateOptimizedConcatenation(e) : this.generateRuntimeConcatenation(e);
+  }
+  /**
+   * Generate optimized static concatenation code
+   */
+  generateOptimizedConcatenation(e) {
+    const t = this.createVariable("optimizedConcat");
+    if (this.addLine("// Optimized static concatenation"), this.addLine(`const ${t} = document.createElement('span')`), this.addLine(`${t}.className = 'tachui-concatenated-optimized'`), e.staticContent) {
+      const i = e.staticContent.segments.map((s) => s.content || "").join("");
+      i && this.addLine(`${t}.textContent = "${i}"`);
+      const n = this.mergeConcatenationStyles(
+        e.staticContent.segments
+      );
+      Object.keys(n).length > 0 && (this.addLine(`Object.assign(${t}.style, {`), this.indent(), Object.entries(n).forEach(([s, r]) => {
+        this.addLine(`${s}: "${r}",`);
+      }), this.dedent(), this.addLine("})")), e.staticContent.aria.label && this.addLine(
+        `${t}.setAttribute('aria-label', "${e.staticContent.aria.label}")`
+      ), e.staticContent.aria.role && e.staticContent.aria.role !== "text" && this.addLine(
+        `${t}.setAttribute('role', "${e.staticContent.aria.role}")`
+      );
+    }
+    this.addEmptyLine();
+  }
+  /**
+   * Generate runtime concatenation fallback
+   */
+  generateRuntimeConcatenation(e) {
+    const t = this.createVariable("runtimeConcat"), i = this.determineARIARequirement(e), n = i ? "SmartARIAConcatenatedComponent" : "MinimalConcatenatedComponent", s = i ? "@tachui/core/concatenation/smart-aria" : "@tachui/core/concatenation/minimal";
+    this.addImport(n, s), this.addLine(
+      `// Dynamic concatenation - using ${i ? "Smart ARIA" : "minimal"} runtime`
+    ), this.addLine(`const ${t} = new ${n}([`), this.indent(), this.generateComponentInline(e.left);
+    const r = this.getLastVariable();
+    if (this.addLine(
+      `{ id: '${e.left.name}-left', component: ${r}, modifiers: [], render: () => ${r} },`
+    ), e.right.type === "Component") {
+      this.generateComponentInline(e.right);
+      const o = this.getLastVariable();
+      this.addLine(
+        `{ id: '${e.right.name}-right', component: ${o}, modifiers: [], render: () => ${o} }`
+      );
+    } else {
+      this.generateConcatenationNode(e.right);
+      const o = this.getLastVariable();
+      this.addLine(`${o}.toSegment()`);
+    }
+    this.dedent(), this.addLine("])"), this.addEmptyLine();
+  }
+  /**
+   * Generate a component inline without creating separate variable
+   */
+  generateComponentInline(e) {
+    switch (e.name) {
+      case "Text":
+        this.generateTextComponent(e);
+        break;
+      case "Button":
+        this.generateButtonComponent(e);
+        break;
+      default:
+        this.generateGenericComponent(e);
+        break;
+    }
+  }
+  /**
+   * Determine if concatenation needs ARIA runtime
+   */
+  determineARIARequirement(e) {
+    return this.hasInteractiveComponents(e.left) || (e.right.type === "Component" ? this.hasInteractiveComponents(e.right) : e.right.optimizable === !1);
+  }
+  /**
+   * Check if component is interactive (Button, Link, etc.)
+   */
+  hasInteractiveComponents(e) {
+    return e.name === "Button" || e.name === "Link" || e.children.some(
+      (t) => t.type === "Component" && this.hasInteractiveComponents(t)
+    );
+  }
+  /**
+   * Merge styles from multiple concatenated segments
+   */
+  mergeConcatenationStyles(e) {
+    const t = {};
+    return e.forEach((i) => {
+      i.styles && Object.assign(t, i.styles);
+    }), t;
+  }
+  /**
+   * Generate CSS classes for stack layouts
+   */
+  generateStackClasses(e) {
+    switch (e) {
+      case "VStack":
+        return "flex flex-col";
+      case "HStack":
+        return "flex flex-row";
+      case "ZStack":
+        return "relative";
+      default:
+        return "flex";
+    }
+  }
+  /**
+   * Generate styles from modifiers
+   */
+  generateModifierStyles(e) {
+    const t = [];
+    return e.forEach((i) => {
+      const n = this.convertModifierToStyle(i);
+      n && t.push(n);
+    }), t;
+  }
+  /**
+   * Generate event handlers from modifiers
+   */
+  generateEventHandlers(e) {
+    const t = [];
+    return e.forEach((i) => {
+      if (i.name === "onTapGesture" && i.arguments.length > 0) {
+        const n = this.expressionToString(i.arguments[0]);
+        t.push(
+          `${this.getLastVariable()}.addEventListener('click', ${n})`
+        );
+      }
+    }), t;
+  }
+  /**
+   * Convert modifier to CSS style property
+   */
+  convertModifierToStyle(e) {
+    const t = e.arguments;
+    switch (e.name) {
+      case "padding":
+        return `padding: ${t.length > 0 ? this.expressionToString(t[0]) : '"8px"'}`;
+      case "background":
+        if (t.length > 0)
+          return `backgroundColor: ${this.expressionToString(t[0])}`;
+        break;
+      case "foregroundColor":
+        if (t.length > 0)
+          return `color: ${this.expressionToString(t[0])}`;
+        break;
+      case "font":
+        if (t.length > 0)
+          return `fontSize: ${this.expressionToString(t[0])}`;
+        break;
+      case "cornerRadius":
+        if (t.length > 0)
+          return `borderRadius: ${this.expressionToString(t[0])}px`;
+        break;
+      case "opacity":
+        if (t.length > 0)
+          return `opacity: ${this.expressionToString(t[0])}`;
+        break;
+      case "frame":
+        if (t.length >= 2)
+          return null;
+        break;
+    }
+    return null;
+  }
+  /**
+   * Helper methods
+   */
+  getTextContent(e) {
+    if (e.length === 0) return '""';
+    const t = e[0];
+    return t.type === "Literal" ? `"${t.value}"` : this.expressionToString(t);
+  }
+  expressionToString(e) {
+    switch (e.type) {
+      case "Literal": {
+        const t = e;
+        return typeof t.value == "string" ? `"${t.value}"` : String(t.value);
+      }
+      case "Identifier":
+        return e.name;
+      default:
+        return '""';
+    }
+  }
+  isReactiveExpression(e) {
+    return e.includes("()") || !e.startsWith('"') && !e.match(/^\d+$/);
+  }
+  createVariable(e) {
+    const t = `${e}${this.variables.length + 1}`;
+    return this.variables.push(t), t;
+  }
+  getLastVariable() {
+    return this.variables.length > 0 ? this.variables[this.variables.length - 1] : null;
+  }
+  addImport(e, t) {
+    this.imports.add(`import { ${e} } from '${t}'`);
+  }
+  addLine(e) {
+    const t = "  ".repeat(this.indentLevel);
+    this.code.push(t + e);
+  }
+  addEmptyLine() {
+    this.code.push("");
+  }
+  indent() {
+    this.indentLevel++;
+  }
+  dedent() {
+    this.indentLevel = Math.max(0, this.indentLevel - 1);
+  }
+  buildFinalCode() {
+    const e = Array.from(this.imports).join(`
+`), t = this.code.join(`
+`);
+    return `${e}
+
+${t}`;
+  }
+  generateSourceMap() {
+    return null;
+  }
+  reset() {
+    this.imports.clear(), this.variables = [], this.code = [], this.indentLevel = 0;
+  }
+}
+var w = Object.defineProperty, A = (a, e, t) => e in a ? w(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, p = (a, e, t) => A(a, typeof e != "symbol" ? e + "" : e, t);
+class T {
+  constructor(e) {
+    p(this, "options"), p(this, "imports", /* @__PURE__ */ new Set()), p(this, "variables", []), p(this, "code", []), p(this, "indentLevel", 0), p(this, "dependencies", /* @__PURE__ */ new Set()), p(this, "exports", /* @__PURE__ */ new Set()), this.options = e;
+  }
+  /**
+   * Generate enhanced reactive DOM code from AST
+   */
+  generate(e) {
+    return this.reset(), this.addImport(
+      "createSignal, createEffect, createComputed, createRoot, batch",
+      "@tachui/core/reactive"
+    ), e.forEach((i) => this.generateEnhancedNode(i)), this.generateMountFunction(), {
+      code: this.buildFinalCode(),
+      map: this.options.sourceMaps ? this.generateSourceMap() : void 0,
+      dependencies: Array.from(this.dependencies),
+      exports: Array.from(this.exports)
+    };
+  }
+  /**
+   * Generate code for enhanced AST nodes
+   */
+  generateEnhancedNode(e) {
+    switch (e.type) {
+      case "Component":
+        this.generateEnhancedComponent(e);
+        break;
+      case "Conditional":
+        this.generateConditionalRendering(e);
+        break;
+      case "ForEach":
+        this.generateListRendering(e);
+        break;
+      case "PropertyWrapper":
+        this.generatePropertyWrapper(e);
+        break;
+      case "StateBinding":
+        this.generateStateBinding(e);
+        break;
+    }
+  }
+  /**
+   * Generate conditional rendering with reactive effects
+   */
+  generateConditionalRendering(e) {
+    const t = this.createVariable("condition"), i = this.createVariable("conditionalContainer");
+    this.addLine("// Conditional rendering"), this.addLine(`const ${i} = document.createElement('div')`), this.addLine(`${i}.className = 'tachui-conditional'`);
+    const n = this.expressionToCode(e.condition);
+    this.addLine(`const ${t} = createComputed(() => ${n})`), this.addLine("createEffect(() => {"), this.indent(), this.addLine("// Clear previous content"), this.addLine(`${i}.innerHTML = ''`), this.addEmptyLine(), this.addLine(`if (${t}()) {`), this.indent(), this.addLine("// Render then body"), e.thenBody.forEach((s) => {
+      this.generateEnhancedNode(s);
+      const r = this.getLastVariable();
+      r && this.addLine(`${i}.appendChild(${r})`);
+    }), this.dedent(), e.elseBody && e.elseBody.length > 0 && (this.addLine("} else {"), this.indent(), this.addLine("// Render else body"), e.elseBody.forEach((s) => {
+      this.generateEnhancedNode(s);
+      const r = this.getLastVariable();
+      r && this.addLine(`${i}.appendChild(${r})`);
+    }), this.dedent()), this.addLine("}"), this.dedent(), this.addLine("})"), this.addEmptyLine();
+  }
+  /**
+   * Generate list rendering with keyed updates
+   */
+  generateListRendering(e) {
+    const t = this.createVariable("listContainer"), i = this.createVariable("items"), n = this.createVariable("renderedItems");
+    this.addLine("// List rendering with keyed updates"), this.addLine(`const ${t} = document.createElement('div')`), this.addLine(`${t}.className = 'tachui-list'`), this.addLine(`let ${n} = new Map()`);
+    const s = this.expressionToCode(e.iterable);
+    if (this.addLine(`const ${i} = createComputed(() => ${s})`), this.addLine("createEffect(() => {"), this.indent(), this.addLine(`const currentItems = ${i}()`), this.addLine("const newRenderedItems = new Map()"), this.addEmptyLine(), this.addLine("// Update existing items and create new ones"), this.addLine(`currentItems.forEach((${e.itemIdentifier}, index) => {`), this.indent(), this.options.generateKeyedLists) {
+      this.addLine(`const key = ${e.itemIdentifier}.id || index`), this.addLine(`let itemElement = ${n}.get(key)`), this.addEmptyLine(), this.addLine("if (!itemElement) {"), this.indent(), this.addLine("// Create new item element"), this.generateListItemContent(e);
+      const r = this.getLastVariable();
+      this.addLine(`itemElement = ${r}`), this.dedent(), this.addLine("}"), this.addEmptyLine(), this.addLine("newRenderedItems.set(key, itemElement)"), this.addLine(`${t}.appendChild(itemElement)`);
+    } else {
+      this.addLine("// Simple list item generation"), this.generateListItemContent(e);
+      const r = this.getLastVariable();
+      this.addLine(`${t}.appendChild(${r})`);
+    }
+    this.dedent(), this.addLine("})"), this.addEmptyLine(), this.options.generateKeyedLists && (this.addLine("// Remove items that are no longer in the list"), this.addLine(`${n}.forEach((element, key) => {`), this.indent(), this.addLine("if (!newRenderedItems.has(key)) {"), this.indent(), this.addLine("element.remove()"), this.dedent(), this.addLine("}"), this.dedent(), this.addLine("})"), this.addEmptyLine(), this.addLine(`${n} = newRenderedItems`)), this.dedent(), this.addLine("})"), this.addEmptyLine();
+  }
+  /**
+   * Generate content for list items
+   */
+  generateListItemContent(e) {
+    this.addLine("// List item content"), e.body.forEach((t) => {
+      this.generateEnhancedNode(t);
+    });
+  }
+  /**
+   * Generate property wrapper code
+   */
+  generatePropertyWrapper(e) {
+    const { wrapper: t, identifier: i, initialValue: n } = e;
+    switch (this.addLine(`// @${t} property wrapper`), t) {
+      case "State": {
+        const s = n ? this.expressionToCode(n) : "undefined";
+        this.addLine(
+          `const [${i}, set${this.capitalize(i)}] = createSignal(${s})`
+        ), this.dependencies.add(i);
+        break;
+      }
+      case "Computed":
+        if (n) {
+          const s = this.expressionToCode(n);
+          this.addLine(`const ${i} = createComputed(() => ${s})`), this.dependencies.add(i);
+        }
+        break;
+      case "Effect":
+        if (n) {
+          const s = this.expressionToCode(n);
+          this.addLine(`const ${i} = createEffect(() => ${s})`);
+        }
+        break;
+    }
+    this.addEmptyLine();
+  }
+  /**
+   * Generate state binding code
+   */
+  generateStateBinding(e) {
+    this.addLine(`// State binding: $${e.identifier}`), this.addLine(`const ${e.identifier}Binding = {`), this.indent(), this.addLine(`get: () => ${e.identifier}(),`), this.addLine(`set: set${this.capitalize(e.identifier)}`), this.dedent(), this.addLine("}"), this.addEmptyLine();
+  }
+  /**
+   * Generate enhanced component with reactive features
+   */
+  generateEnhancedComponent(e) {
+    switch (e.name) {
+      case "VStack":
+      case "HStack":
+      case "ZStack":
+        this.generateEnhancedStackComponent(e);
+        break;
+      case "Text":
+        this.generateEnhancedTextComponent(e);
+        break;
+      case "Button":
+        this.generateEnhancedButtonComponent(e);
+        break;
+      case "TextField":
+        this.generateEnhancedTextFieldComponent(e);
+        break;
+      default:
+        this.generateEnhancedGenericComponent(e);
+        break;
+    }
+  }
+  /**
+   * Generate enhanced stack component with reactive children
+   */
+  generateEnhancedStackComponent(e) {
+    const t = e.name.toLowerCase().replace("stack", ""), i = this.createVariable("container");
+    this.addLine(`// Enhanced ${e.name} component`), this.addLine(`const ${i} = document.createElement('div')`), this.addLine(
+      `${i}.className = 'tachui-${t} ${this.generateStackClasses(e.name)}'`
+    ), this.addLine("// Reactive children management"), e.children.forEach((n) => {
+      this.generateEnhancedNode(n);
+      const s = this.getLastVariable();
+      s && this.addLine(`${i}.appendChild(${s})`);
+    }), this.generateEnhancedModifiers(e.modifiers, i), this.addEmptyLine();
+  }
+  /**
+   * Generate enhanced text component with reactive content
+   */
+  generateEnhancedTextComponent(e) {
+    const t = this.createVariable("textElement"), i = this.getTextContent(e.children);
+    this.addLine("// Enhanced Text component"), this.addLine(`const ${t} = document.createElement('span')`), this.addLine(`${t}.className = 'tachui-text'`), this.isReactiveExpression(i) ? (this.addLine("createEffect(() => {"), this.indent(), this.addLine(`${t}.textContent = String(${i})`), this.dedent(), this.addLine("})")) : this.addLine(`${t}.textContent = ${i}`), this.generateEnhancedModifiers(e.modifiers, t), this.addEmptyLine();
+  }
+  /**
+   * Generate enhanced button component
+   */
+  generateEnhancedButtonComponent(e) {
+    const t = this.createVariable("buttonElement"), i = this.getTextContent(e.children);
+    this.addLine("// Enhanced Button component"), this.addLine(`const ${t} = document.createElement('button')`), this.addLine(`${t}.className = 'tachui-button'`), this.isReactiveExpression(i) ? (this.addLine("createEffect(() => {"), this.indent(), this.addLine(`${t}.textContent = String(${i})`), this.dedent(), this.addLine("})")) : this.addLine(`${t}.textContent = ${i}`), this.generateEnhancedModifiers(e.modifiers, t), this.addEmptyLine();
+  }
+  /**
+   * Generate enhanced TextField component with two-way binding
+   */
+  generateEnhancedTextFieldComponent(e) {
+    const t = this.createVariable("textFieldElement"), i = e.children.length > 0 ? this.getTextContent([e.children[0]]) : '""';
+    this.addLine("// Enhanced TextField component"), this.addLine(`const ${t} = document.createElement('input')`), this.addLine(`${t}.type = 'text'`), this.addLine(`${t}.className = 'tachui-textfield'`), this.addLine(`${t}.placeholder = ${i}`);
+    const n = e.children.find((s) => s.type === "StateBinding");
+    n && (this.addLine("// Two-way data binding"), this.addLine("createEffect(() => {"), this.indent(), this.addLine(`${t}.value = String(${n.identifier}() || '')`), this.dedent(), this.addLine("})"), this.addLine(`${t}.addEventListener('input', (e) => {`), this.indent(), this.addLine(`set${this.capitalize(n.identifier)}(e.target.value)`), this.dedent(), this.addLine("})")), this.generateEnhancedModifiers(e.modifiers, t), this.addEmptyLine();
+  }
+  /**
+   * Generate enhanced generic component
+   */
+  generateEnhancedGenericComponent(e) {
+    const t = this.createVariable("element");
+    this.addLine(`// Enhanced ${e.name} component`), this.addLine(`const ${t} = document.createElement('div')`), this.addLine(`${t}.className = 'tachui-${e.name.toLowerCase()}'`), e.children.forEach((i) => {
+      this.generateEnhancedNode(i);
+      const n = this.getLastVariable();
+      n && this.addLine(`${t}.appendChild(${n})`);
+    }), this.generateEnhancedModifiers(e.modifiers, t), this.addEmptyLine();
+  }
+  /**
+   * Generate enhanced modifiers with reactive updates
+   */
+  generateEnhancedModifiers(e, t) {
+    if (e.length === 0) return;
+    const i = [], n = [], s = [];
+    e.forEach((r) => {
+      const o = this.convertModifierToStyle(r);
+      o && (this.modifierHasReactiveContent(r) ? n.push(o) : i.push(o));
+      const h = this.convertModifierToHandler(r, t);
+      h && s.push(h);
+    }), i.length > 0 && (this.addLine(`Object.assign(${t}.style, {`), this.indent(), i.forEach((r) => this.addLine(`${r},`)), this.dedent(), this.addLine("})")), n.length > 0 && (this.addLine("createEffect(() => {"), this.indent(), this.addLine(`Object.assign(${t}.style, {`), this.indent(), n.forEach((r) => this.addLine(`${r},`)), this.dedent(), this.addLine("})"), this.dedent(), this.addLine("})")), s.forEach((r) => this.addLine(r));
+  }
+  /**
+   * Generate component mount function
+   */
+  generateMountFunction() {
+    if (this.addLine("// Component mount function"), this.addLine("export function mountComponent(container) {"), this.indent(), this.addLine("return createRoot(() => {"), this.indent(), this.variables.length > 0) {
+      const e = this.variables[this.variables.length - 1];
+      this.addLine(`container.appendChild(${e})`), this.addLine(`return () => container.removeChild(${e})`);
+    }
+    this.dedent(), this.addLine("})"), this.dedent(), this.addLine("}"), this.exports.add("mountComponent");
+  }
+  /**
+   * Helper methods
+   */
+  expressionToCode(e) {
+    switch (e.type) {
+      case "Literal": {
+        const t = e;
+        return typeof t.value == "string" ? `"${t.value}"` : String(t.value);
+      }
+      case "Identifier":
+        return e.name;
+      case "CallExpression": {
+        const t = e, i = t.arguments.map((n) => this.expressionToCode(n)).join(", ");
+        return `${this.expressionToCode(t.callee)}(${i})`;
+      }
+      case "MemberExpression": {
+        const t = e;
+        return `${t.object}.${t.property}`;
+      }
+      case "ArrayExpression":
+        return `[${e.elements.map((n) => this.expressionToCode(n)).join(", ")}]`;
+      default:
+        return '""';
+    }
+  }
+  getTextContent(e) {
+    if (e.length === 0) return '""';
+    const t = e[0];
+    return t.type === "Literal" || t.type === "Identifier" || t.type === "CallExpression" || t.type === "MemberExpression" || t.type === "ArrayExpression" ? this.expressionToCode(t) : '""';
+  }
+  isReactiveExpression(e) {
+    return e.includes("()") || e.includes("get") || !e.startsWith('"') && !e.match(/^\d+$/);
+  }
+  modifierHasReactiveContent(e) {
+    return e.arguments.some((t) => {
+      const i = this.expressionToCode(t);
+      return this.isReactiveExpression(i);
+    });
+  }
+  convertModifierToStyle(e) {
+    const t = e.arguments;
+    switch (e.name) {
+      case "padding":
+        return `padding: ${t.length > 0 ? this.expressionToCode(t[0]) : '"8px"'}`;
+      case "background":
+        if (t.length > 0)
+          return `backgroundColor: ${this.expressionToCode(t[0])}`;
+        break;
+      case "foregroundColor":
+        if (t.length > 0)
+          return `color: ${this.expressionToCode(t[0])}`;
+        break;
+      case "font":
+        if (t.length > 0)
+          return `fontSize: ${this.expressionToCode(t[0])}`;
+        break;
+      case "cornerRadius":
+        if (t.length > 0)
+          return `borderRadius: ${this.expressionToCode(t[0])}px`;
+        break;
+      case "opacity":
+        if (t.length > 0)
+          return `opacity: ${this.expressionToCode(t[0])}`;
+        break;
+    }
+    return null;
+  }
+  convertModifierToHandler(e, t) {
+    if (e.name === "onTapGesture" && e.arguments.length > 0) {
+      const i = this.expressionToCode(e.arguments[0]);
+      return `${t}.addEventListener('click', ${i})`;
+    }
+    return null;
+  }
+  generateStackClasses(e) {
+    switch (e) {
+      case "VStack":
+        return "flex flex-col";
+      case "HStack":
+        return "flex flex-row";
+      case "ZStack":
+        return "relative";
+      default:
+        return "flex";
+    }
+  }
+  capitalize(e) {
+    return e.charAt(0).toUpperCase() + e.slice(1);
+  }
+  createVariable(e) {
+    const t = `${e}${this.variables.length + 1}`;
+    return this.variables.push(t), t;
+  }
+  getLastVariable() {
+    return this.variables.length > 0 ? this.variables[this.variables.length - 1] : null;
+  }
+  addImport(e, t) {
+    this.imports.add(`import { ${e} } from '${t}'`);
+  }
+  addLine(e) {
+    const t = "  ".repeat(this.indentLevel);
+    this.code.push(t + e);
+  }
+  addEmptyLine() {
+    this.code.push("");
+  }
+  indent() {
+    this.indentLevel++;
+  }
+  dedent() {
+    this.indentLevel = Math.max(0, this.indentLevel - 1);
+  }
+  buildFinalCode() {
+    const e = Array.from(this.imports).join(`
+`), t = this.code.join(`
+`);
+    return `${e}
+
+${t}`;
+  }
+  generateSourceMap() {
+    return null;
+  }
+  reset() {
+    this.imports.clear(), this.variables = [], this.code = [], this.indentLevel = 0, this.dependencies.clear(), this.exports.clear();
+  }
+}
+function X(a, e = {}) {
+  return new T(e).generate(a);
+}
+var I = Object.defineProperty, V = (a, e, t) => e in a ? I(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t, f = (a, e, t) => V(a, typeof e != "symbol" ? e + "" : e, t);
+function P(a, e) {
+  return new W(a, e).parse();
+}
+class W {
+  constructor(e, t) {
+    f(this, "code"), f(this, "filename"), f(this, "position", 0), f(this, "line", 1), f(this, "column", 1), this.code = e, this.filename = t;
+  }
+  /**
+   * Main parsing entry point
+   */
+  parse() {
+    const e = [];
+    for (; !this.isAtEnd() && (this.skipWhitespace(), !this.isAtEnd()); ) {
+      const t = this.parseNode();
+      t && e.push(t);
+    }
+    return e;
+  }
+  /**
+   * Parse a single AST node
+   */
+  parseNode() {
+    const e = this.currentPosition();
+    return this.isComponentStart() ? this.parseComponent(e) : (this.advance(), null);
+  }
+  /**
+   * Parse a SwiftUI component (VStack, Text, Button, etc.)
+   */
+  parseComponent(e) {
+    const t = this.parseIdentifier();
+    if (!t)
+      throw new Error(`Expected component name at line ${this.line}`);
+    this.skipWhitespace();
+    const i = [], n = [];
+    if (this.peek() === "{") {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== "}"; ) {
+        this.skipWhitespace();
+        const r = this.parseNode();
+        r && i.push(r);
+      }
+      this.peek() === "}" && this.advance();
+    } else if (this.peek() === "(") {
+      this.advance(), this.skipWhitespace();
+      const r = this.parseExpression();
+      r && i.push(r), this.skipWhitespace(), this.peek() === ")" && this.advance();
+    }
+    for (this.skipWhitespace(); this.peek() === "."; ) {
+      const r = this.parseModifier();
+      r && n.push(r), this.skipWhitespace();
+    }
+    const s = this.currentPosition();
+    return {
+      type: "Component",
+      name: t,
+      children: i,
+      modifiers: n,
+      loc: {
+        start: e,
+        end: s,
+        source: this.filename
+      }
+    };
+  }
+  // Concatenation optimization methods moved to post-processing functions
+  /**
+   * Parse a modifier (.padding(), .background(), etc.)
+   */
+  parseModifier() {
+    if (this.peek() !== ".") return null;
+    const e = this.currentPosition();
+    this.advance();
+    const t = this.parseIdentifier();
+    if (!t) return null;
+    const i = [];
+    if (this.peek() === "(") {
+      for (this.advance(), this.skipWhitespace(); !this.isAtEnd() && this.peek() !== ")"; ) {
+        const s = this.parseExpression();
+        s && i.push(s), this.skipWhitespace(), this.peek() === "," && (this.advance(), this.skipWhitespace());
+      }
+      this.peek() === ")" && this.advance();
+    }
+    const n = this.currentPosition();
+    return {
+      type: "Modifier",
+      name: t,
+      arguments: i,
+      loc: {
+        start: e,
+        end: n,
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse an expression (literal, identifier, function call)
+   */
+  parseExpression() {
+    this.skipWhitespace();
+    const e = this.currentPosition();
+    if (this.peek() === '"' || this.peek() === "'")
+      return this.parseStringLiteral(e);
+    if (this.isDigit(this.peek()))
+      return this.parseNumberLiteral(e);
+    if (this.match("true") || this.match("false")) {
+      const i = this.code.slice(e.offset, this.position);
+      return {
+        type: "Literal",
+        value: i === "true",
+        raw: i,
+        loc: {
+          start: e,
+          end: this.currentPosition(),
+          source: this.filename
+        }
+      };
+    }
+    const t = this.parseIdentifier();
+    if (t) {
+      const i = this.currentPosition();
+      return {
+        type: "Identifier",
+        name: t,
+        loc: {
+          start: e,
+          end: i,
+          source: this.filename
+        }
+      };
+    }
+    return null;
+  }
+  /**
+   * Parse a string literal
+   */
+  parseStringLiteral(e) {
+    const t = this.peek();
+    this.advance();
+    let i = "";
+    for (; !this.isAtEnd() && this.peek() !== t; )
+      if (this.peek() === "\\") {
+        this.advance();
+        const s = this.peek();
+        switch (s) {
+          case "n":
+            i += `
+`;
+            break;
+          case "t":
+            i += "	";
+            break;
+          case "r":
+            i += "\r";
+            break;
+          case "\\":
+            i += "\\";
+            break;
+          case '"':
+            i += '"';
+            break;
+          case "'":
+            i += "'";
+            break;
+          default:
+            i += s;
+            break;
+        }
+        this.advance();
+      } else
+        i += this.peek(), this.advance();
+    this.peek() === t && this.advance();
+    const n = this.code.slice(e.offset, this.position);
+    return {
+      type: "Literal",
+      value: i,
+      raw: n,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse a number literal
+   */
+  parseNumberLiteral(e) {
+    let t = "";
+    for (; !this.isAtEnd() && (this.isDigit(this.peek()) || this.peek() === "."); )
+      t += this.peek(), this.advance();
+    return {
+      type: "Literal",
+      value: t.includes(".") ? parseFloat(t) : parseInt(t, 10),
+      raw: t,
+      loc: {
+        start: e,
+        end: this.currentPosition(),
+        source: this.filename
+      }
+    };
+  }
+  /**
+   * Parse an identifier (component name, variable name, etc.)
+   */
+  parseIdentifier() {
+    if (!this.isAlpha(this.peek()) && this.peek() !== "_")
+      return null;
+    let e = "";
+    for (; !this.isAtEnd() && (this.isAlphaNumeric(this.peek()) || this.peek() === "_"); )
+      e += this.peek(), this.advance();
+    return e;
+  }
+  /**
+   * Helper methods
+   */
+  isComponentStart() {
+    const e = this.position, t = this.line, i = this.column, n = this.parseIdentifier(), s = n && this.isValidComponentName(n);
+    return this.position = e, this.line = t, this.column = i, !!s;
+  }
+  isValidComponentName(e) {
+    return [
+      "VStack",
+      "HStack",
+      "ZStack",
+      "List",
+      "Form",
+      "Text",
+      "Button",
+      "Image",
+      "TextField",
+      "Toggle"
+    ].includes(e);
+  }
+  skipWhitespace() {
+    for (; !this.isAtEnd() && this.isWhitespace(this.peek()); )
+      this.peek() === `
+` ? (this.line++, this.column = 1) : this.column++, this.position++;
+  }
+  match(e) {
+    return this.code.slice(this.position, this.position + e.length) === e ? (this.position += e.length, this.column += e.length, !0) : !1;
+  }
+  peek() {
+    return this.isAtEnd() ? "\0" : this.code[this.position];
+  }
+  advance() {
+    const e = this.peek();
+    return this.isAtEnd() || (this.position++, e === `
+` ? (this.line++, this.column = 1) : this.column++), e;
+  }
+  isAtEnd() {
+    return this.position >= this.code.length;
+  }
+  isWhitespace(e) {
+    return /\s/.test(e);
+  }
+  isAlpha(e) {
+    return /[a-zA-Z]/.test(e);
+  }
+  isDigit(e) {
+    return /[0-9]/.test(e);
+  }
+  isAlphaNumeric(e) {
+    return this.isAlpha(e) || this.isDigit(e);
+  }
+  currentPosition() {
+    return {
+      line: this.line,
+      column: this.column,
+      offset: this.position
+    };
+  }
+}
+function J(a = {}) {
+  const {
+    include: e = [".tsx", ".ts"],
+    exclude: t = ["node_modules/**", "**/*.test.*", "**/*.bench.*"],
+    dev: i = process.env.NODE_ENV === "development",
+    transform: n = {}
+  } = a;
+  return {
+    name: "tachui-transform",
+    enforce: "pre",
+    // Run before other plugins
+    configResolved(s) {
+      i && s.command === "serve" && console.log("🚀 TachUI plugin loaded in development mode");
+    },
+    buildStart() {
+      this.addWatchFile("tachui.config.ts");
+    },
+    resolveId(s) {
+      return s === "virtual:tachui-runtime" ? s : null;
+    },
+    load(s) {
+      return s === "virtual:tachui-runtime" ? q() : null;
+    },
+    transform(s, r) {
+      if (!Z(r, e, t))
+        return null;
+      try {
+        let o = s, h = !1;
+        const d = N(s, r);
+        if (d.length > 0) {
+          const c = R(
+            d,
+            r
+          );
+          z(c, r, i), o = U(
+            o,
+            d
+          ), h = !0, i && (global.__tachui_optimization_data = global.__tachui_optimization_data || [], global.__tachui_optimization_data.push({
+            filename: r,
+            patterns: d,
+            report: c,
+            timestamp: Date.now()
+          }));
+        }
+        if (G(o)) {
+          i && d.length === 0 && console.log(`🔄 Transforming SwiftUI syntax: ${r}`);
+          const c = P(o, r), g = x(c, {
+            ...n,
+            sourceFile: r,
+            sourceMaps: n.sourceMaps ?? i
+          });
+          return {
+            code: g.code,
+            map: g.map
+          };
+        }
+        return h ? {
+          code: o,
+          map: null
+          // TODO: Generate source maps for concatenation transformations
+        } : null;
+      } catch (o) {
+        const h = o instanceof Error ? o.message : String(o);
+        return this.error(`TachUI transformation failed in ${r}: ${h}`), null;
+      }
+    },
+    handleHotUpdate(s) {
+      if (s.file.endsWith(".tui.tsx") || s.file.endsWith(".tui.ts"))
+        return s.server.ws.send({
+          type: "full-reload"
+        }), [];
+    }
+  };
+}
+function N(a, e) {
+  const t = [];
+  try {
+    let i = function(s) {
+      if (l.isCallExpression(s) && l.isPropertyAccessExpression(s.expression) && s.expression.name.text === "concat") {
+        const r = s.expression.expression;
+        if (l.isCallExpression(r) && l.isPropertyAccessExpression(r.expression) && r.expression.name.text === "build") {
+          const o = r.expression.expression, h = k(o, a), d = s.arguments.length > 0 ? k(s.arguments[0], a) : "";
+          if (h && d) {
+            const c = s.getStart(n), g = s.getEnd(), L = O(
+              h,
+              d
+            ), C = H(
+              h,
+              d,
+              a
+            );
+            t.push({
+              type: L ? "static" : "dynamic",
+              location: { start: c, end: g },
+              leftComponent: h.trim(),
+              rightComponent: d.trim(),
+              optimizable: L,
+              accessibilityNeeds: C
+            });
+          }
+        }
+      }
+      l.forEachChild(s, i);
+    };
+    const n = l.createSourceFile(
+      e,
+      a,
+      l.ScriptTarget.Latest,
+      !0,
+      e.endsWith(".tsx") ? l.ScriptKind.TSX : l.ScriptKind.TS
+    );
+    i(n);
+  } catch (i) {
+    console.warn(
+      `Failed to parse ${e} for concatenation analysis:`,
+      i
+    );
+  }
+  return t;
+}
+function k(a, e) {
+  const t = a.getStart(), i = a.getEnd();
+  return e.substring(t, i);
+}
+function R(a, e) {
+  const t = a.filter((c) => c.optimizable), i = a.filter((c) => !c.optimizable), n = /* @__PURE__ */ new Set();
+  a.forEach((c) => {
+    n.add(`concatenation-${c.accessibilityNeeds}`);
+  });
+  const s = 87.76, r = n.size * 5, o = Math.max(0, s - r), h = {
+    minimal: a.filter((c) => c.accessibilityNeeds === "minimal").length,
+    aria: a.filter((c) => c.accessibilityNeeds === "aria").length,
+    full: a.filter((c) => c.accessibilityNeeds === "full").length
+  }, d = _(a);
+  return {
+    totalPatterns: a.length,
+    optimizedPatterns: t.length,
+    runtimePatterns: i.length,
+    bundleImpact: {
+      estimatedSavingsKB: o,
+      runtimeReduction: `${Math.round(o / s * 100)}%`,
+      selectedRuntimes: n
+    },
+    accessibilityBreakdown: h,
+    recommendations: d
+  };
+}
+function _(a) {
+  const e = [];
+  return a.forEach((t) => {
+    t.optimizable || M(
+      t.leftComponent,
+      t.rightComponent
+    ) && e.push({
+      type: "static",
+      pattern: t,
+      suggestion: "Consider extracting variable interpolation to enable static concatenation",
+      impact: "medium"
+    }), t.accessibilityNeeds === "full" && F(t) && e.push({
+      type: "accessibility",
+      pattern: t,
+      suggestion: "This concatenation could use minimal ARIA - consider simplifying accessibility requirements",
+      impact: "low"
+    }), t.type === "dynamic" && B(t) && e.push({
+      type: "performance",
+      pattern: t,
+      suggestion: "High-frequency dynamic concatenation - consider memoization or caching",
+      impact: "high"
+    });
+  }), e;
+}
+function z(a, e, t) {
+  if (!t || a.totalPatterns === 0) return;
+  const i = e.split("/").pop() || e;
+  console.log(`
+🔗 TachUI Concatenation Analysis - ${i}`), console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"), console.log("📊 Pattern Summary:"), console.log(`   Total patterns: ${a.totalPatterns}`), console.log(`   ✅ Optimized: ${a.optimizedPatterns} (static)`), console.log(`   🔄 Runtime: ${a.runtimePatterns} (dynamic)`), console.log(`
+📦 Bundle Impact:`), console.log(
+    `   Estimated savings: ${a.bundleImpact.estimatedSavingsKB.toFixed(1)}KB`
+  ), console.log(`   Runtime reduction: ${a.bundleImpact.runtimeReduction}`), console.log(
+    `   Selected runtimes: ${Array.from(a.bundleImpact.selectedRuntimes).join(", ")}`
+  ), console.log(`
+♿ Accessibility Breakdown:`), console.log(`   Minimal: ${a.accessibilityBreakdown.minimal}`), console.log(`   ARIA: ${a.accessibilityBreakdown.aria}`), console.log(`   Full: ${a.accessibilityBreakdown.full}`), a.recommendations.length > 0 && (console.log(`
+💡 Optimization Recommendations:`), a.recommendations.forEach((n) => {
+    const s = n.impact === "high" ? "🔴" : n.impact === "medium" ? "🟡" : "🔵";
+    console.log(`   ${s} ${n.suggestion}`);
+  })), console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+}
+function M(a, e) {
+  const t = /Text\s*\(\s*["'][^"']*["']\s*\)/;
+  return t.test(a) || t.test(e);
+}
+function F(a) {
+  return !a.leftComponent.includes("Button") && !a.rightComponent.includes("Button") && !a.leftComponent.includes("Link") && !a.rightComponent.includes("Link");
+}
+function B(a) {
+  return a.leftComponent.includes("entry[") || a.rightComponent.includes("entry[") || a.leftComponent.includes(".map") || a.rightComponent.includes(".map");
+}
+function O(a, e) {
+  const t = /\$\{[^}]+\}|[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/;
+  return !t.test(a) && !t.test(e);
+}
+function H(a, e, t) {
+  const i = /aria[A-Z][a-zA-Z]*|role\s*:/i.test(t), n = /Button|Link|onTapGesture|onClick/i.test(
+    a + e
+  ), s = /VStack|HStack|ZStack|Form/i.test(t);
+  return i || s ? "full" : n ? "aria" : "minimal";
+}
+function U(a, e) {
+  let t = a;
+  for (const i of e.reverse())
+    if (i.optimizable) {
+      const n = j(i);
+      t = t.slice(0, i.location.start) + n + t.slice(i.location.end);
+    }
+  return t;
+}
+function j(a) {
+  const { leftComponent: e, rightComponent: t, accessibilityNeeds: i } = a;
+  return `(() => {
+    ${D(i)}
+    const leftEl = ${e}.build();
+    const rightEl = ${t}.build();
+    return createOptimizedConcatenation(leftEl, rightEl, '${i}');
+  })()`;
+}
+function D(a) {
+  switch (a) {
+    case "minimal":
+      return "import { createOptimizedConcatenation } from '@tachui/core/runtime/concatenation-minimal';";
+    case "aria":
+      return "import { createOptimizedConcatenation } from '@tachui/core/runtime/concatenation-aria';";
+    case "full":
+      return "import { createOptimizedConcatenation } from '@tachui/core/runtime/concatenation-full';";
+  }
+}
+function Z(a, e, t) {
+  return e.some((s) => a.endsWith(s)) ? !t.some((s) => s.includes("**") ? new RegExp(
+    s.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*")
+  ).test(a) : a.includes(s)) : !1;
+}
+function G(a) {
+  return [
+    /\b(VStack|HStack|ZStack|List|Form)\s*\{/,
+    /\b(Text|Button|Image|TextField|Toggle)\s*\(/,
+    /\.(padding|background|foregroundColor|font|frame)\s*\(/,
+    /\.onTapGesture\s*\(/
+  ].some((t) => t.test(a));
+}
+function q() {
+  return `
+// TachUI Runtime Module
+// This provides runtime utilities for transformed components
+
+import { createSignal, createEffect, createComputed } from '@tachui/core/reactive'
+
+export { createSignal, createEffect, createComputed }
+
+// Runtime helpers for component lifecycle
+export function mountComponent(element, render) {
+  const dispose = render()
+  element._tachui_dispose = dispose
+  return dispose
+}
+
+export function unmountComponent(element) {
+  if (element._tachui_dispose) {
+    element._tachui_dispose()
+    delete element._tachui_dispose
+  }
+}
+
+// Hot reload support
+if (import.meta.hot) {
+  import.meta.hot.accept()
+  
+  // Re-mount components on hot reload
+  import.meta.hot.dispose(() => {
+    document.querySelectorAll('[data-tachui-component]').forEach(unmountComponent)
+  })
+}
+`;
+}
+export {
+  X as a,
+  P as b,
+  J as c,
+  x as g,
+  K as p
+};