@qt-test/apex-dsl-compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,2050 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SourceMapBuilder: () => SourceMapBuilder,
+  VERSION: () => VERSION,
+  applySourceMap: () => applySourceMap,
+  compile: () => compile,
+  compileACSS: () => compileACSS,
+  compileAXML: () => compileAXML,
+  createSourceMap: () => createSourceMap,
+  formatErrors: () => formatErrors,
+  generateCode: () => generateCode,
+  mergeSourceMaps: () => mergeSourceMaps,
+  parseACSS: () => parseACSS,
+  parseAXML: () => parseAXML,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/axml/parser.ts
+function createPosition(state) {
+  return {
+    line: state.line,
+    column: state.column,
+    offset: state.pos
+  };
+}
+function createLoc(start, end, source) {
+  return { start, end, source };
+}
+function parseAXML(source) {
+  const state = {
+    source,
+    pos: 0,
+    line: 1,
+    column: 0,
+    errors: []
+  };
+  const children = parseChildren(state);
+  let ast;
+  if (children.length === 0) {
+    ast = null;
+  } else if (children.length === 1 && children[0].type === "Element") {
+    ast = children[0];
+  } else {
+    ast = {
+      type: "Element",
+      tag: "block",
+      attributes: [],
+      directives: [],
+      children,
+      selfClosing: false,
+      isComponent: false,
+      start: 0,
+      end: source.length,
+      loc: createLoc(
+        { line: 1, column: 0, offset: 0 },
+        { line: state.line, column: state.column, offset: state.pos }
+      )
+    };
+  }
+  return { ast, errors: state.errors };
+}
+function parseChildren(state, endTag) {
+  const children = [];
+  while (state.pos < state.source.length) {
+    if (endTag && lookAhead(state, `</${endTag}`)) {
+      break;
+    }
+    const node = parseNode(state);
+    if (node) {
+      if (node.type === "Text" && children.length > 0 && children[children.length - 1].type === "Text") {
+        const prev = children[children.length - 1];
+        prev.content += node.content;
+        prev.raw += node.raw;
+        prev.end = node.end;
+        prev.loc.end = node.loc.end;
+      } else {
+        children.push(node);
+      }
+    }
+  }
+  return children;
+}
+function parseNode(state) {
+  skipWhitespace(state);
+  if (state.pos >= state.source.length) {
+    return null;
+  }
+  if (lookAhead(state, "<!--")) {
+    return parseComment(state);
+  }
+  if (lookAhead(state, "<") && !lookAhead(state, "</")) {
+    return parseElement(state);
+  }
+  return parseText(state);
+}
+function parseElement(state) {
+  const start = createPosition(state);
+  advance(state);
+  const tag = parseTagName(state);
+  if (!tag) {
+    state.errors.push(`Expected tag name at line ${state.line}`);
+    return null;
+  }
+  const { attributes, directives } = parseAttributes(state);
+  skipWhitespace(state);
+  const selfClosing = lookAhead(state, "/>");
+  if (selfClosing) {
+    advance(state, 2);
+  } else {
+    if (!consume(state, ">")) {
+      state.errors.push(`Expected '>' at line ${state.line}`);
+      return null;
+    }
+    const children = parseChildren(state, tag);
+    if (!consume(state, `</${tag}`)) {
+      state.errors.push(`Expected closing tag </${tag}> at line ${state.line}`);
+    }
+    skipWhitespace(state);
+    consume(state, ">");
+    const end2 = createPosition(state);
+    return {
+      type: "Element",
+      tag,
+      attributes,
+      directives,
+      children,
+      selfClosing: false,
+      isComponent: isCustomComponent(tag),
+      start: start.offset,
+      end: end2.offset,
+      loc: createLoc(start, end2)
+    };
+  }
+  const end = createPosition(state);
+  return {
+    type: "Element",
+    tag,
+    attributes,
+    directives,
+    children: [],
+    selfClosing: true,
+    isComponent: isCustomComponent(tag),
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseTagName(state) {
+  let name = "";
+  while (state.pos < state.source.length) {
+    const char = state.source[state.pos];
+    if (/[a-zA-Z0-9_-]/.test(char)) {
+      name += char;
+      advance(state);
+    } else {
+      break;
+    }
+  }
+  return name;
+}
+function parseAttributes(state) {
+  const attributes = [];
+  const directives = [];
+  while (state.pos < state.source.length) {
+    skipWhitespace(state);
+    if (lookAhead(state, ">") || lookAhead(state, "/>")) {
+      break;
+    }
+    const start = createPosition(state);
+    const name = parseAttributeName(state);
+    if (!name) break;
+    if (name.startsWith("a:")) {
+      const directive = parseDirective(state, name, start);
+      if (directive) {
+        directives.push(directive);
+      }
+      continue;
+    }
+    let value = null;
+    let isDynamic = false;
+    skipWhitespace(state);
+    if (consume(state, "=")) {
+      skipWhitespace(state);
+      const result = parseAttributeValue(state);
+      value = result.value;
+      isDynamic = result.isDynamic;
+    }
+    const end = createPosition(state);
+    attributes.push({
+      type: "Attribute",
+      name,
+      value,
+      isDynamic,
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc(start, end)
+    });
+  }
+  return { attributes, directives };
+}
+function parseAttributeName(state) {
+  let name = "";
+  while (state.pos < state.source.length) {
+    const char = state.source[state.pos];
+    if (/[a-zA-Z0-9_\-:]/.test(char)) {
+      name += char;
+      advance(state);
+    } else {
+      break;
+    }
+  }
+  return name;
+}
+function parseAttributeValue(state) {
+  const quote = state.source[state.pos];
+  if (quote !== '"' && quote !== "'") {
+    const start2 = createPosition(state);
+    let raw2 = "";
+    while (state.pos < state.source.length && !/[\s>]/.test(state.source[state.pos])) {
+      raw2 += state.source[state.pos];
+      advance(state);
+    }
+    const end2 = createPosition(state);
+    const isDynamic2 = raw2.includes("{{");
+    if (isDynamic2) {
+      return {
+        value: {
+          type: "Expression",
+          expression: extractExpression(raw2),
+          raw: raw2,
+          start: start2.offset,
+          end: end2.offset,
+          loc: createLoc(start2, end2)
+        },
+        isDynamic: true
+      };
+    }
+    return {
+      value: {
+        type: "Literal",
+        value: raw2,
+        raw: raw2,
+        start: start2.offset,
+        end: end2.offset,
+        loc: createLoc(start2, end2)
+      },
+      isDynamic: false
+    };
+  }
+  advance(state);
+  const start = createPosition(state);
+  let raw = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== quote) {
+    raw += state.source[state.pos];
+    advance(state);
+  }
+  const end = createPosition(state);
+  advance(state);
+  const isDynamic = raw.includes("{{");
+  if (isDynamic) {
+    return {
+      value: {
+        type: "Expression",
+        expression: extractExpression(raw),
+        raw,
+        start: start.offset,
+        end: end.offset,
+        loc: createLoc(start, end)
+      },
+      isDynamic: true
+    };
+  }
+  return {
+    value: {
+      type: "Literal",
+      value: raw,
+      raw,
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc(start, end)
+    },
+    isDynamic: false
+  };
+}
+function parseDirective(state, name, start) {
+  const directiveName = name.slice(2);
+  let value = null;
+  skipWhitespace(state);
+  if (consume(state, "=")) {
+    skipWhitespace(state);
+    const result = parseAttributeValue(state);
+    if (result.value?.type === "Expression") {
+      value = result.value;
+    } else if (result.value?.type === "Literal") {
+      value = {
+        type: "Expression",
+        expression: result.value.value,
+        raw: result.value.raw,
+        start: result.value.start,
+        end: result.value.end,
+        loc: result.value.loc
+      };
+    }
+  }
+  const end = createPosition(state);
+  return {
+    type: "Directive",
+    name: directiveName,
+    value,
+    modifiers: [],
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseText(state) {
+  const start = createPosition(state);
+  let raw = "";
+  while (state.pos < state.source.length) {
+    if (lookAhead(state, "<")) {
+      break;
+    }
+    raw += state.source[state.pos];
+    advance(state);
+  }
+  if (!raw) return null;
+  const end = createPosition(state);
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && !trimmed.slice(2, -2).includes("{{")) {
+    return {
+      type: "Expression",
+      expression: trimmed.slice(2, -2).trim(),
+      raw,
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc(start, end)
+    };
+  }
+  return {
+    type: "Text",
+    content: raw,
+    raw,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseComment(state) {
+  const start = createPosition(state);
+  advance(state, 4);
+  let content = "";
+  while (state.pos < state.source.length && !lookAhead(state, "-->")) {
+    content += state.source[state.pos];
+    advance(state);
+  }
+  advance(state, 3);
+  const end = createPosition(state);
+  return {
+    type: "Comment",
+    content,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function extractExpression(raw) {
+  const parts = [];
+  let lastIndex = 0;
+  const regex = /\{\{(.+?)\}\}/g;
+  let match;
+  while ((match = regex.exec(raw)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push(`'${raw.slice(lastIndex, match.index)}'`);
+    }
+    parts.push(match[1].trim());
+    lastIndex = regex.lastIndex;
+  }
+  if (lastIndex < raw.length) {
+    parts.push(`'${raw.slice(lastIndex)}'`);
+  }
+  return parts.length === 1 ? parts[0] : parts.join(" + ");
+}
+function isCustomComponent(tag) {
+  const builtIn = [
+    "view",
+    "text",
+    "image",
+    "button",
+    "input",
+    "textarea",
+    "scroll-view",
+    "swiper",
+    "swiper-item",
+    "navigator",
+    "block",
+    "template",
+    "slot",
+    "icon",
+    "progress",
+    "checkbox",
+    "checkbox-group",
+    "radio",
+    "radio-group",
+    "switch",
+    "slider",
+    "picker",
+    "picker-view",
+    "picker-view-column",
+    "form",
+    "label",
+    "rich-text",
+    "web-view",
+    "map",
+    "canvas",
+    "video",
+    "audio",
+    "camera",
+    "live-player",
+    "live-pusher"
+  ];
+  return !builtIn.includes(tag);
+}
+function advance(state, count = 1) {
+  for (let i = 0; i < count && state.pos < state.source.length; i++) {
+    if (state.source[state.pos] === "\n") {
+      state.line++;
+      state.column = 0;
+    } else {
+      state.column++;
+    }
+    state.pos++;
+  }
+}
+function lookAhead(state, str) {
+  return state.source.slice(state.pos, state.pos + str.length) === str;
+}
+function consume(state, str) {
+  if (lookAhead(state, str)) {
+    advance(state, str.length);
+    return true;
+  }
+  return false;
+}
+function skipWhitespace(state) {
+  while (state.pos < state.source.length && /\s/.test(state.source[state.pos])) {
+    advance(state);
+  }
+}
+
+// src/axml/compiler.ts
+function compileAXML(source, options = {}) {
+  const { ast, errors: parseErrors } = parseAXML(source);
+  const ctx = {
+    code: "",
+    indent: 0,
+    components: options.components ?? {},
+    usedComponents: /* @__PURE__ */ new Set(),
+    usedExpressions: /* @__PURE__ */ new Set(),
+    warnings: [],
+    errors: [...parseErrors],
+    scopeStack: []
+  };
+  if (!ast) {
+    return {
+      code: "function render() { return null; }",
+      ast: null,
+      warnings: ctx.warnings,
+      errors: ctx.errors,
+      usedComponents: ctx.usedComponents,
+      usedExpressions: ctx.usedExpressions
+    };
+  }
+  const renderCode = generateRenderFunction(ast, ctx);
+  return {
+    code: renderCode,
+    ast,
+    warnings: ctx.warnings,
+    errors: ctx.errors,
+    usedComponents: ctx.usedComponents,
+    usedExpressions: ctx.usedExpressions
+  };
+}
+function generateRenderFunction(ast, ctx) {
+  const bodyCode = generateElement(ast, ctx);
+  return `function render(_ctx, _cache) {
+  const { h, Fragment, renderList, renderSlot, withDirectives, resolveComponent } = _ctx._runtime;
+  return ${bodyCode};
+}`;
+}
+function generateElement(node, ctx) {
+  const { tag, attributes, directives, children, isComponent } = node;
+  const forDirective = directives.find((d) => d.name === "for");
+  const ifDirective = directives.find((d) => d.name === "if");
+  const elifDirective = directives.find((d) => d.name === "elif");
+  const elseDirective = directives.find((d) => d.name === "else");
+  if (forDirective) {
+    return generateForLoop(node, forDirective, ctx);
+  }
+  if (ifDirective) {
+    return generateConditional(node, ifDirective, "if", ctx);
+  }
+  if (elifDirective) {
+    ctx.warnings.push(`a:elif without preceding a:if at line ${node.loc.start.line}`);
+    return generateConditional(node, elifDirective, "elif", ctx);
+  }
+  if (elseDirective) {
+    ctx.warnings.push(`a:else without preceding a:if at line ${node.loc.start.line}`);
+    return "null";
+  }
+  if (tag === "block" || tag === "template") {
+    return generateFragment(children, ctx);
+  }
+  if (tag === "slot") {
+    return generateSlot(node, ctx);
+  }
+  let tagCode;
+  if (isComponent) {
+    ctx.usedComponents.add(tag);
+    const componentPath = ctx.components[tag];
+    if (componentPath) {
+      tagCode = `resolveComponent("${tag}")`;
+    } else {
+      tagCode = `resolveComponent("${tag}")`;
+      ctx.warnings.push(`Unknown component "${tag}" at line ${node.loc.start.line}`);
+    }
+  } else {
+    tagCode = `"${tag}"`;
+  }
+  const propsCode = generateProps(attributes, directives, ctx);
+  const childrenCode = generateChildren(children, ctx);
+  if (childrenCode === "null") {
+    if (propsCode === "null") {
+      return `h(${tagCode})`;
+    }
+    return `h(${tagCode}, ${propsCode})`;
+  }
+  return `h(${tagCode}, ${propsCode}, ${childrenCode})`;
+}
+function generateForLoop(node, directive, ctx) {
+  const expression = directive.value?.expression ?? "";
+  const forMatch = expression.match(/^\s*(?:\(([^,]+),\s*([^)]+)\)|([^\s]+))\s+in\s+(.+)$/);
+  if (!forMatch) {
+    ctx.errors.push(`Invalid a:for expression: ${expression}`);
+    return "null";
+  }
+  const itemVar = forMatch[1] || forMatch[3] || "item";
+  const indexVar = forMatch[2] || "index";
+  const listExpr = forMatch[4];
+  const forItemDir = node.directives.find((d) => d.name === "for-item");
+  const forIndexDir = node.directives.find((d) => d.name === "for-index");
+  const keyDir = node.directives.find((d) => d.name === "key");
+  const finalItemVar = forItemDir?.value?.expression ?? itemVar;
+  const finalIndexVar = forIndexDir?.value?.expression ?? indexVar;
+  const keyExpr = keyDir?.value?.expression ?? finalIndexVar;
+  ctx.usedExpressions.add(listExpr);
+  ctx.scopeStack.push(finalItemVar, finalIndexVar);
+  const filteredDirectives = node.directives.filter(
+    (d) => !["for", "for-item", "for-index", "key"].includes(d.name)
+  );
+  const elementWithoutFor = { ...node, directives: filteredDirectives };
+  const elementCode = generateElement(elementWithoutFor, ctx);
+  ctx.scopeStack.pop();
+  ctx.scopeStack.pop();
+  return `renderList(_ctx.${listExpr}, (${finalItemVar}, ${finalIndexVar}) => {
+    return ${elementCode};
+  }, "${keyExpr}")`;
+}
+function generateConditional(node, directive, type, ctx) {
+  const expression = directive.value?.expression ?? "true";
+  ctx.usedExpressions.add(expression);
+  const filteredDirectives = node.directives.filter((d) => d.name !== type);
+  const elementWithoutCondition = { ...node, directives: filteredDirectives };
+  const elementCode = generateElement(elementWithoutCondition, ctx);
+  return `(${transformExpression(expression, ctx)}) ? ${elementCode} : null`;
+}
+function generateFragment(children, ctx) {
+  if (children.length === 0) {
+    return "null";
+  }
+  if (children.length === 1) {
+    return generateNode(children[0], ctx);
+  }
+  const childrenCode = children.map((child) => generateNode(child, ctx)).filter((code) => code !== "null").join(",\n    ");
+  return `h(Fragment, null, [
+    ${childrenCode}
+  ])`;
+}
+function generateSlot(node, ctx) {
+  const nameAttr = node.attributes.find((a) => a.name === "name");
+  const slotName = nameAttr?.value?.type === "Literal" ? nameAttr.value.value : "default";
+  const fallback = node.children.length > 0 ? generateChildren(node.children, ctx) : "null";
+  const slotProps = node.attributes.filter((a) => a.name !== "name").map((a) => {
+    const key = a.name;
+    const value = a.value ? a.isDynamic ? transformExpression(a.value.type === "Expression" ? a.value.expression : a.value.value, ctx) : `"${a.value.type === "Literal" ? a.value.value : ""}"` : "true";
+    return `${key}: ${value}`;
+  }).join(", ");
+  const propsCode = slotProps ? `{ ${slotProps} }` : "null";
+  return `renderSlot(_ctx.$slots, "${slotName}", ${propsCode}, () => ${fallback})`;
+}
+function generateProps(attributes, directives, ctx) {
+  const props = [];
+  const events = [];
+  for (const attr of attributes) {
+    const { name, value, isDynamic } = attr;
+    if (name.startsWith("on") || name.startsWith("catch")) {
+      const isCatch = name.startsWith("catch");
+      const eventName = isCatch ? name.slice(5) : name.slice(2);
+      const handler = value?.type === "Expression" ? value.expression : value?.type === "Literal" ? value.value : "";
+      if (handler) {
+        ctx.usedExpressions.add(handler);
+        const eventKey = eventName.toLowerCase();
+        events.push(`${eventKey}: { handler: _ctx.${handler}, catch: ${isCatch} }`);
+      }
+      continue;
+    }
+    if (name === "class") {
+      if (isDynamic && value?.type === "Expression") {
+        ctx.usedExpressions.add(value.expression);
+        props.push(`class: ${transformExpression(value.expression, ctx)}`);
+      } else if (value?.type === "Literal") {
+        props.push(`class: "${value.value}"`);
+      }
+      continue;
+    }
+    if (name === "style") {
+      if (isDynamic && value?.type === "Expression") {
+        ctx.usedExpressions.add(value.expression);
+        props.push(`style: ${transformExpression(value.expression, ctx)}`);
+      } else if (value?.type === "Literal") {
+        props.push(`style: "${value.value}"`);
+      }
+      continue;
+    }
+    if (name.startsWith("data-")) {
+      const dataKey = name.slice(5);
+      if (isDynamic && value?.type === "Expression") {
+        ctx.usedExpressions.add(value.expression);
+        props.push(`"data-${dataKey}": ${transformExpression(value.expression, ctx)}`);
+      } else if (value?.type === "Literal") {
+        props.push(`"data-${dataKey}": "${value.value}"`);
+      } else {
+        props.push(`"data-${dataKey}": true`);
+      }
+      continue;
+    }
+    if (isDynamic && value?.type === "Expression") {
+      ctx.usedExpressions.add(value.expression);
+      props.push(`${name}: ${transformExpression(value.expression, ctx)}`);
+    } else if (value?.type === "Literal") {
+      props.push(`${name}: "${value.value}"`);
+    } else if (value === null) {
+      props.push(`${name}: true`);
+    }
+  }
+  const refDirective = directives.find((d) => d.name === "ref");
+  if (refDirective?.value) {
+    props.push(`ref: "${refDirective.value.expression}"`);
+  }
+  if (events.length > 0) {
+    props.push(`_events: { ${events.join(", ")} }`);
+  }
+  if (props.length === 0) {
+    return "null";
+  }
+  return `{ ${props.join(", ")} }`;
+}
+function generateChildren(children, ctx) {
+  const filteredChildren = children.filter((child) => {
+    if (child.type === "Comment") return false;
+    if (child.type === "Text" && !child.content.trim()) return false;
+    return true;
+  });
+  if (filteredChildren.length === 0) {
+    return "null";
+  }
+  const processedChildren = processConditionalChains(filteredChildren, ctx);
+  if (processedChildren.length === 1) {
+    return generateNode(processedChildren[0].node, ctx, processedChildren[0].chain);
+  }
+  const childrenCode = processedChildren.map(({ node, chain }) => generateNode(node, ctx, chain)).join(",\n    ");
+  return `[
+    ${childrenCode}
+  ]`;
+}
+function processConditionalChains(children, _ctx) {
+  const result = [];
+  let currentChain = [];
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (child.type !== "Element") {
+      if (currentChain.length > 0) {
+        result.push({ node: currentChain[0], chain: currentChain.slice(1) });
+        currentChain = [];
+      }
+      result.push({ node: child });
+      continue;
+    }
+    const hasIf = child.directives.some((d) => d.name === "if");
+    const hasElif = child.directives.some((d) => d.name === "elif");
+    const hasElse = child.directives.some((d) => d.name === "else");
+    if (hasIf) {
+      if (currentChain.length > 0) {
+        result.push({ node: currentChain[0], chain: currentChain.slice(1) });
+      }
+      currentChain = [child];
+    } else if ((hasElif || hasElse) && currentChain.length > 0) {
+      currentChain.push(child);
+      if (hasElse) {
+        result.push({ node: currentChain[0], chain: currentChain.slice(1) });
+        currentChain = [];
+      }
+    } else {
+      if (currentChain.length > 0) {
+        result.push({ node: currentChain[0], chain: currentChain.slice(1) });
+        currentChain = [];
+      }
+      result.push({ node: child });
+    }
+  }
+  if (currentChain.length > 0) {
+    result.push({ node: currentChain[0], chain: currentChain.slice(1) });
+  }
+  return result;
+}
+function generateNode(node, ctx, conditionalChain) {
+  switch (node.type) {
+    case "Element":
+      if (conditionalChain && conditionalChain.length > 0) {
+        return generateConditionalChain(node, conditionalChain, ctx);
+      }
+      return generateElement(node, ctx);
+    case "Text":
+      return generateText(node, ctx);
+    case "Expression":
+      return generateExpression(node, ctx);
+    case "Comment":
+      return "null";
+    default:
+      return "null";
+  }
+}
+function generateConditionalChain(ifNode, chain, ctx) {
+  const ifDirective = ifNode.directives.find((d) => d.name === "if");
+  if (!ifDirective?.value) {
+    ctx.errors.push(`Missing condition in a:if at line ${ifNode.loc.start.line}`);
+    return "null";
+  }
+  const ifCondition = transformExpression(ifDirective.value.expression, ctx);
+  ctx.usedExpressions.add(ifDirective.value.expression);
+  const ifBranchNode = {
+    ...ifNode,
+    directives: ifNode.directives.filter((d) => d.name !== "if")
+  };
+  const ifBranch = generateElement(ifBranchNode, ctx);
+  let code = `(${ifCondition}) ? ${ifBranch}`;
+  for (const chainNode of chain) {
+    const elifDirective = chainNode.directives.find((d) => d.name === "elif");
+    const elseDirective = chainNode.directives.find((d) => d.name === "else");
+    const branchNode = {
+      ...chainNode,
+      directives: chainNode.directives.filter((d) => !["elif", "else"].includes(d.name))
+    };
+    const branchCode = generateElement(branchNode, ctx);
+    if (elifDirective?.value) {
+      const elifCondition = transformExpression(elifDirective.value.expression, ctx);
+      ctx.usedExpressions.add(elifDirective.value.expression);
+      code += ` : (${elifCondition}) ? ${branchCode}`;
+    } else if (elseDirective) {
+      code += ` : ${branchCode}`;
+    }
+  }
+  const hasElse = chain.some((n) => n.directives.some((d) => d.name === "else"));
+  if (!hasElse) {
+    code += " : null";
+  }
+  return code;
+}
+function generateText(node, ctx) {
+  const content = node.content.trim();
+  if (!content) return "null";
+  if (content.includes("{{")) {
+    return generateInterpolatedText(content, ctx);
+  }
+  return `"${escapeString(content)}"`;
+}
+function generateInterpolatedText(content, ctx) {
+  const parts = [];
+  let lastIndex = 0;
+  const regex = /\{\{(.+?)\}\}/g;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match.index > lastIndex) {
+      const text = content.slice(lastIndex, match.index);
+      if (text) {
+        parts.push(`"${escapeString(text)}"`);
+      }
+    }
+    const expr = match[1].trim();
+    ctx.usedExpressions.add(expr);
+    parts.push(transformExpression(expr, ctx));
+    lastIndex = regex.lastIndex;
+  }
+  if (lastIndex < content.length) {
+    const text = content.slice(lastIndex);
+    if (text) {
+      parts.push(`"${escapeString(text)}"`);
+    }
+  }
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  return parts.join(" + ");
+}
+function generateExpression(node, ctx) {
+  ctx.usedExpressions.add(node.expression);
+  return transformExpression(node.expression, ctx);
+}
+function transformExpression(expr, ctx) {
+  if (/^['"`].*['"`]$/.test(expr)) return expr;
+  if (/^\d+(\.\d+)?$/.test(expr)) return expr;
+  if (expr === "true" || expr === "false" || expr === "null" || expr === "undefined") {
+    return expr;
+  }
+  const scopeVars = ctx.scopeStack;
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(expr)) {
+    if (scopeVars.includes(expr)) {
+      return expr;
+    }
+    return `_ctx.${expr}`;
+  }
+  const rootMatch = expr.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+  if (rootMatch) {
+    const root = rootMatch[1];
+    if (scopeVars.includes(root)) {
+      return expr;
+    }
+  }
+  return expr.replace(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b(?!\s*:)/g, (match, id) => {
+    const keywords = ["true", "false", "null", "undefined", "this", "typeof", "instanceof", "new", "void", "delete"];
+    if (keywords.includes(id) || scopeVars.includes(id)) {
+      return match;
+    }
+    return `_ctx.${id}`;
+  });
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+
+// src/acss/parser.ts
+function createPosition2(state) {
+  return {
+    line: state.line,
+    column: state.column,
+    offset: state.pos
+  };
+}
+function createLoc2(start, end, source) {
+  return { start, end, source };
+}
+function parseACSS(source) {
+  const state = {
+    source,
+    pos: 0,
+    line: 1,
+    column: 0,
+    errors: []
+  };
+  const start = createPosition2(state);
+  const rules = [];
+  const imports = [];
+  while (state.pos < state.source.length) {
+    skipWhitespaceAndComments(state);
+    if (state.pos >= state.source.length) break;
+    if (lookAhead2(state, "@import")) {
+      const importRule = parseImport(state);
+      if (importRule) {
+        imports.push(importRule);
+      }
+      continue;
+    }
+    if (lookAhead2(state, "@media")) {
+      const mediaRule = parseMediaRule(state);
+      if (mediaRule) {
+        rules.push(mediaRule);
+      }
+      continue;
+    }
+    if (lookAhead2(state, "@keyframes") || lookAhead2(state, "@-webkit-keyframes")) {
+      const keyframesRule = parseKeyframesRule(state);
+      if (keyframesRule) {
+        rules.push(keyframesRule);
+      }
+      continue;
+    }
+    const rule = parseStyleRule(state);
+    if (rule) {
+      rules.push(rule);
+    }
+  }
+  const end = createPosition2(state);
+  return {
+    ast: {
+      type: "Stylesheet",
+      rules,
+      imports,
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc2(start, end)
+    },
+    errors: state.errors
+  };
+}
+function parseImport(state) {
+  const start = createPosition2(state);
+  advance2(state, 7);
+  skipWhitespace2(state);
+  let path = "";
+  const quote = state.source[state.pos];
+  if (quote === '"' || quote === "'") {
+    advance2(state);
+    while (state.pos < state.source.length && state.source[state.pos] !== quote) {
+      path += state.source[state.pos];
+      advance2(state);
+    }
+    advance2(state);
+  } else {
+    state.errors.push(`Expected quoted string at line ${state.line}`);
+    skipToSemicolon(state);
+    return null;
+  }
+  skipWhitespace2(state);
+  consume2(state, ";");
+  const end = createPosition2(state);
+  return {
+    type: "Import",
+    path,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc2(start, end)
+  };
+}
+function parseMediaRule(state) {
+  const start = createPosition2(state);
+  advance2(state, 6);
+  skipWhitespace2(state);
+  let query = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== "{") {
+    query += state.source[state.pos];
+    advance2(state);
+  }
+  query = query.trim();
+  if (!consume2(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    return null;
+  }
+  const rules = [];
+  while (state.pos < state.source.length && state.source[state.pos] !== "}") {
+    skipWhitespaceAndComments(state);
+    if (state.source[state.pos] === "}") break;
+    const rule = parseStyleRule(state);
+    if (rule) {
+      rules.push(rule);
+    }
+  }
+  consume2(state, "}");
+  const end = createPosition2(state);
+  return {
+    type: "MediaRule",
+    query,
+    rules,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc2(start, end)
+  };
+}
+function parseKeyframesRule(state) {
+  const start = createPosition2(state);
+  if (lookAhead2(state, "@-webkit-keyframes")) {
+    advance2(state, 18);
+  } else {
+    advance2(state, 10);
+  }
+  skipWhitespace2(state);
+  let name = "";
+  while (state.pos < state.source.length && !/[\s{]/.test(state.source[state.pos])) {
+    name += state.source[state.pos];
+    advance2(state);
+  }
+  skipWhitespace2(state);
+  if (!consume2(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    return null;
+  }
+  const keyframes = [];
+  while (state.pos < state.source.length && state.source[state.pos] !== "}") {
+    skipWhitespaceAndComments(state);
+    if (state.source[state.pos] === "}") break;
+    const keyframe = parseKeyframe(state);
+    if (keyframe) {
+      keyframes.push(keyframe);
+    }
+  }
+  consume2(state, "}");
+  const end = createPosition2(state);
+  return {
+    type: "KeyframesRule",
+    name,
+    keyframes,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc2(start, end)
+  };
+}
+function parseKeyframe(state) {
+  const start = createPosition2(state);
+  let selector = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== "{") {
+    selector += state.source[state.pos];
+    advance2(state);
+  }
+  selector = selector.trim();
+  if (!consume2(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    return null;
+  }
+  const declarations = parseDeclarations(state);
+  consume2(state, "}");
+  const end = createPosition2(state);
+  return {
+    type: "Keyframe",
+    selector,
+    declarations,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc2(start, end)
+  };
+}
+function parseStyleRule(state) {
+  const start = createPosition2(state);
+  const selectors = parseSelectors(state);
+  if (selectors.length === 0) {
+    skipToCloseBrace(state);
+    return null;
+  }
+  skipWhitespace2(state);
+  if (!consume2(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    skipToCloseBrace(state);
+    return null;
+  }
+  const declarations = parseDeclarations(state);
+  consume2(state, "}");
+  const end = createPosition2(state);
+  return {
+    type: "StyleRule",
+    selectors,
+    declarations,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc2(start, end)
+  };
+}
+function parseSelectors(state) {
+  const selectors = [];
+  let current = "";
+  const start = createPosition2(state);
+  while (state.pos < state.source.length) {
+    const char = state.source[state.pos];
+    if (char === "{") break;
+    if (char === ",") {
+      const trimmed2 = current.trim();
+      if (trimmed2) {
+        const end = createPosition2(state);
+        selectors.push({
+          type: "Selector",
+          value: trimmed2,
+          specificity: calculateSpecificity(trimmed2),
+          start: start.offset,
+          end: end.offset,
+          loc: createLoc2(start, end)
+        });
+      }
+      advance2(state);
+      current = "";
+      continue;
+    }
+    current += char;
+    advance2(state);
+  }
+  const trimmed = current.trim();
+  if (trimmed) {
+    const end = createPosition2(state);
+    selectors.push({
+      type: "Selector",
+      value: trimmed,
+      specificity: calculateSpecificity(trimmed),
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc2(start, end)
+    });
+  }
+  return selectors;
+}
+function calculateSpecificity(selector) {
+  let ids = 0;
+  let classes = 0;
+  let elements = 0;
+  ids = (selector.match(/#[a-zA-Z_-][a-zA-Z0-9_-]*/g) || []).length;
+  classes = (selector.match(/\.[a-zA-Z_-][a-zA-Z0-9_-]*/g) || []).length;
+  classes += (selector.match(/\[[^\]]+\]/g) || []).length;
+  classes += (selector.match(/:[a-zA-Z-]+(?:\([^)]*\))?/g) || []).filter(
+    (p) => !p.startsWith("::")
+  ).length;
+  const withoutIds = selector.replace(/#[a-zA-Z_-][a-zA-Z0-9_-]*/g, "");
+  const withoutClasses = withoutIds.replace(/\.[a-zA-Z_-][a-zA-Z0-9_-]*/g, "");
+  const withoutAttrs = withoutClasses.replace(/\[[^\]]+\]/g, "");
+  const withoutPseudo = withoutAttrs.replace(/:[a-zA-Z-]+(?:\([^)]*\))?/g, "");
+  const tagMatches = withoutPseudo.match(/[a-zA-Z][a-zA-Z0-9-]*/g) || [];
+  elements = tagMatches.filter((t) => !["not", "is", "where", "has"].includes(t)).length;
+  elements += (selector.match(/::[a-zA-Z-]+/g) || []).length;
+  return [ids, classes, elements];
+}
+function parseDeclarations(state) {
+  const declarations = [];
+  while (state.pos < state.source.length && state.source[state.pos] !== "}") {
+    skipWhitespaceAndComments(state);
+    if (state.source[state.pos] === "}") break;
+    const declaration = parseDeclaration(state);
+    if (declaration) {
+      declarations.push(declaration);
+    }
+  }
+  return declarations;
+}
+function parseDeclaration(state) {
+  const start = createPosition2(state);
+  let property = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== ":" && state.source[state.pos] !== "}") {
+    property += state.source[state.pos];
+    advance2(state);
+  }
+  property = property.trim();
+  if (!property || !consume2(state, ":")) {
+    skipToSemicolon(state);
+    return null;
+  }
+  skipWhitespace2(state);
+  let value = "";
+  let important = false;
+  let parenDepth = 0;
+  while (state.pos < state.source.length) {
+    const char = state.source[state.pos];
+    if (char === "(") parenDepth++;
+    if (char === ")") parenDepth--;
+    if (parenDepth === 0 && (char === ";" || char === "}")) {
+      break;
+    }
+    value += char;
+    advance2(state);
+  }
+  value = value.trim();
+  if (value.endsWith("!important")) {
+    important = true;
+    value = value.slice(0, -10).trim();
+  }
+  consume2(state, ";");
+  const end = createPosition2(state);
+  if (!/^[a-zA-Z-]+$/.test(property)) {
+    state.errors.push(`Invalid property name "${property}" at line ${start.line}`);
+    return null;
+  }
+  return {
+    type: "Declaration",
+    property,
+    value,
+    important,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc2(start, end)
+  };
+}
+function advance2(state, count = 1) {
+  for (let i = 0; i < count && state.pos < state.source.length; i++) {
+    if (state.source[state.pos] === "\n") {
+      state.line++;
+      state.column = 0;
+    } else {
+      state.column++;
+    }
+    state.pos++;
+  }
+}
+function lookAhead2(state, str) {
+  return state.source.slice(state.pos, state.pos + str.length) === str;
+}
+function consume2(state, str) {
+  if (lookAhead2(state, str)) {
+    advance2(state, str.length);
+    return true;
+  }
+  return false;
+}
+function skipWhitespace2(state) {
+  while (state.pos < state.source.length && /\s/.test(state.source[state.pos])) {
+    advance2(state);
+  }
+}
+function skipWhitespaceAndComments(state) {
+  while (state.pos < state.source.length) {
+    skipWhitespace2(state);
+    if (lookAhead2(state, "/*")) {
+      advance2(state, 2);
+      while (state.pos < state.source.length && !lookAhead2(state, "*/")) {
+        advance2(state);
+      }
+      advance2(state, 2);
+      continue;
+    }
+    if (lookAhead2(state, "//")) {
+      while (state.pos < state.source.length && state.source[state.pos] !== "\n") {
+        advance2(state);
+      }
+      continue;
+    }
+    break;
+  }
+}
+function skipToSemicolon(state) {
+  while (state.pos < state.source.length && state.source[state.pos] !== ";" && state.source[state.pos] !== "}") {
+    advance2(state);
+  }
+  consume2(state, ";");
+}
+function skipToCloseBrace(state) {
+  let depth = 0;
+  while (state.pos < state.source.length) {
+    if (state.source[state.pos] === "{") depth++;
+    if (state.source[state.pos] === "}") {
+      if (depth === 0) {
+        advance2(state);
+        return;
+      }
+      depth--;
+    }
+    advance2(state);
+  }
+}
+
+// src/acss/compiler.ts
+var PREFIXED_PROPERTIES = {
+  "transform": ["-webkit-transform"],
+  "transform-origin": ["-webkit-transform-origin"],
+  "transition": ["-webkit-transition"],
+  "animation": ["-webkit-animation"],
+  "animation-name": ["-webkit-animation-name"],
+  "animation-duration": ["-webkit-animation-duration"],
+  "animation-timing-function": ["-webkit-animation-timing-function"],
+  "animation-delay": ["-webkit-animation-delay"],
+  "animation-iteration-count": ["-webkit-animation-iteration-count"],
+  "animation-direction": ["-webkit-animation-direction"],
+  "animation-fill-mode": ["-webkit-animation-fill-mode"],
+  "animation-play-state": ["-webkit-animation-play-state"],
+  "flex": ["-webkit-flex"],
+  "flex-direction": ["-webkit-flex-direction"],
+  "flex-wrap": ["-webkit-flex-wrap"],
+  "flex-flow": ["-webkit-flex-flow"],
+  "justify-content": ["-webkit-justify-content"],
+  "align-items": ["-webkit-align-items"],
+  "align-content": ["-webkit-align-content"],
+  "align-self": ["-webkit-align-self"],
+  "order": ["-webkit-order"],
+  "flex-grow": ["-webkit-flex-grow"],
+  "flex-shrink": ["-webkit-flex-shrink"],
+  "flex-basis": ["-webkit-flex-basis"],
+  "user-select": ["-webkit-user-select", "-moz-user-select"],
+  "appearance": ["-webkit-appearance", "-moz-appearance"],
+  "backdrop-filter": ["-webkit-backdrop-filter"],
+  "background-clip": ["-webkit-background-clip"]
+};
+function compileACSS(source, options = {}) {
+  const { ast, errors: parseErrors } = parseACSS(source);
+  const warnings = [];
+  const errors = [...parseErrors];
+  const animations = /* @__PURE__ */ new Set();
+  const imports = ast.imports.map((i) => i.path);
+  const processedRules = ast.rules.map((rule) => processRule(rule, options, animations, warnings));
+  const css = generateCSS(processedRules, options, warnings);
+  return {
+    css,
+    ast,
+    warnings,
+    errors,
+    imports,
+    animations
+  };
+}
+function processRule(rule, options, animations, warnings) {
+  switch (rule.type) {
+    case "StyleRule":
+      return processStyleRule(rule, options, animations, warnings);
+    case "MediaRule":
+      return {
+        ...rule,
+        rules: rule.rules.map((r) => processStyleRule(r, options, animations, warnings))
+      };
+    case "KeyframesRule":
+      animations.add(rule.name);
+      return processKeyframesRule(rule, options, warnings);
+    default:
+      return rule;
+  }
+}
+function processStyleRule(rule, options, animations, warnings) {
+  let selectors = rule.selectors;
+  if (options.scoped && options.scopeId) {
+    selectors = selectors.map((s) => ({
+      ...s,
+      value: scopeSelector(s.value, options.scopeId)
+    }));
+  }
+  let declarations = rule.declarations.map((d) => processDeclaration(d, options, warnings));
+  if (options.autoprefixer) {
+    declarations = addVendorPrefixes(declarations);
+  }
+  declarations.forEach((d) => {
+    if (d.property === "animation" || d.property === "animation-name") {
+      const animName = d.value.split(/\s+/)[0];
+      if (animName && !animName.startsWith("var(")) {
+        animations.add(animName);
+      }
+    }
+  });
+  return {
+    ...rule,
+    selectors,
+    declarations
+  };
+}
+function processKeyframesRule(rule, options, warnings) {
+  return {
+    ...rule,
+    keyframes: rule.keyframes.map((kf) => ({
+      ...kf,
+      declarations: kf.declarations.map((d) => processDeclaration(d, options, warnings))
+    }))
+  };
+}
+function processDeclaration(decl, options, warnings) {
+  let { value } = decl;
+  if (options.rpxToRem) {
+    value = convertRpxToRem(value, options);
+  }
+  if (!value) {
+    warnings.push(`Empty value for property "${decl.property}"`);
+  }
+  return {
+    ...decl,
+    value
+  };
+}
+function convertRpxToRem(value, options) {
+  const designWidth = options.designWidth ?? 750;
+  const baseFontSize = options.baseFontSize ?? 16;
+  return value.replace(/(\d+(?:\.\d+)?)\s*rpx/gi, (_, num) => {
+    const px = parseFloat(num) / designWidth * 375;
+    const rem = px / baseFontSize;
+    return `${rem.toFixed(6).replace(/\.?0+$/, "")}rem`;
+  });
+}
+function scopeSelector(selector, scopeId) {
+  const scopeAttr = `[data-v-${scopeId}]`;
+  return selector.split(/\s*([>+~])\s*/).map((part, i) => {
+    if (i % 2 === 1) return part;
+    if (/^(html|body|:root)$/i.test(part)) return part;
+    const pseudoMatch = part.match(/^(.+?)(::[\w-]+)$/);
+    if (pseudoMatch) {
+      return `${pseudoMatch[1]}${scopeAttr}${pseudoMatch[2]}`;
+    }
+    const pseudoClassMatch = part.match(/^(.+?)(:[\w-]+(?:\([^)]*\))?)$/);
+    if (pseudoClassMatch) {
+      return `${pseudoClassMatch[1]}${scopeAttr}${pseudoClassMatch[2]}`;
+    }
+    return `${part}${scopeAttr}`;
+  }).join(" ");
+}
+function addVendorPrefixes(declarations) {
+  const result = [];
+  for (const decl of declarations) {
+    const prefixes = PREFIXED_PROPERTIES[decl.property];
+    if (prefixes) {
+      for (const prefix of prefixes) {
+        result.push({
+          ...decl,
+          property: prefix
+        });
+      }
+    }
+    result.push(decl);
+  }
+  return result;
+}
+function generateCSS(rules, options, _warnings) {
+  const minify = options.minify ?? false;
+  const indent = minify ? "" : "  ";
+  const newline = minify ? "" : "\n";
+  const space = minify ? "" : " ";
+  const parts = [];
+  for (const rule of rules) {
+    parts.push(generateRule(rule, indent, newline, space));
+  }
+  return parts.join(minify ? "" : "\n\n");
+}
+function generateRule(rule, indent, newline, space) {
+  switch (rule.type) {
+    case "StyleRule":
+      return generateStyleRule(rule, indent, newline, space);
+    case "MediaRule":
+      return generateMediaRule(rule, indent, newline, space);
+    case "KeyframesRule":
+      return generateKeyframesRule(rule, indent, newline, space);
+    default:
+      return "";
+  }
+}
+function generateStyleRule(rule, indent, newline, space, baseIndent = "") {
+  const selectors = rule.selectors.map((s) => s.value).join(`,${space}`);
+  const declarations = rule.declarations.map((d) => {
+    const important = d.important ? `${space}!important` : "";
+    return `${baseIndent}${indent}${d.property}:${space}${d.value}${important};`;
+  }).join(newline);
+  return `${baseIndent}${selectors}${space}{${newline}${declarations}${newline}${baseIndent}}`;
+}
+function generateMediaRule(rule, indent, newline, space) {
+  const rules = rule.rules.map((r) => generateStyleRule(r, indent, newline, space, indent)).join(newline + newline);
+  return `@media${space}${rule.query}${space}{${newline}${rules}${newline}}`;
+}
+function generateKeyframesRule(rule, indent, newline, space) {
+  const keyframes = rule.keyframes.map((kf) => {
+    const declarations = kf.declarations.map((d) => {
+      const important = d.important ? `${space}!important` : "";
+      return `${indent}${indent}${d.property}:${space}${d.value}${important};`;
+    }).join(newline);
+    return `${indent}${kf.selector}${space}{${newline}${declarations}${newline}${indent}}`;
+  }).join(newline);
+  const standard = `@keyframes${space}${rule.name}${space}{${newline}${keyframes}${newline}}`;
+  const webkit = `@-webkit-keyframes${space}${rule.name}${space}{${newline}${keyframes}${newline}}`;
+  return `${webkit}${newline}${standard}`;
+}
+
+// src/codegen.ts
+function generateCode(input, options) {
+  const { template, styles, js } = input;
+  const { isComponent, minify } = options;
+  const parts = [];
+  parts.push(generateImports(input, options));
+  if (js) {
+    parts.push("");
+    parts.push("// User code");
+    parts.push(js);
+  }
+  if (template) {
+    parts.push("");
+    parts.push("// Render function");
+    parts.push(template.code);
+  }
+  if (styles) {
+    parts.push("");
+    parts.push("// Styles");
+    parts.push(generateStylesCode(styles, options));
+  }
+  parts.push("");
+  parts.push(
+    isComponent ? generateComponentDefinition(input, options) : generatePageDefinition(input, options)
+  );
+  parts.push("");
+  parts.push(generateExports(input, options));
+  let code = parts.join("\n");
+  if (minify) {
+    code = minifyCode(code);
+  }
+  return code;
+}
+function generateImports(input, _options) {
+  const imports = [];
+  const runtimeImports = ["h", "Fragment"];
+  if (input.template?.usedComponents.size) {
+    runtimeImports.push("resolveComponent");
+  }
+  if (input.template?.code.includes("renderList")) {
+    runtimeImports.push("renderList");
+  }
+  if (input.template?.code.includes("renderSlot")) {
+    runtimeImports.push("renderSlot");
+  }
+  imports.push(`import { ${runtimeImports.join(", ")} } from '@qt-test/apex-runtime';`);
+  const components = input.config.usingComponents ?? {};
+  for (const [name, path] of Object.entries(components)) {
+    imports.push(`import ${toPascalCase(name)} from '${path}';`);
+  }
+  if (input.styles?.imports.length) {
+    for (const importPath of input.styles.imports) {
+      imports.push(`import '${importPath}';`);
+    }
+  }
+  return imports.join("\n");
+}
+function generateStylesCode(styles, _options) {
+  const css = styles.css.replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  return `const __styles__ = \`${css}\`;`;
+}
+function generateComponentDefinition(input, _options) {
+  const properties = extractComponentProperties(input.js ?? "");
+  const methods = extractComponentMethods(input.js ?? "");
+  const parts = [];
+  parts.push("const __component__ = {");
+  parts.push('  is: "component",');
+  if (properties.length > 0) {
+    parts.push(`  properties: {`);
+    for (const prop of properties) {
+      parts.push(`    ${prop.name}: { type: ${prop.type}, value: ${prop.default} },`);
+    }
+    parts.push("  },");
+  }
+  parts.push("  data() {");
+  parts.push("    return {};");
+  parts.push("  },");
+  if (methods.length > 0) {
+    parts.push("  methods: {");
+    for (const method of methods) {
+      parts.push(`    ${method},`);
+    }
+    parts.push("  },");
+  }
+  if (input.template) {
+    parts.push("  render,");
+  }
+  if (input.styles) {
+    parts.push("  styles: __styles__,");
+  }
+  if (input.config.usingComponents) {
+    const componentEntries = Object.entries(input.config.usingComponents).map(([name]) => `    "${name}": ${toPascalCase(name)}`).join(",\n");
+    parts.push(`  components: {
+${componentEntries}
+  },`);
+  }
+  parts.push("};");
+  return parts.join("\n");
+}
+function generatePageDefinition(input, _options) {
+  const parts = [];
+  parts.push("const __page__ = {");
+  parts.push('  is: "page",');
+  if (input.config.navigationBarTitleText) {
+    parts.push(`  title: "${input.config.navigationBarTitleText}",`);
+  }
+  if (input.config.enablePullDownRefresh) {
+    parts.push("  enablePullDownRefresh: true,");
+  }
+  parts.push("  data() {");
+  parts.push("    return {};");
+  parts.push("  },");
+  if (input.template) {
+    parts.push("  render,");
+  }
+  if (input.styles) {
+    parts.push("  styles: __styles__,");
+  }
+  if (input.config.usingComponents) {
+    const componentEntries = Object.entries(input.config.usingComponents).map(([name]) => `    "${name}": ${toPascalCase(name)}`).join(",\n");
+    parts.push(`  components: {
+${componentEntries}
+  },`);
+  }
+  parts.push("};");
+  return parts.join("\n");
+}
+function generateExports(input, options) {
+  const exports2 = [];
+  if (options.isComponent) {
+    exports2.push("export default __component__;");
+  } else {
+    exports2.push("export default __page__;");
+  }
+  if (input.template) {
+    exports2.push("export { render };");
+  }
+  if (input.styles) {
+    exports2.push("export { __styles__ as styles };");
+  }
+  return exports2.join("\n");
+}
+function extractComponentProperties(js) {
+  const properties = [];
+  const propsMatch = js.match(/properties\s*:\s*\{([^}]+)\}/);
+  if (propsMatch) {
+    const propsBlock = propsMatch[1];
+    const propMatches = propsBlock.matchAll(/(\w+)\s*:\s*\{?\s*(?:type\s*:\s*(\w+))?\s*(?:,\s*value\s*:\s*([^,}]+))?\s*\}?/g);
+    for (const match of propMatches) {
+      properties.push({
+        name: match[1],
+        type: match[2] || "String",
+        default: match[3]?.trim() || "null"
+      });
+    }
+  }
+  return properties;
+}
+function extractComponentMethods(js) {
+  const methods = [];
+  const methodsMatch = js.match(/methods\s*:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/);
+  if (methodsMatch) {
+    const methodsBlock = methodsMatch[1];
+    const methodMatches = methodsBlock.matchAll(/(\w+)\s*(?:\([^)]*\))?\s*\{/g);
+    for (const match of methodMatches) {
+      methods.push(match[1]);
+    }
+  }
+  return methods;
+}
+function toPascalCase(str) {
+  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function minifyCode(code) {
+  return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{};,:])\s*/g, "$1").replace(/;\s*}/g, "}").trim();
+}
+
+// src/sourcemap.ts
+var SourceMapBuilder = class {
+  constructor(options) {
+    this.sources = [];
+    this.sourcesContent = [];
+    this.names = [];
+    this.mappings = [];
+    this.currentLine = [];
+    if (options) {
+      this.file = options.file;
+      this.sourceRoot = options.sourceRoot;
+      this.sources = [...options.sources];
+      if (options.includeContent && options.sourcesContent) {
+        this.sourcesContent = [...options.sourcesContent];
+      }
+    }
+  }
+  /**
+   * Adds a source file
+   */
+  addSource(source, content) {
+    const index = this.sources.indexOf(source);
+    if (index !== -1) {
+      return index;
+    }
+    this.sources.push(source);
+    this.sourcesContent.push(content ?? null);
+    return this.sources.length - 1;
+  }
+  /**
+   * Adds a name
+   */
+  addName(name) {
+    const index = this.names.indexOf(name);
+    if (index !== -1) {
+      return index;
+    }
+    this.names.push(name);
+    return this.names.length - 1;
+  }
+  /**
+   * Adds a mapping
+   */
+  addMapping(generatedLine, generatedColumn, sourceIndex, sourceLine, sourceColumn, nameIndex) {
+    while (this.mappings.length <= generatedLine) {
+      if (this.currentLine.length > 0) {
+        this.mappings.push(this.currentLine);
+        this.currentLine = [];
+      } else {
+        this.mappings.push([]);
+      }
+    }
+    const segment = { generatedColumn };
+    if (sourceIndex !== void 0) {
+      segment.sourceIndex = sourceIndex;
+      segment.sourceLine = sourceLine;
+      segment.sourceColumn = sourceColumn;
+      if (nameIndex !== void 0) {
+        segment.nameIndex = nameIndex;
+      }
+    }
+    if (this.mappings.length === generatedLine) {
+      this.currentLine.push(segment);
+    } else {
+      this.mappings[generatedLine].push(segment);
+    }
+  }
+  /**
+   * Starts a new line
+   */
+  newLine() {
+    this.mappings.push(this.currentLine);
+    this.currentLine = [];
+  }
+  /**
+   * Generates the source map
+   */
+  toSourceMap() {
+    if (this.currentLine.length > 0) {
+      this.mappings.push(this.currentLine);
+      this.currentLine = [];
+    }
+    return {
+      version: 3,
+      file: this.file,
+      sourceRoot: this.sourceRoot,
+      sources: this.sources,
+      sourcesContent: this.sourcesContent.length > 0 ? this.sourcesContent : void 0,
+      names: this.names,
+      mappings: this.encodeMappings()
+    };
+  }
+  /**
+   * Encodes mappings to VLQ format
+   */
+  encodeMappings() {
+    let previousGeneratedColumn = 0;
+    let previousSourceIndex = 0;
+    let previousSourceLine = 0;
+    let previousSourceColumn = 0;
+    let previousNameIndex = 0;
+    const lines = [];
+    for (const line of this.mappings) {
+      previousGeneratedColumn = 0;
+      const segments = [];
+      const sortedSegments = [...line].sort((a, b) => a.generatedColumn - b.generatedColumn);
+      for (const segment of sortedSegments) {
+        const values = [];
+        values.push(segment.generatedColumn - previousGeneratedColumn);
+        previousGeneratedColumn = segment.generatedColumn;
+        if (segment.sourceIndex !== void 0) {
+          values.push(segment.sourceIndex - previousSourceIndex);
+          previousSourceIndex = segment.sourceIndex;
+          values.push((segment.sourceLine ?? 0) - previousSourceLine);
+          previousSourceLine = segment.sourceLine ?? 0;
+          values.push((segment.sourceColumn ?? 0) - previousSourceColumn);
+          previousSourceColumn = segment.sourceColumn ?? 0;
+          if (segment.nameIndex !== void 0) {
+            values.push(segment.nameIndex - previousNameIndex);
+            previousNameIndex = segment.nameIndex;
+          }
+        }
+        segments.push(values.map(encodeVLQ).join(""));
+      }
+      lines.push(segments.join(","));
+    }
+    return lines.join(";");
+  }
+  /**
+   * Returns JSON string
+   */
+  toString() {
+    return JSON.stringify(this.toSourceMap());
+  }
+  /**
+   * Returns data URL
+   */
+  toDataUrl() {
+    const json = this.toString();
+    const base64 = typeof btoa !== "undefined" ? btoa(json) : Buffer.from(json).toString("base64");
+    return `data:application/json;charset=utf-8;base64,${base64}`;
+  }
+  /**
+   * Returns inline comment
+   */
+  toComment() {
+    return `//# sourceMappingURL=${this.toDataUrl()}`;
+  }
+};
+var VLQ_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var VLQ_BASE_SHIFT = 5;
+var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+var VLQ_BASE_MASK = VLQ_BASE - 1;
+var VLQ_CONTINUATION_BIT = VLQ_BASE;
+function encodeVLQ(value) {
+  let encoded = "";
+  let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
+  do {
+    let digit = vlq & VLQ_BASE_MASK;
+    vlq >>>= VLQ_BASE_SHIFT;
+    if (vlq > 0) {
+      digit |= VLQ_CONTINUATION_BIT;
+    }
+    encoded += VLQ_BASE64[digit];
+  } while (vlq > 0);
+  return encoded;
+}
+function decodeVLQ(encoded, start = 0) {
+  let vlq = 0;
+  let shift = 0;
+  let continuation = true;
+  let i = start;
+  while (continuation && i < encoded.length) {
+    const char = encoded[i];
+    const digit = VLQ_BASE64.indexOf(char);
+    if (digit === -1) {
+      throw new Error(`Invalid VLQ character: ${char}`);
+    }
+    continuation = (digit & VLQ_CONTINUATION_BIT) !== 0;
+    vlq += (digit & VLQ_BASE_MASK) << shift;
+    shift += VLQ_BASE_SHIFT;
+    i++;
+  }
+  const value = vlq & 1 ? -(vlq >> 1) : vlq >> 1;
+  return { value, next: i };
+}
+function createSourceMap(options) {
+  const builder = new SourceMapBuilder(options);
+  return builder.toSourceMap();
+}
+function mergeSourceMaps(maps) {
+  const builder = new SourceMapBuilder();
+  let lineOffset = 0;
+  for (const map of maps) {
+    const sourceIndexMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < map.sources.length; i++) {
+      const newIndex = builder.addSource(
+        map.sources[i],
+        map.sourcesContent?.[i] ?? void 0
+      );
+      sourceIndexMap.set(i, newIndex);
+    }
+    const nameIndexMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < map.names.length; i++) {
+      const newIndex = builder.addName(map.names[i]);
+      nameIndexMap.set(i, newIndex);
+    }
+    const decodedMappings = decodeMappings(map.mappings);
+    for (let lineIndex = 0; lineIndex < decodedMappings.length; lineIndex++) {
+      const line = decodedMappings[lineIndex];
+      for (const segment of line) {
+        const sourceIndex = segment.sourceIndex !== void 0 ? sourceIndexMap.get(segment.sourceIndex) : void 0;
+        const nameIndex = segment.nameIndex !== void 0 ? nameIndexMap.get(segment.nameIndex) : void 0;
+        builder.addMapping(
+          lineIndex + lineOffset,
+          segment.generatedColumn,
+          sourceIndex,
+          segment.sourceLine,
+          segment.sourceColumn,
+          nameIndex
+        );
+      }
+    }
+    lineOffset += decodedMappings.length;
+  }
+  return builder.toSourceMap();
+}
+function decodeMappings(mappings) {
+  const lines = [];
+  const lineStrings = mappings.split(";");
+  let previousSourceIndex = 0;
+  let previousSourceLine = 0;
+  let previousSourceColumn = 0;
+  let previousNameIndex = 0;
+  for (const lineString of lineStrings) {
+    const line = [];
+    let previousGeneratedColumn = 0;
+    if (lineString) {
+      const segmentStrings = lineString.split(",");
+      for (const segmentString of segmentStrings) {
+        if (!segmentString) continue;
+        const segment = { generatedColumn: 0 };
+        let pos = 0;
+        const col = decodeVLQ(segmentString, pos);
+        segment.generatedColumn = previousGeneratedColumn + col.value;
+        previousGeneratedColumn = segment.generatedColumn;
+        pos = col.next;
+        if (pos < segmentString.length) {
+          const src = decodeVLQ(segmentString, pos);
+          segment.sourceIndex = previousSourceIndex + src.value;
+          previousSourceIndex = segment.sourceIndex;
+          pos = src.next;
+          const srcLine = decodeVLQ(segmentString, pos);
+          segment.sourceLine = previousSourceLine + srcLine.value;
+          previousSourceLine = segment.sourceLine;
+          pos = srcLine.next;
+          const srcCol = decodeVLQ(segmentString, pos);
+          segment.sourceColumn = previousSourceColumn + srcCol.value;
+          previousSourceColumn = segment.sourceColumn;
+          pos = srcCol.next;
+          if (pos < segmentString.length) {
+            const name = decodeVLQ(segmentString, pos);
+            segment.nameIndex = previousNameIndex + name.value;
+            previousNameIndex = segment.nameIndex;
+          }
+        }
+        line.push(segment);
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function applySourceMap(map, line, column) {
+  const decodedMappings = decodeMappings(map.mappings);
+  if (line >= decodedMappings.length) {
+    return null;
+  }
+  const lineMappings = decodedMappings[line];
+  let bestSegment = null;
+  for (const segment of lineMappings) {
+    if (segment.generatedColumn <= column) {
+      bestSegment = segment;
+    } else {
+      break;
+    }
+  }
+  if (!bestSegment || bestSegment.sourceIndex === void 0) {
+    return null;
+  }
+  return {
+    source: map.sources[bestSegment.sourceIndex] ?? null,
+    line: bestSegment.sourceLine ?? 0,
+    column: bestSegment.sourceColumn ?? 0,
+    name: bestSegment.nameIndex !== void 0 ? map.names[bestSegment.nameIndex] ?? null : null
+  };
+}
+
+// src/compiler.ts
+function compile(options) {
+  const warnings = [];
+  const errors = [];
+  let config = {};
+  if (options.json) {
+    if (typeof options.json === "string") {
+      try {
+        config = JSON.parse(options.json);
+      } catch (e) {
+        errors.push({
+          code: "INVALID_JSON",
+          message: `Failed to parse JSON config: ${e.message}`
+        });
+      }
+    } else {
+      config = options.json;
+    }
+  }
+  const isComponent = options.isComponent ?? config.component ?? false;
+  let templateResult = null;
+  if (options.axml) {
+    templateResult = compileAXML(options.axml, {
+      filename: options.filename ? `${options.filename}.axml` : void 0,
+      components: { ...config.usingComponents, ...options.components }
+    });
+    warnings.push(...templateResult.warnings.map((w) => ({ message: w })));
+    errors.push(...templateResult.errors.map((e) => ({ code: "AXML_ERROR", message: e })));
+  }
+  let styleResult = null;
+  if (options.acss) {
+    styleResult = compileACSS(options.acss, {
+      filename: options.filename ? `${options.filename}.acss` : void 0
+    });
+    warnings.push(...styleResult.warnings.map((w) => ({ message: w })));
+    errors.push(...styleResult.errors.map((e) => ({ code: "ACSS_ERROR", message: e })));
+  }
+  const generatorOptions = {
+    isComponent,
+    minify: options.minify ?? false,
+    target: options.target ?? "es2020",
+    sourceMap: options.sourceMap ?? false,
+    filename: options.filename
+  };
+  const code = generateCode({
+    template: templateResult,
+    styles: styleResult,
+    config,
+    js: options.js
+  }, generatorOptions);
+  let map;
+  if (options.sourceMap && options.filename) {
+    map = createSourceMap({
+      file: options.filename,
+      sources: [
+        options.axml ? `${options.filename}.axml` : null,
+        options.acss ? `${options.filename}.acss` : null,
+        options.js ? `${options.filename}.js` : null
+      ].filter(Boolean)
+    });
+  }
+  return {
+    code,
+    css: styleResult?.css ?? "",
+    config,
+    map,
+    warnings,
+    errors,
+    templateAst: templateResult?.ast,
+    styleAst: styleResult?.ast
+  };
+}
+function validate(result) {
+  return result.errors.length === 0;
+}
+function formatErrors(result) {
+  if (result.errors.length === 0) return "";
+  return result.errors.map((error) => {
+    let msg = `[${error.code}] ${error.message}`;
+    if (error.loc) {
+      msg += ` at line ${error.loc.line}, column ${error.loc.column}`;
+    }
+    return msg;
+  }).join("\n");
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SourceMapBuilder,
+  VERSION,
+  applySourceMap,
+  compile,
+  compileACSS,
+  compileAXML,
+  createSourceMap,
+  formatErrors,
+  generateCode,
+  mergeSourceMaps,
+  parseACSS,
+  parseAXML,
+  validate
+});