@qt-test/apex-dsl-compiler 0.1.0

package/dist/chunk-GQ3PJZ2P.mjs

@@ -0,0 +1,836 @@
+// 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");
+}
+
+export {
+  parseAXML,
+  compileAXML
+};