@xaendar/cli 0.2.1 → 0.3.1

package/index.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -6,7 +8,7 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a2, b) => (typeof require !== "undefined" ? require : a2)[b]
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
@@ -230,8 +232,8 @@ var require_help = __commonJS({
           visibleCommands.push(helpCommand);
         }
         if (this.sortSubcommands) {
-          visibleCommands.sort((a2, b) => {
-            return a2.name().localeCompare(b.name());
+          visibleCommands.sort((a, b) => {
+            return a.name().localeCompare(b.name());
           });
         }
         return visibleCommands;
@@ -243,11 +245,11 @@ var require_help = __commonJS({
        * @param {Option} b
        * @returns {number}
        */
-      compareOptions(a2, b) {
+      compareOptions(a, b) {
         const getSortKey = (option) => {
           return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
         };
-        return getSortKey(a2).localeCompare(getSortKey(b));
+        return getSortKey(a).localeCompare(getSortKey(b));
       }
       /**
        * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
@@ -1113,20 +1115,20 @@ var require_option = __commonJS({
 var require_suggestSimilar = __commonJS({
   "../node_modules/commander/lib/suggestSimilar.js"(exports) {
     var maxDistance = 3;
-    function editDistance(a2, b) {
-      if (Math.abs(a2.length - b.length) > maxDistance)
-        return Math.max(a2.length, b.length);
+    function editDistance(a, b) {
+      if (Math.abs(a.length - b.length) > maxDistance)
+        return Math.max(a.length, b.length);
       const d = [];
-      for (let i = 0; i <= a2.length; i++) {
+      for (let i = 0; i <= a.length; i++) {
         d[i] = [i];
       }
       for (let j = 0; j <= b.length; j++) {
         d[0][j] = j;
       }
       for (let j = 1; j <= b.length; j++) {
-        for (let i = 1; i <= a2.length; i++) {
+        for (let i = 1; i <= a.length; i++) {
           let cost = 1;
-          if (a2[i - 1] === b[j - 1]) {
+          if (a[i - 1] === b[j - 1]) {
             cost = 0;
           } else {
             cost = 1;
@@ -1139,12 +1141,12 @@ var require_suggestSimilar = __commonJS({
             d[i - 1][j - 1] + cost
             // substitution
           );
-          if (i > 1 && j > 1 && a2[i - 1] === b[j - 2] && a2[i - 2] === b[j - 1]) {
+          if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
             d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
           }
         }
       }
-      return d[a2.length][b.length];
+      return d[a.length][b.length];
     }
     function suggestSimilar(word, candidates) {
       if (!candidates || candidates.length === 0) return "";
@@ -1171,7 +1173,7 @@ var require_suggestSimilar = __commonJS({
           }
         }
       });
-      similar.sort((a2, b) => a2.localeCompare(b));
+      similar.sort((a, b) => a.localeCompare(b));
       if (searchingOptions) {
         similar = similar.map((candidate) => `--${candidate}`);
       }
@@ -3477,8 +3479,9 @@ var {
 // ../packages/cli/src/commands/generate/component/component.command.ts
 import { mkdirSync, writeFileSync, existsSync, rmSync } from "fs";
 import { join } from "path";
-function generateComponent(name, path, force) {
+function generateComponent(name, path, force, style) {
   const dir = join(path, name);
+  style ??= "css";
   if (existsSync(dir)) {
     if (force) {
       console.log(`Deleting "${name}"...`);
@@ -3491,9 +3494,9 @@ function generateComponent(name, path, force) {
   }
   mkdirSync(dir, { recursive: true });
   const files = [
-    [`${name}.xd.component.ts`, tsTemplate(name)],
+    [`${name}.xd.component.ts`, tsTemplate(name, style)],
     [`${name}.xd.component.html`, htmlTemplate(name)],
-    [`${name}.xd.component.css`, cssTemplate(name)],
+    [`${name}.xd.component.${style}`, cssTemplate(name)],
     [`${name}.xd.component.spec.ts`, specTemplate(name)]
   ];
   for (const [filename, content] of files) {
@@ -3505,13 +3508,13 @@ function generateComponent(name, path, force) {
     console.log(`${name}/${filename}`);
   }
 }
-function tsTemplate(name) {
+function tsTemplate(name, style) {
   const className = toPascalCase(name);
   return `import { BaseWebComponent, WebComponent } from '@xaendar/core';
 
 @WebComponent({
   selector: '${toKebabCase(name)}',
-  styleUrl: './${name}.xd.component.css',
+  styleUrl: './${name}.xd.component.${style}',
   templateUrl: './${name}.xd.component.html'
 })
 export class ${className}Component extends BaseWebComponent {
@@ -3528,8 +3531,7 @@ function cssTemplate(_name) {
 }
 function specTemplate(name) {
   const className = toPascalCase(name);
-  return `
-import { describe, expect, it } from "vitest";
+  return `import { describe, expect, it } from "vitest";
 import { ${className}Component } from './${name}.xd.component';
 
 describe('${className}Component', () => {
@@ -3548,8 +3550,8 @@ function toKebabCase(str) {
 }
 
 // ../packages/cli/src/commands/generate/generate.command.ts
-function makeGenerateCommand() {
-  const generate = new Command("generate").alias("g").description("Generate Xendar building blocks");
+function generateCommand() {
+  const generate = new Command("generate").alias("g").description("Generate Xaendar building blocks");
   generate.command("component <name>").alias("c").option("-p, --path <path>", "Custom path for the generated component (default: current directory)").option("-f, --force", "Force generation deleting current component if already exists").description("Generate a new component (creates <name>/ folder with .ts, .html, .css, .spec.ts)").action((name, options) => {
     const path = options.path || process.cwd();
     generateComponent(name, path, !!options.force);
@@ -3557,1286 +3559,239 @@ function makeGenerateCommand() {
   return generate;
 }
 
-// ../packages/common/src/models/stack/stack.model.ts
-var Stack = class {
-  /**
-   * Internal array holding the stack elements, ordered from bottom to top.
-   */
-  _elements = new Array();
-  constructor() {
-    return new Proxy(this, {
-      get(target, prop) {
-        return isNaN(Number(prop)) ? target[prop] : target._elements[Number(prop)];
-      }
-    });
-  }
-  /**
-   * The number of elements currently in the stack.
-   */
-  get length() {
-    return this._elements.length;
-  }
-  /**
-   * A shallow copy of the elements in the stack, ordered from bottom to top.
-   */
-  get values() {
-    return [...this._elements];
-  }
-  /**
-   * Removes and returns the top element of the stack.
-   *
-   * @returns The top element, or `undefined` if the stack is empty.
-   */
-  pop() {
-    return this._elements.pop();
-  }
-  /**
-   * Pushes an element onto the top of the stack.
-   *
-   * @param element - The element to push.
-   * @returns The new length of the stack.
-   */
-  push(element) {
-    return this._elements.push(element);
-  }
-};
-
-// ../packages/compiler/src/costants/chars.constants.ts
-var EOF = 0;
-var LF = 10;
-var CR = 13;
-var SPACE = 32;
-var LPAREN = 40;
-var RPAREN = 41;
-var SLASH = 47;
-var LESS_THAN = 60;
-var GREATER_THEN = 62;
-var AT_SIGN = 64;
-var GRAVE_ACCENT = 96;
-var LEFT_BRACE = 123;
-var RIGHT_BRACE = 125;
+// ../packages/cli/src/commands/new/new.command.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path/win32";
 
-// ../packages/compiler/src/lexer/models/lexer-cursor.model.ts
-var LexerCursor = class {
-  /**
-   * Creates a new cursor for the given input source.
-   *
-   * @param input Full source string to be tokenized.
-   */
-  constructor(input) {
-    this.input = input;
-  }
-  input;
-  /**
-   * Representation of the current character.
-   *
-   * - `index`: absolute index within the input string
-   * - `code`: Unicode code point of the character
-   * - `value`: actual character value
-   *
-   * An index of `-1` indicates that the cursor has not yet consumed
-   * any character or has reached EOF.
-   */
-  _currentChar = {
-    code: 0,
-    index: -1,
-    value: ""
-  };
-  /**
-   * Returns a read-only snapshot of the current character.
-   */
-  get currentChar() {
-    return this._currentChar;
-  }
-  /**
-   * Cache used by peek operations to avoid re-reading
-   * the same character positions multiple times.
-   *
-   * Key: absolute character index
-   * Value: Unicode code point
-   */
-  _peekCache = /* @__PURE__ */ new Map();
-  /**
-   * Logical position of the cursor in the input.
-   *
-   * - `row`: zero-based line number
-   * - `column`: zero-based column number
-   */
-  _position = {
-    row: 0,
-    column: 0
-  };
-  /**
-   * Returns a read-only snapshot of the current cursor position.
-   */
-  get position() {
-    return this._position;
-  }
-  /**
-   * Advances the cursor by the specified number of characters.
-   *
-   * This method:
-   * - Updates the current character
-   * - Updates row/column position
-   * - Detects line breaks (LF / CR)
-   * - Throws an EOF error when the end of the input is reached
-   *
-   * @param chars Number of characters to consume (must be >= 1)
-   *
-   * @throws Error with cause `EOF` when advancing past input length
-   */
-  advance(chars = 1) {
-    if (chars < 1) {
-      throw new Error(`${chars} is not a valid value. Please enter a number equal or greater than 1`);
-    }
-    const newIndex = this._currentChar.index + chars;
-    if (newIndex >= this.input.length) {
-      this._currentChar.code = EOF;
-      this._currentChar.index = -1;
-      this._currentChar.value = "";
-      this.throwEOFError();
-    } else {
-      if ([LF, CR].includes(this._currentChar.code)) {
-        this._position.row++;
-        this._position.column = 0;
-      } else {
-        this._position.column++;
-      }
-      this._currentChar.index = newIndex;
-      this._currentChar.value = this.input[newIndex];
-      this._currentChar.code = this.input.charCodeAt(newIndex);
-    }
-  }
-  peekMatch(pattern, length) {
-    if (typeof pattern === "string") {
-      const peekedChars = this.peek(pattern.length);
-      for (let i = 0; i < pattern.length; i++) {
-        if (peekedChars[i] !== pattern.charCodeAt(i)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    const start = this._currentChar.index + 1;
-    const slice = this.input.slice(start, start + length);
-    return pattern.test(slice);
-  }
-  peek(charsOrOptions, options) {
-    const cache = this._peekCache;
-    const chars = typeof charsOrOptions === "number" ? charsOrOptions : 1;
-    const offset = (typeof charsOrOptions === "object" ? charsOrOptions : options)?.offset ?? 0;
-    return chars === 1 ? this.peekOneChar(this._currentChar.index + offset + 1, cache) : this.peekMany(chars + offset, cache);
-  }
-  /**
-   * Skips all consecutive space characters from the current position.
-   */
-  skipSpaces() {
-    while (this.peek() === SPACE) {
-      this.advance();
-    }
-  }
-  /**
-   * Peeks multiple characters ahead.
-   */
-  peekMany(chars, cache) {
-    const peekedChars = new Array();
-    const nextCharIndex = this._currentChar.index + 1;
-    for (let i = nextCharIndex; i < nextCharIndex + chars; i++) {
-      peekedChars.push(this.peekOneChar(i, cache));
-    }
-    return peekedChars;
-  }
-  /**
-   * Peeks a single character at the given absolute index.
-   */
-  peekOneChar(index, cache) {
-    if (cache.has(index)) {
-      return cache.get(index);
-    }
-    if (index >= this.input.length) {
-      this.throwEOFError();
-    }
-    const charCode = this.input.charCodeAt(index);
-    cache.set(index, charCode);
-    return charCode;
-  }
-  /**
-   * Throws a standardized EOF error used by the lexer engine
-   * to terminate tokenization.
-   */
-  throwEOFError() {
-    throw new Error("", { cause: EOF });
-  }
-};
+// ../packages/cli/src/commands/new/structure.ts
+import { readFileSync } from "fs";
 
-// ../packages/compiler/src/lexer/models/token-type.enum.ts
-var TokenType = /* @__PURE__ */ ((TokenType2) => {
-  TokenType2[TokenType2["TEXT"] = 0] = "TEXT";
-  TokenType2[TokenType2["TAG_OPEN_NAME"] = 1] = "TAG_OPEN_NAME";
-  TokenType2[TokenType2["TAG_SELF_CLOSE"] = 2] = "TAG_SELF_CLOSE";
-  TokenType2[TokenType2["TAG_OPEN_END"] = 3] = "TAG_OPEN_END";
-  TokenType2[TokenType2["TAG_CLOSE_NAME"] = 4] = "TAG_CLOSE_NAME";
-  TokenType2[TokenType2["ATTRIBUTE"] = 5] = "ATTRIBUTE";
-  TokenType2[TokenType2["EVENT"] = 6] = "EVENT";
-  TokenType2[TokenType2["INTERPOLATION_LITERAL"] = 7] = "INTERPOLATION_LITERAL";
-  TokenType2[TokenType2["INTERPOLATION_EXPRESSION"] = 8] = "INTERPOLATION_EXPRESSION";
-  TokenType2[TokenType2["IF"] = 9] = "IF";
-  TokenType2[TokenType2["FOR"] = 10] = "FOR";
-  TokenType2[TokenType2["ELSE"] = 11] = "ELSE";
-  TokenType2[TokenType2["SWITCH"] = 12] = "SWITCH";
-  TokenType2[TokenType2["CASE"] = 13] = "CASE";
-  TokenType2[TokenType2["DEFAULT"] = 14] = "DEFAULT";
-  TokenType2[TokenType2["CONDITION"] = 15] = "CONDITION";
-  TokenType2[TokenType2["BLOCK_OPEN"] = 16] = "BLOCK_OPEN";
-  TokenType2[TokenType2["BLOCK_CLOSE"] = 17] = "BLOCK_CLOSE";
-  TokenType2[TokenType2["EOF"] = 18] = "EOF";
-  return TokenType2;
-})(TokenType || {});
-
-// ../packages/compiler/src/lexer/states/attribute.state.ts
-function consumeAttribute(cursor, _context) {
-  let read = true;
-  let attribute = "";
-  let retVal;
-  while (read) {
-    switch (cursor.peek()) {
-      case SPACE:
-      case SLASH:
-      case GREATER_THEN:
-        retVal = {
-          state: "tag-body" /* TAG_BODY */,
-          tokens: [{
-            type: 5 /* ATTRIBUTE */,
-            parts: [attribute]
-          }]
-        };
-        read = false;
-        break;
-      case LEFT_BRACE:
-        retVal = {
-          state: "interpolation" /* INTERPOLATION */,
-          tokens: [{
-            type: 5 /* ATTRIBUTE */,
-            parts: [attribute]
-          }],
-          pushState: true
-        };
-        read = false;
-        break;
-      default:
-        cursor.advance();
-        attribute = `${attribute}${cursor.currentChar.value}`;
-    }
-  }
-  return retVal;
-}
-
-// ../packages/compiler/src/lexer/states/event.state.ts
-function consumeEvent(cursor, _context) {
-  let read = true;
-  let event = "";
-  let retVal;
-  cursor.advance();
-  while (read) {
-    switch (cursor.peek()) {
-      case SPACE:
-      case SLASH:
-      case GREATER_THEN:
-        retVal = {
-          state: "tag-body" /* TAG_BODY */,
-          tokens: [{
-            type: 6 /* EVENT */,
-            parts: [event]
-          }]
-        };
-        read = false;
-        break;
-      default:
-        cursor.advance();
-        event = `${event}${cursor.currentChar.value}`;
-    }
-  }
-  return retVal;
-}
-
-// ../packages/compiler/src/lexer/states/flow-control.ts
-function consumeFlowControl(cursor, _context) {
-  let retVal;
-  cursor.advance();
-  if (cursor.peekMatch("for ")) {
-    cursor.advance(4);
-    retVal = {
-      state: "flow-control-condition" /* FLOW_CONTROL_CONDITION */,
-      tokens: [{
-        type: 10 /* FOR */
-      }],
-      pushState: true
-    };
-  } else if (cursor.peekMatch("if ")) {
-    cursor.advance(2);
-    retVal = {
-      state: "flow-control-condition" /* FLOW_CONTROL_CONDITION */,
-      tokens: [{
-        type: 9 /* IF */
-      }],
-      pushState: true
-    };
-  } else if (cursor.peekMatch("else ")) {
-    cursor.advance(5);
-    retVal = {
-      state: "flow-control-block" /* FLOW_CONTROL_BLOCK */,
-      tokens: [{
-        type: 11 /* ELSE */
-      }],
-      pushState: true
-    };
-  } else if (cursor.peekMatch("switch ")) {
-    cursor.advance(7);
-    retVal = {
-      state: "flow-control-condition" /* FLOW_CONTROL_CONDITION */,
-      tokens: [{
-        type: 12 /* SWITCH */
-      }],
-      pushState: true
-    };
-  } else if (cursor.peekMatch("case ")) {
-    cursor.advance(5);
-    retVal = {
-      state: "flow-control-condition" /* FLOW_CONTROL_CONDITION */,
-      tokens: [{
-        type: 13 /* CASE */
-      }],
-      pushState: true
-    };
-  } else if (cursor.peekMatch("default ")) {
-    cursor.advance(8);
-    retVal = {
-      state: "flow-control-block" /* FLOW_CONTROL_BLOCK */,
-      tokens: [{
-        type: 14 /* DEFAULT */
-      }],
-      pushState: true
-    };
-  }
-  return retVal;
-}
-
-// ../packages/compiler/src/lexer/states/flow-control-block.state.ts
-function consumeFlowControlBlock(cursor, _context) {
-  cursor.skipSpaces();
-  if (cursor.peek() !== LEFT_BRACE) {
-    throw new Error(`Expected '{' but got '${String.fromCharCode(cursor.peek())}' at row ${cursor.position.row}, col ${cursor.position.column}`);
-  }
-  cursor.advance();
-  return {
-    state: "text" /* TEXT */,
-    tokens: [{ type: 16 /* BLOCK_OPEN */ }],
-    pushState: true
-  };
+// ../packages/cli/src/commands/new/templates/index-html.ts
+function indexHtml(name) {
+  const selector = `${name}-root`;
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${name}</title>
+  </head>
+  <body>
+    <${selector}></${selector}>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`;
 }
 
-// ../packages/compiler/src/lexer/states/flow-control-condition.state.ts
-function consumeFlowControlCondition(cursor, _context) {
-  cursor.skipSpaces();
-  if (cursor.peek() !== LPAREN) {
-    throw new Error(`Expected '(' but got '${String.fromCharCode(cursor.peek())}' at row ${cursor.position.row}, col ${cursor.position.column}`);
-  }
-  cursor.advance();
-  let expression = "";
-  let depth = 1;
-  while (depth > 0) {
-    const code = cursor.peek();
-    switch (code) {
-      case LPAREN:
-        depth++;
-        cursor.advance();
-        break;
-      case RPAREN:
-        depth--;
-        if (!depth) {
-          cursor.advance();
-          break;
-        }
-        cursor.advance();
-        break;
-      default:
-        cursor.advance();
-        expression = `${expression}${cursor.currentChar.value}`;
-    }
-  }
-  return {
-    state: "flow-control-block" /* FLOW_CONTROL_BLOCK */,
-    tokens: [{
-      type: 15 /* CONDITION */,
-      parts: [expression]
-    }],
-    popState: true
-  };
+// ../packages/cli/src/commands/new/templates/main-ts.ts
+function mainTs(componentName) {
+  return `import { loadSignals } from '@xaendar/signals';
+  
+  loadSignals();
+  `;
 }
 
-// ../packages/compiler/src/lexer/states/interpolation-expression.state.ts
-function consumeInterpolationExpression(cursor, context) {
-  let read = true;
-  let interpolation = "";
-  let deep = 1;
-  let retVal;
-  while (read) {
-    switch (cursor.peek()) {
-      case LEFT_BRACE:
-        deep++;
-        interpolation = addCharacter(cursor, interpolation);
-        break;
-      case RIGHT_BRACE:
-        deep--;
-        if (deep === 0) {
-          cursor.advance();
-          const previousState = context.history.pop();
-          let state;
-          switch (previousState) {
-            case "attribute" /* ATTRIBUTE */:
-              state = "tag-body" /* TAG_BODY */;
-              break;
-            case "text" /* TEXT */:
-              state = "text" /* TEXT */;
-          }
-          ;
-          retVal = {
-            state,
-            tokens: [{
-              type: 8 /* INTERPOLATION_EXPRESSION */,
-              parts: [interpolation]
-            }],
-            popState: true
-          };
-          read = false;
-        } else {
-          interpolation = addCharacter(cursor, interpolation);
-        }
-        break;
-      default:
-        interpolation = addCharacter(cursor, interpolation);
-    }
+// ../packages/cli/src/commands/new/templates/package-json.ts
+function packageJson(name, version) {
+  return `{
+  "name": "${name}",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "build": "vite build",
+    "start": "vite",
+    "test": "vitest",
+    "xd": "xd"
+  },
+  "dependencies": {
+    "@xaendar/core": "^${version}",
+    "@xaendar/signals": "^${version}",
+    "@xaendar/types": "^${version}"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.7",
+    "@xaendar/build-tools": "^${version}",
+    "@xaendar/cli": "^${version}",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.14",
+    "vitest": "^4.1.7"
   }
-  return retVal;
 }
-function addCharacter(cursor, interpolation) {
-  cursor.advance(1);
-  return `${interpolation}${cursor.currentChar.value}`;
+`;
 }
 
-// ../packages/compiler/src/lexer/states/interpolation-literal.state.ts
-function consumeInterpolationliteral(cursor, context) {
-  let read = true;
-  let interpolation = "";
-  let retVal;
-  cursor.advance();
-  while (read) {
-    switch (cursor.peek()) {
-      case GRAVE_ACCENT:
-        cursor.advance();
-        if (cursor.peek() === RIGHT_BRACE) {
-          cursor.advance();
-          const previousState = context.history.pop();
-          let state;
-          switch (previousState) {
-            case "attribute" /* ATTRIBUTE */:
-              state = "tag-body" /* TAG_BODY */;
-              break;
-            case "text" /* TEXT */:
-              state = "text" /* TEXT */;
-          }
-          ;
-          retVal = {
-            state,
-            tokens: [{
-              type: 7 /* INTERPOLATION_LITERAL */,
-              parts: [interpolation]
-            }],
-            popState: true
-          };
-          read = false;
-        } else {
-          interpolation = `${interpolation}${cursor.currentChar.value}`;
-        }
-        break;
-      default:
-        interpolation = addCharacter2(cursor, interpolation);
+// ../packages/cli/src/commands/new/templates/tsconfig-json.ts
+function tsconfigJson() {
+  return `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./src/*"]
     }
-  }
-  return retVal;
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules", "**/*.spec.ts"]
 }
-function addCharacter2(cursor, interpolation) {
-  cursor.advance(1);
-  return `${interpolation}${cursor.currentChar.value}`;
+`;
 }
 
-// ../packages/compiler/src/utils/chars.utils.ts
-function isNotBlank(str) {
-  return /\S/.test(str);
-}
-function isJSIdentifierStart(code) {
-  return code >= 65 && code <= 90 || // A-Z
-  code >= 97 && code <= 122 || // a-z
-  code === 36 || // $
-  code === 95;
-}
+// ../packages/cli/src/commands/new/templates/vite-config-ts.ts
+function viteConfigTs() {
+  return `import { defineConfig } from 'vite';
+import { xaendarPlugin } from '@xaendar/build-tools';
 
-// ../packages/compiler/src/lexer/states/interpolation.state.ts
-function consumeInterpolation(cursor, _context) {
-  let retVal;
-  cursor.advance();
-  cursor.skipSpaces();
-  const nextChar = cursor.peek();
-  if (nextChar === GRAVE_ACCENT) {
-    retVal = { state: "interpolation-literal" /* INTERPOLATION_LITERAL */ };
-  } else if (isJSIdentifierStart(nextChar)) {
-    retVal = { state: "interpolation-expression" /* INTERPOLATION_EXPRESSION */ };
-  } else {
-    throw new Error(`Unrecognized First Character ${String.fromCharCode(nextChar)} in interpolation`);
-  }
-  return retVal;
+export default defineConfig({
+  plugins: [xaendarPlugin()],
+});
+`;
 }
 
-// ../packages/compiler/src/lexer/states/tag-body.state.ts
-function consumeTagBody(cursor, _context) {
-  let read = true;
-  let retVal;
-  while (read) {
-    const nextChar = cursor.peek();
-    switch (nextChar) {
-      case AT_SIGN:
-        retVal = {
-          state: "event" /* EVENT */
-        };
-        read = false;
-        break;
-      case SPACE:
-        cursor.advance();
-        break;
-      case GREATER_THEN:
-      case SLASH:
-        retVal = {
-          state: "tag-open-end" /* TAG_OPEN_END */
-        };
-        read = false;
-        break;
-      default:
-        retVal = {
-          state: "attribute" /* ATTRIBUTE */
-        };
-        read = false;
+// ../packages/cli/src/commands/new/templates/xaendar-json.ts
+function xaendarJson(name, style) {
+  return `{
+  "name": "${name}",
+  "entry": "src/main.ts",
+  "outDir": "dist",
+  "assetsDir": "assets",
+  "generate": {
+    "components": {
+      "style": "${style}"
     }
   }
-  return retVal;
 }
-
-// ../packages/compiler/src/lexer/states/tag-close.state.ts
-function consumeTagClose(cursor, _context) {
-  let read = true;
-  let tagName = "";
-  let retVal;
-  cursor.advance(2);
-  cursor.skipSpaces();
-  while (read) {
-    switch (cursor.peek()) {
-      case GREATER_THEN:
-        cursor.advance();
-        retVal = {
-          state: "text" /* TEXT */,
-          tokens: [{
-            type: 4 /* TAG_CLOSE_NAME */,
-            parts: [tagName]
-          }]
-        };
-        read = false;
-        break;
-      case SPACE:
-        throw new Error("Tag Close Name cannot contains spaces");
-      default:
-        cursor.advance();
-        tagName = `${tagName}${cursor.currentChar.value}`;
-    }
-  }
-  return retVal;
+`;
 }
 
-// ../packages/compiler/src/lexer/states/tag-open-end.state.ts
-function consumeTagOpenEnd(cursor, _context) {
-  let retVal;
-  if (cursor.peek() === GREATER_THEN) {
-    cursor.advance();
-    retVal = {
-      state: "text" /* TEXT */,
-      tokens: [{
-        type: 3 /* TAG_OPEN_END */,
-        parts: []
-      }]
-    };
-  } else {
-    cursor.advance();
-    const nextChar = cursor.peek();
-    if (nextChar === GREATER_THEN) {
-      cursor.advance();
-      retVal = {
-        state: "text" /* TEXT */,
-        tokens: [{
-          type: 2 /* TAG_SELF_CLOSE */,
-          parts: []
-        }]
-      };
-    } else {
-      throw new Error(`Unexpected character ${nextChar} for closing tag.
-Expected />
-Read of /${String.fromCharCode(nextChar)}
-At line ${cursor.position.row + 1} col ${cursor.position.column + 1}`);
+// ../packages/cli/src/commands/new/structure.ts
+function readCliVersion() {
+  try {
+    const cliPackageJson = JSON.parse(readFileSync("./package.json", "utf8"));
+    if (!cliPackageJson.version) {
+      throw new Error("Unable to determine Xaendar CLI version.");
     }
+    return cliPackageJson.version;
+  } catch (error) {
+    console.error("Error reading Xaendar CLI version:", error);
+    process.exit(1);
   }
-  return retVal;
 }
-
-// ../packages/compiler/src/lexer/states/tag-open-name.state.ts
-function consumeTagOpenName(cursor, _context) {
-  let read = true;
-  let tagName = "";
-  let retVal;
-  cursor.advance();
-  cursor.skipSpaces();
-  while (read) {
-    switch (cursor.peek()) {
-      case SPACE:
-      case SLASH:
-      case GREATER_THEN:
-        retVal = {
-          state: "tag-body" /* TAG_BODY */,
-          tokens: [{
-            type: 1 /* TAG_OPEN_NAME */,
-            parts: [tagName]
-          }]
-        };
-        read = false;
-        break;
-      default:
-        cursor.advance();
-        tagName = `${tagName}${cursor.currentChar.value}`;
+function buildStructure(context) {
+  const version = readCliVersion();
+  const componentName = context.name;
+  return [
+    {
+      type: "file",
+      name: "package.json",
+      content: packageJson(componentName, version)
+    },
+    {
+      type: "file",
+      name: "xaendar.json",
+      content: xaendarJson(componentName, context.style)
+    },
+    {
+      type: "file",
+      name: "vite.config.ts",
+      content: viteConfigTs()
+    },
+    {
+      type: "file",
+      name: "tsconfig.json",
+      content: tsconfigJson()
+    },
+    {
+      type: "directory",
+      name: "src",
+      children: [
+        {
+          type: "file",
+          name: "index.html",
+          content: indexHtml(componentName)
+        },
+        {
+          type: "file",
+          name: "main.ts",
+          content: mainTs(componentName)
+        },
+        {
+          type: "generateComponent",
+          name: componentName
+        }
+      ]
     }
-  }
-  return retVal;
+  ];
 }
 
-// ../packages/compiler/src/lexer/states/text.state.ts
-function consumeText(cursor, context) {
-  let read = true;
-  let text = "";
-  let retVal;
-  while (read) {
-    switch (cursor.peek()) {
-      case LESS_THAN:
-        const nextState = cursor.peek(1, { offset: 1 }) === SLASH ? "tag-close" /* TAG_CLOSE */ : "tag-open-name" /* TAG_OPEN_NAME */;
-        retVal = { state: nextState };
-        read = false;
-        break;
-      case LEFT_BRACE:
-        retVal = {
-          state: "interpolation" /* INTERPOLATION */,
-          pushState: true
-        };
-        read = false;
-        break;
-      case AT_SIGN:
-        retVal = {
-          state: "flow-control" /* FLOW_CONTROL */
-        };
-        read = false;
-        break;
-      case RIGHT_BRACE:
-        if (context.history[context.history.length - 1] === "flow-control-block" /* FLOW_CONTROL_BLOCK */) {
-          cursor.advance();
-          retVal = {
-            state: "text" /* TEXT */,
-            tokens: [{ type: 17 /* BLOCK_CLOSE */ }],
-            popState: true
-          };
-          read = false;
-        } else {
-          cursor.advance();
-          text = `${text}${cursor.currentChar.value}`;
-        }
-        break;
-      case LF:
-      case CR:
-        cursor.advance();
-        break;
-      default:
-        cursor.advance();
-        text = `${text}${cursor.currentChar.value}`;
-    }
-  }
-  retVal.tokens ??= isNotBlank(text) ? [{ type: 0 /* TEXT */, parts: [text] }] : void 0;
-  return retVal;
+// ../packages/cli/src/commands/new/new.command.ts
+function newCommand() {
+  return new Command("new").description("Sccafold a new Xaendar project").argument("<name>", "Name of the project to create").option("-p, --path <path>", "Custom path for the generated project (default: current directory)").option("-s, --style <style>", "CSS preprocessor to use (css, scss, less, styl)", "css").action((name, options) => {
+    const style = resolveStyleOptions(options.style);
+    const workingDirectory = options.path || process.cwd();
+    const projectDirectory = resolve(workingDirectory, name);
+    checkAndCreateProjectDirectory(projectDirectory);
+    createFiles(buildStructure({ name, style }), projectDirectory, style);
+  });
 }
-
-// ../packages/compiler/src/lexer/lexer.ts
-var Lexer = class {
-  /**
-   * Creates a new Cursor instance for the given template content.
-   *
-   * @param input The full template text that the cursor will navigate.
-   */
-  constructor(input) {
-    this.input = input;
-    this._cursor = new LexerCursor(this.input);
-  }
-  input;
-  _cursor;
-  _state = "start" /* START */;
-  _stack = new Stack();
-  _tokens = new Array();
-  _states = {
-    ["start" /* START */]: consumeText,
-    ["text" /* TEXT */]: consumeText,
-    ["tag-open-name" /* TAG_OPEN_NAME */]: consumeTagOpenName,
-    ["tag-body" /* TAG_BODY */]: consumeTagBody,
-    ["tag-open-end" /* TAG_OPEN_END */]: consumeTagOpenEnd,
-    ["tag-close" /* TAG_CLOSE */]: consumeTagClose,
-    ["attribute" /* ATTRIBUTE */]: consumeAttribute,
-    ["flow-control" /* FLOW_CONTROL */]: consumeFlowControl,
-    ["flow-control-condition" /* FLOW_CONTROL_CONDITION */]: consumeFlowControlCondition,
-    ["flow-control-block" /* FLOW_CONTROL_BLOCK */]: consumeFlowControlBlock,
-    ["event" /* EVENT */]: consumeEvent,
-    ["interpolation" /* INTERPOLATION */]: consumeInterpolation,
-    ["interpolation-expression" /* INTERPOLATION_EXPRESSION */]: consumeInterpolationExpression,
-    ["interpolation-literal" /* INTERPOLATION_LITERAL */]: consumeInterpolationliteral
-  };
-  tokenize() {
-    let eof = false;
-    while (!eof) {
-      try {
-        const transitionFunction = this._states[this._state];
-        const { state, tokens, popState, pushState } = transitionFunction(this._cursor, { history: this._stack.values });
-        if (tokens?.length) {
-          this._tokens.push(...tokens);
-        }
-        if (pushState) {
-          this._stack.push(this._state);
-        }
-        if (popState) {
-          this._stack.pop();
-        }
-        this._state = state;
-      } catch (err) {
-        const error = err;
-        if (error.cause === EOF) {
-          eof = true;
-        } else {
-          throw err;
-        }
-      }
-    }
-    return this._tokens;
-  }
-};
-
-// ../packages/compiler/src/parser/models/parser-cursor.model.ts
-var ParserCursor = class {
-  /**
-   * Creates a new ParserCursor for the given token array.
-   *
-   * @param _tokens Array of tokens to navigate.
-   */
-  constructor(_tokens) {
-    this._tokens = _tokens;
-  }
-  _tokens;
-  /**
-   * Representation of the current token.
-   *
-   * - `index`: absolute index within the token array
-   * - `value`: current token object (or EOF token)
-   *
-   * An index of `-1` indicates that the cursor has not
-   * yet consumed any token or has reached EOF.
-   */
-  _currentToken = {
-    value: { type: 18 /* EOF */ },
-    index: -1
-  };
-  /**
-   * Returns a read-only snapshot of the current token.
-   */
-  get currentToken() {
-    return this._currentToken;
-  }
-  /**
-   * Advances the cursor by the specified number of tokens.
-   *
-   * Updates the current token and index.
-   *
-   * @param chars Number of tokens to advance (must be >= 1)
-   *
-   * @throws Error with cause `EOF` when advancing past the end
-   */
-  advance(chars = 1) {
-    if (chars < 1) {
-      throw new Error(`${chars} is not a valid value. Please enter a number equal or greater than 1`);
-    }
-    const newIndex = this._currentToken.index + chars;
-    if (newIndex >= this._tokens.length) {
-      this._currentToken.value = { type: 18 /* EOF */ };
-      this._currentToken.index = -1;
-      this.throwEOFError();
-    } else {
-      this._currentToken.index = newIndex;
-      this._currentToken.value = this._tokens[newIndex];
-    }
-  }
-  peek(charsOrOptions, options) {
-    const tokens = typeof charsOrOptions === "number" ? charsOrOptions : 1;
-    const offset = (typeof charsOrOptions === "object" ? charsOrOptions : options)?.offset ?? 0;
-    return tokens === 1 ? this.peekOneToken(this._currentToken.index + offset + 1) : this.peekMany(tokens + offset);
-  }
-  /**
-   * Peeks multiple tokens ahead.
-   */
-  peekMany(chars) {
-    const peekedTokens = [];
-    const nextTokenIndex = this._currentToken.index + 1;
-    for (let i = nextTokenIndex; i < nextTokenIndex + chars; i++) {
-      peekedTokens.push(this.peekOneToken(i));
-    }
-    return peekedTokens;
+function resolveStyleOptions(style) {
+  const validStyles = ["css", "scss", "less", "styl"];
+  if (!style) {
+    return "css";
   }
-  /**
-   * Peeks a single token at the given absolute index.
-   */
-  peekOneToken(index) {
-    if (index >= this._tokens.length) {
-      this.throwEOFError();
-    }
-    return this._tokens[index];
-  }
-  /**
-   * Throws a standardized EOF error used by the parser
-   * to terminate token consumption.
-   */
-  throwEOFError() {
-    throw new Error("", { cause: EOF });
-  }
-};
-
-// ../packages/compiler/src/parser/parser.ts
-var Parser = class {
-  /**
-   * Creates a new Parser instance.
-   *
-   * @param tokens Array of tokens produced by the Lexer
-   */
-  constructor(tokens) {
-    this.tokens = tokens;
-    this._cursor = new ParserCursor(this.tokens);
-  }
-  tokens;
-  /** Internal cursor for navigating tokens */
-  _cursor;
-  /**
-   * Entry point for parsing the token stream into AST nodes.
-   *
-   * @returns Array of top-level AST nodes
-   */
-  parse() {
-    let eof = false;
-    const nodes = [];
-    while (!eof) {
-      try {
-        nodes.push(this.parseNode());
-      } catch (err) {
-        const error = err;
-        if (error.cause === EOF) {
-          eof = true;
-        } else {
-          throw err;
-        }
-      }
-    }
-    return nodes;
-  }
-  /**
-   * Parses the next AST node based on the current token.
-   *
-   * @returns Parsed AST node
-   * @throws Error if an unexpected token is encountered
-   */
-  parseNode() {
-    const token = this._cursor.peek();
-    switch (token.type) {
-      case 0 /* TEXT */:
-        return this.parseText(token);
-      case 8 /* INTERPOLATION_EXPRESSION */:
-      case 7 /* INTERPOLATION_LITERAL */:
-        return this.parseInterpolation(token);
-      case 1 /* TAG_OPEN_NAME */:
-        return this.parseElement(token);
-      case 9 /* IF */:
-        return this.parseIfControlFlow(token);
-      case 10 /* FOR */:
-        return this.parseForControlFlow(token);
-      case 12 /* SWITCH */:
-        return this.parseSwitchControlFlow(token);
-      default:
-        throw this.error(`Unexpected token ${TokenType[token.type]}`);
-    }
+  if (!validStyles.includes(style)) {
+    console.error(`\u2716  Invalid style option: ${style}`);
+    process.exit(1);
   }
-  /**
-   * Parses an @if block, including an optional @else branch.
-   *
-   * Expected token sequence:
-   *   IF → CONDITION → BLOCK_OPEN → ...children... → BLOCK_CLOSE
-   *   (optionally followed by: ELSE → BLOCK_OPEN → ...children... → BLOCK_CLOSE)
-   */
-  parseIfControlFlow(_token) {
-    this._cursor.advance();
-    const conditionToken = this._cursor.peek();
-    if (conditionToken.type !== 15 /* CONDITION */) {
-      throw this.error(`Expected CONDITION after IF, got ${TokenType[conditionToken.type]}`);
-    }
-    const condition = conditionToken.parts[0];
-    this._cursor.advance();
-    this._cursor.advance();
-    const consequent = this.parseBlockChildren();
-    let alternate = null;
-    const next = this._cursor.peek();
-    if (next.type === 11 /* ELSE */) {
-      this._cursor.advance();
-      this._cursor.advance();
-      const elseChildren = this.parseBlockChildren();
-      alternate = { type: 4 /* Else */, children: elseChildren };
-    }
-    return { type: 3 /* If */, condition, consequent, alternate };
+  return style;
+}
+function checkAndCreateProjectDirectory(path) {
+  const exists = existsSync2(path);
+  if (exists && readdirSync(path).length) {
+    console.error(`\u2716  Cannot create project: target directory is not empty: ${path}`);
+    process.exit(1);
   }
-  /**
-   * Parses a @for block.
-   *
-   * Expected token sequence:
-   *   FOR → CONDITION → BLOCK_OPEN → ...children... → BLOCK_CLOSE
-   */
-  parseForControlFlow(_token) {
-    this._cursor.advance();
-    const conditionToken = this._cursor.peek();
-    if (conditionToken.type !== 15 /* CONDITION */) {
-      throw this.error(`Expected CONDITION after FOR, got ${TokenType[conditionToken.type]}`);
-    }
-    const expression = conditionToken.parts[0];
-    this._cursor.advance();
-    this._cursor.advance();
-    const children = this.parseBlockChildren();
-    return { type: 5 /* For */, expression, children };
+  if (!exists) {
+    mkdirSync2(path);
   }
-  /**
-   * Parses a @switch block containing @case and @default branches.
-   *
-   * Expected token sequence:
-   *   SWITCH → CONDITION → BLOCK_OPEN
-   *     (CASE → CONDITION → BLOCK_OPEN → ...children... → BLOCK_CLOSE)*
-   *     (DEFAULT → BLOCK_OPEN → ...children... → BLOCK_CLOSE)?
-   *   BLOCK_CLOSE
-   */
-  parseSwitchControlFlow(_token) {
-    this._cursor.advance();
-    const conditionToken = this._cursor.peek();
-    if (conditionToken.type !== 15 /* CONDITION */) {
-      throw this.error(`Expected CONDITION after SWITCH, got ${TokenType[conditionToken.type]}`);
-    }
-    const expression = conditionToken.parts[0];
-    this._cursor.advance();
-    this._cursor.advance();
-    const cases = [];
-    while (this._cursor.peek().type !== 17 /* BLOCK_CLOSE */) {
-      const t = this._cursor.peek();
-      if (t.type === 13 /* CASE */) {
-        this._cursor.advance();
-        const caseCondition = this._cursor.peek();
-        if (caseCondition.type !== 15 /* CONDITION */) {
-          throw this.error(`Expected CONDITION after CASE`);
+}
+function createFiles(entries, basePath, style) {
+  entries.forEach((entry) => {
+    switch (entry.type) {
+      case "file":
+      case void 0:
+        const content = entry.content;
+        writeFileSync2(resolve(basePath, entry.name), content, "utf8");
+        break;
+      case "directory":
+        const dirPath = resolve(basePath, entry.name);
+        mkdirSync2(dirPath);
+        if (entry.children) {
+          createFiles(entry.children, dirPath, style);
         }
-        const caseExpr = caseCondition.parts[0];
-        this._cursor.advance();
-        this._cursor.advance();
-        cases.push({ type: 7 /* Case */, condition: caseExpr, children: this.parseBlockChildren() });
-      } else if (t.type === 14 /* DEFAULT */) {
-        this._cursor.advance();
-        this._cursor.advance();
-        cases.push({ type: 7 /* Case */, condition: null, children: this.parseBlockChildren() });
-      } else {
         break;
-      }
-    }
-    this._cursor.advance();
-    return { type: 6 /* Switch */, expression, cases };
-  }
-  /**
-   * Parses child nodes until a BLOCK_CLOSE token is encountered.
-   * Consumes the BLOCK_CLOSE before returning.
-   */
-  parseBlockChildren() {
-    const children = [];
-    while (this._cursor.peek().type !== 17 /* BLOCK_CLOSE */) {
-      children.push(this.parseNode());
-    }
-    this._cursor.advance();
-    return children;
-  }
-  /**
-   * Parses a text token into a TextNode.
-   */
-  parseText(token) {
-    this._cursor.advance();
-    return {
-      type: 1 /* Text */,
-      value: token.parts[0]
-    };
-  }
-  /**
-   * Parses an interpolation token into an InterpolationNode.
-   */
-  parseInterpolation(token) {
-    this._cursor.advance();
-    return {
-      type: 2 /* Interpolation */,
-      expression: token.parts[0]
-    };
-  }
-  /**
-   * Parses an element starting from a TAG_OPEN_NAME token.
-   * Handles attributes, events, children, and tag closure.
-   */
-  parseElement(token) {
-    this._cursor.advance();
-    const tagName = token.parts[0];
-    const attributes = new Array();
-    const events = new Array();
-    let read = true;
-    while (read) {
-      const token2 = this._cursor.peek();
-      switch (token2.type) {
-        case 5 /* ATTRIBUTE */:
-          attributes.push(this.parseAttribute(token2));
-          break;
-        case 6 /* EVENT */:
-          events.push(this.parseEvent(token2));
-          break;
-        default:
-          read = false;
-      }
-    }
-    if (this._cursor.peek().type === 3 /* TAG_OPEN_END */) {
-      this._cursor.advance();
-    }
-    if (this._cursor.peek().type === 2 /* TAG_SELF_CLOSE */) {
-      this._cursor.advance();
-      return {
-        type: 0 /* Element */,
-        tagName,
-        attributes,
-        events,
-        children: []
-      };
-    }
-    const children = [];
-    while (!this.isTagClose(tagName)) {
-      children.push(this.parseNode());
-    }
-    this._cursor.advance();
-    return {
-      type: 0 /* Element */,
-      tagName,
-      attributes,
-      events,
-      children
-    };
-  }
-  /**
-   * Parses an attribute token into an AttributeNode.
-   * Supports literal values and interpolations as attribute values.
-   */
-  parseAttribute(token) {
-    this._cursor.advance();
-    const raw = token.parts[0];
-    if (!raw.includes("=")) {
-      return { name: raw, value: "true" };
-    }
-    const [name, value] = raw.split("=");
-    if (!name || !value) {
-      throw this.error(`Invalid attribute format: ${raw}`);
-    }
-    const nextToken = this._cursor.peek();
-    if (nextToken.type === 8 /* INTERPOLATION_EXPRESSION */ || nextToken.type === 7 /* INTERPOLATION_LITERAL */) {
-      return {
-        name,
-        value: this.parseInterpolation(nextToken)
-      };
-    }
-    return {
-      name,
-      value: value.replace(/^['']|['']$/g, "")
-    };
-  }
-  /**
-   * Parses an event token into an EventNode.
-   */
-  parseEvent(token) {
-    this._cursor.advance();
-    const raw = token.parts[0];
-    const [name, value] = raw.split("=");
-    if (!name || !value) {
-      throw this.error(`Invalid event format: ${raw}`);
+      case "generateComponent":
+        generateComponent(entry.name, basePath, false, style);
+        break;
     }
-    return {
-      name,
-      handler: value.replace(/^[""]|[""]$/g, "")
-    };
-  }
-  /**
-   * Checks whether the next token is a closing tag matching the given name.
-   */
-  isTagClose(tagName) {
-    const nextToken = this._cursor.peek();
-    return nextToken.type === 4 /* TAG_CLOSE_NAME */ && nextToken.parts[0] === tagName;
-  }
-  /**
-   * Creates a parser error with a consistent prefix.
-   */
-  error(message) {
-    return new Error(`[Parser] ${message}`);
-  }
-};
-
-// ../packages/compiler/src/render-generator/render-generator.model.ts
-function generateRenderFunction(ast, componentVar = "this") {
-  return [
-    `
-const shadow = ${componentVar}.shadowRoot!;
-`,
-    ...ast.map((node, i) => processNode(node, `node${i}`, componentVar, "shadow")).flat()
-  ].join("\n");
-}
-function processNode(node, varName, componentVar, parentVar) {
-  switch (node.type) {
-    case 1 /* Text */:
-    case 2 /* Interpolation */:
-      return processTextAndInterpolation(node, varName, componentVar, parentVar);
-    case 0 /* Element */:
-      return processElement(node, varName, componentVar, parentVar);
-    case 3 /* If */:
-      return processIf(node, varName, componentVar, parentVar);
-    case 5 /* For */:
-      return processFor(node, varName, componentVar, parentVar);
-    case 6 /* Switch */:
-      return processSwitch(node, varName, componentVar, parentVar);
-    default:
-      return [];
-  }
-}
-function processTextAndInterpolation(node, varName, componentVar, parentVar) {
-  const textValue = node.type === 1 /* Text */ ? JSON.stringify(node.value) : resolveExpression(node.expression, componentVar);
-  return [
-    `const ${varName} = document.createTextNode(${textValue});`,
-    `${parentVar}.appendChild(${varName});`
-  ];
-}
-function processElement(node, varName, componentVar, parentVar) {
-  return [
-    `const ${varName} = document.createElement("${node.tagName}");`,
-    ...node.attributes?.map((attr) => `${varName}.setAttribute('${attr.name}', ${typeof attr.value === "string" ? attr.value : `${componentVar}.${attr.value.expression}`});`) || [],
-    ...node.events?.map((event) => `${varName}.addEventListener("${event.name}", ${componentVar}.${event.handler}.bind(${componentVar}));`) || [],
-    `${parentVar}.appendChild(${varName});`,
-    ...node.children.map((child, i) => processNode(child, `${varName}_c${i}`, componentVar, varName)).flat()
-  ];
-}
-function processIf(node, varName, componentVar, parentVar) {
-  const code = [
-    `if (${resolveExpression(node.condition, componentVar)}) {`,
-    ...node.consequent.map((child, idx) => indent(...processNode(child, `${varName}_t${idx}`, componentVar, parentVar))).flat(),
-    "}"
-  ];
-  const alt = node.alternate;
-  if (alt) {
-    code[code.length - 1] += " else {";
-    code.push(
-      ...alt.children.map((child, idx) => indent(...processNode(child, `${varName}_e${idx}`, componentVar, parentVar))).flat(),
-      "}"
-    );
-  }
-  return code;
-}
-function processFor(node, varName, componentVar, parentVar) {
-  const iterExpr = resolveForExpression(node.expression, componentVar);
-  return [
-    `for (${iterExpr}) {`,
-    ...node.children.map((child, idx) => indent(...processNode(child, `${varName}_f${idx}`, componentVar, parentVar))).flat(),
-    "}"
-  ];
-}
-function processSwitch(node, varName, componentVar, parentVar) {
-  return [
-    `switch (${resolveExpression(node.expression, componentVar)}) {`,
-    ...node.cases.map((caseNode) => [
-      ...indent(
-        `${!caseNode.condition ? "default" : `case ${caseNode.condition}`}: {`,
-        ...caseNode.children.map((child, i) => indent(...processNode(child, `${varName}_s${i}_${i}`, componentVar, parentVar))).flat(),
-        `${indent("break;")}`,
-        `}`
-      )
-    ]).flat(),
-    "}"
-  ];
-}
-function resolveForExpression(expression, componentVar) {
-  const match = expression.match(/^let\s+(\w+)\s+of\s+(\w+)$/);
-  if (!match) {
-    throw new Error(`String "${expression}" does not match the structure "let X of Y"`);
-  }
-  const [, X, Y] = match;
-  return `const ${X} of this.${Y}`;
-}
-function resolveExpression(expression, componentVar) {
-  return expression.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g, (match) => match === componentVar ? match : `${componentVar}.${match}`);
-}
-function indent(...lines) {
-  return lines.map((line) => `  ${line}`);
-}
-
-// ../packages/cli/src/commands/compile/compile.command.ts
-import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname, extname, resolve } from "path";
-function compileFile(inputPath, outputPath) {
-  const absInput = resolve(process.cwd(), inputPath);
-  const absOutput = outputPath ? resolve(process.cwd(), outputPath) : resolve(dirname(absInput), `${basename(absInput, extname(absInput))}.render.js`);
-  let source;
-  try {
-    source = readFileSync(absInput, "utf8");
-  } catch {
-    console.error(`\u2716  Cannot read file: ${absInput}`);
-    process.exit(1);
-  }
-  const result = compile(source);
-  writeFileSync2(absOutput, result, "utf8");
-  console.log(`\u2714  Compiled: ${inputPath} \u2192 ${absOutput}`);
-}
-function compile(source) {
-  const tokens = new Lexer(source).tokenize();
-  const ast = new Parser(tokens).parse();
-  return generateRenderFunction(ast);
-}
-
-// ../packages/cli/src/commands/compile/compile.ts
-function makeCompileCommand() {
-  return new Command("compile").alias("co").description("Compile a Xendar HTML template into a render function").argument("<input>", "Path to the .xd.component.html template file").option("-o, --output <path>", "Path for the emitted output file (default: <input>.render.js)").action((input, options) => {
-    compileFile(input, options.output);
   });
 }
 
 // ../packages/cli/src/index.ts
-program.name("xd").description("Xendar CLI").version("0.2.0");
-program.addCommand(makeGenerateCommand());
-program.addCommand(makeCompileCommand());
+program.name("xd").description("Xaendar CLI").version("0.2.0");
+program.addCommand(generateCommand());
+program.addCommand(newCommand());
 program.parse();
 //# sourceMappingURL=index.js.map