@frontiers-labs/argon 0.4.0

package/dist/parser.js

@@ -0,0 +1,714 @@
+import ts from 'typescript';
+class ParseError extends Error {
+    node;
+    constructor(msg, node) {
+        super(msg);
+        this.node = node;
+    }
+}
+// ── Entry point ────────────────────────────────────────────────────────────────
+export function parseModule(source, fileName) {
+    const sf = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    const interfaces = [];
+    const dataConsts = [];
+    const functions = [];
+    const jsFunctions = [];
+    let component = null;
+    let stylesConstName = null;
+    let stylesConstText = '';
+    let functionComponent = null;
+    for (const stmt of sf.statements) {
+        if (ts.isImportDeclaration(stmt))
+            continue;
+        if (ts.isInterfaceDeclaration(stmt)) {
+            interfaces.push(parseInterface(stmt, source));
+            continue;
+        }
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (!decl.initializer)
+                    continue;
+                if (ts.isObjectLiteralExpression(decl.initializer)) {
+                    const name = decl.name.text;
+                    dataConsts.push({ name, value: parseLiteral(decl.initializer) });
+                }
+                // Capture top-level styles const: const styles = css`...`
+                if (ts.isTaggedTemplateExpression(decl.initializer) ||
+                    ts.isNoSubstitutionTemplateLiteral(decl.initializer)) {
+                    const name = ts.isIdentifier(decl.name) ? decl.name.text : '';
+                    if (name) {
+                        stylesConstName = name;
+                        stylesConstText = extractTemplateText(decl.initializer);
+                    }
+                }
+            }
+            continue;
+        }
+        if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+            const tagName = extractComponentTagName(stmt);
+            if (tagName) {
+                functionComponent = { fn: stmt, tagName };
+            }
+            else if (hasDomParams(stmt)) {
+                // Functions with DOM-typed params are JS-only — skip IR parsing entirely.
+                jsFunctions.push({ name: stmt.name.text, source: source.slice(stmt.pos, stmt.end).trim() });
+            }
+            else {
+                try {
+                    functions.push(parseFunction(stmt, source));
+                }
+                catch {
+                    jsFunctions.push({ name: stmt.name.text, source: source.slice(stmt.pos, stmt.end).trim() });
+                }
+            }
+            continue;
+        }
+        if (ts.isClassDeclaration(stmt)) {
+            const tagName = extractComponentTagName(stmt);
+            if (tagName) {
+                component = parseClass(stmt, tagName, source, sf);
+            }
+            continue;
+        }
+    }
+    if (!component && functionComponent) {
+        component = parseFunctionComponent(functionComponent.fn, functionComponent.tagName, stylesConstName, stylesConstText, source);
+    }
+    if (!component)
+        throw new ParseError('No component found (expected @component class or exported PascalCase function)');
+    return { sourceFile: fileName, interfaces, dataConsts, functions, jsFunctions, component };
+}
+// ── Decorator ──────────────────────────────────────────────────────────────────
+function extractComponentTagName(cls) {
+    // ts.canHaveDecorators returns false for function declarations even though the
+    // parser captures decorators in modifiers. Read them directly.
+    const mods = ts.canHaveDecorators(cls)
+        ? ts.getDecorators(cls) ?? []
+        : cls.modifiers ?? [];
+    for (const mod of mods) {
+        if (mod.kind !== ts.SyntaxKind.Decorator)
+            continue;
+        const dec = mod;
+        if (ts.isCallExpression(dec.expression) &&
+            ts.isIdentifier(dec.expression.expression) &&
+            dec.expression.expression.text === 'component' &&
+            dec.expression.arguments.length >= 1) {
+            const arg = dec.expression.arguments[0];
+            if (ts.isStringLiteral(arg))
+                return arg.text;
+        }
+    }
+    return null;
+}
+// ── Interface ──────────────────────────────────────────────────────────────────
+function parseInterface(node, _src) {
+    const fields = [];
+    for (const member of node.members) {
+        if (ts.isPropertySignature(member) && member.name) {
+            fields.push({
+                name: member.name.text,
+                type: member.type ? parseType(member.type) : { kind: 'unknown' },
+                optional: !!member.questionToken,
+            });
+        }
+    }
+    return { name: node.name.text, fields };
+}
+// ── Data const ────────────────────────────────────────────────────────────────
+function parseLiteral(node) {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return { kind: 'string', value: node.text };
+    }
+    if (ts.isNumericLiteral(node)) {
+        return { kind: 'number', value: Number(node.text) };
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return { kind: 'boolean', value: true };
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return { kind: 'boolean', value: false };
+    // Negative number: -42
+    if (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(node.operand)) {
+        return { kind: 'number', value: -Number(node.operand.text) };
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return { kind: 'array', elements: node.elements.map(parseLiteral) };
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const properties = [];
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop) && prop.initializer) {
+                const key = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : '';
+                if (key)
+                    properties.push({ key, value: parseLiteral(prop.initializer) });
+            }
+        }
+        return { kind: 'object', properties };
+    }
+    // Template literal used as a string value (e.g. inside object)
+    if (ts.isAsExpression(node))
+        return parseLiteral(node.expression);
+    throw new ParseError(`Unsupported literal node: ${ts.SyntaxKind[node.kind]}`, node);
+}
+// ── Type ───────────────────────────────────────────────────────────────────────
+function parseType(node) {
+    if (ts.isTypeReferenceNode(node)) {
+        const name = ts.isIdentifier(node.typeName) ? node.typeName.text : '';
+        if (name === 'Record' && node.typeArguments?.length === 2) {
+            return { kind: 'record', key: parseType(node.typeArguments[0]), value: parseType(node.typeArguments[1]) };
+        }
+        if (name === 'Array' && node.typeArguments?.length === 1) {
+            return { kind: 'array', element: parseType(node.typeArguments[0]) };
+        }
+        return { kind: 'named', name };
+    }
+    if (ts.isArrayTypeNode(node)) {
+        return { kind: 'array', element: parseType(node.elementType) };
+    }
+    if (ts.isTupleTypeNode(node)) {
+        return { kind: 'tuple', elements: node.elements.map(e => parseType(e)) };
+    }
+    if (ts.isTypeLiteralNode(node)) {
+        const fields = [];
+        for (const m of node.members) {
+            if (ts.isPropertySignature(m) && m.name) {
+                fields.push({
+                    name: m.name.text,
+                    type: m.type ? parseType(m.type) : { kind: 'unknown' },
+                    optional: !!m.questionToken,
+                });
+            }
+        }
+        return { kind: 'object', fields };
+    }
+    switch (node.kind) {
+        case ts.SyntaxKind.StringKeyword: return { kind: 'string' };
+        case ts.SyntaxKind.NumberKeyword: return { kind: 'number' };
+        case ts.SyntaxKind.BooleanKeyword: return { kind: 'boolean' };
+        case ts.SyntaxKind.VoidKeyword: return { kind: 'void' };
+        default: return { kind: 'unknown' };
+    }
+}
+// ── Function ───────────────────────────────────────────────────────────────────
+function parseFunction(node, source) {
+    const name = node.name.text;
+    const params = (node.parameters ?? []).map(p => ({
+        name: ts.isIdentifier(p.name) ? p.name.text : '?',
+        type: p.type ? parseType(p.type) : { kind: 'unknown' },
+    }));
+    const returnType = node.type ? parseType(node.type) : { kind: 'unknown' };
+    const body = node.body
+        ? node.body.statements.flatMap(s => parseStatement(s))
+        : [];
+    const bodySource = (() => {
+        if (!node.body)
+            return '';
+        const bodyText = source.slice(node.body.pos, node.body.end);
+        const open = bodyText.indexOf('{');
+        const close = bodyText.lastIndexOf('}');
+        return open !== -1 ? bodyText.slice(open + 1, close).trim() : '';
+    })();
+    return { name, params, returnType, bodySource, body };
+}
+// ── Statements ─────────────────────────────────────────────────────────────────
+function parseStatement(node) {
+    if (ts.isVariableStatement(node)) {
+        return node.declarationList.declarations.flatMap(decl => {
+            if (!decl.initializer)
+                return [];
+            const names = extractBindingNames(decl.name);
+            return [{ kind: 'const', names, init: parseExpr(decl.initializer) }];
+        });
+    }
+    if (ts.isReturnStatement(node) && node.expression) {
+        return [{ kind: 'return', value: parseExpr(node.expression) }];
+    }
+    if (ts.isExpressionStatement(node)) {
+        return [{ kind: 'expr_stmt', expr: parseExpr(node.expression) }];
+    }
+    throw new ParseError(`Unsupported statement: ${ts.SyntaxKind[node.kind]}`, node);
+}
+function extractBindingNames(name) {
+    if (ts.isIdentifier(name))
+        return [name.text];
+    if (ts.isArrayBindingPattern(name)) {
+        return name.elements.flatMap(el => ts.isBindingElement(el) ? extractBindingNames(el.name) : []);
+    }
+    if (ts.isObjectBindingPattern(name)) {
+        return name.elements.flatMap(el => extractBindingNames(el.name));
+    }
+    return [];
+}
+// ── Expressions ────────────────────────────────────────────────────────────────
+function parseExpr(node) {
+    // Parenthesized expression — unwrap
+    if (ts.isParenthesizedExpression(node))
+        return parseExpr(node.expression);
+    // Type assertion: expr as T — drop the cast
+    if (ts.isAsExpression(node))
+        return { kind: 'as_expr', expr: parseExpr(node.expression) };
+    // Literals
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return { kind: 'literal', value: { kind: 'string', value: node.text } };
+    }
+    if (ts.isNumericLiteral(node)) {
+        return { kind: 'literal', value: { kind: 'number', value: Number(node.text) } };
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword) {
+        return { kind: 'literal', value: { kind: 'boolean', value: true } };
+    }
+    if (node.kind === ts.SyntaxKind.FalseKeyword) {
+        return { kind: 'literal', value: { kind: 'boolean', value: false } };
+    }
+    // -N
+    if (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(node.operand)) {
+        return { kind: 'literal', value: { kind: 'number', value: -Number(node.operand.text) } };
+    }
+    // this.field
+    if (ts.isPropertyAccessExpression(node) &&
+        node.expression.kind === ts.SyntaxKind.ThisKeyword) {
+        return { kind: 'self_field', field: node.name.text };
+    }
+    // a.b
+    if (ts.isPropertyAccessExpression(node)) {
+        return {
+            kind: 'prop_access',
+            object: parseExpr(node.expression),
+            property: node.name.text,
+        };
+    }
+    // a[b]
+    if (ts.isElementAccessExpression(node)) {
+        return {
+            kind: 'index',
+            object: parseExpr(node.expression),
+            index: parseExpr(node.argumentExpression),
+        };
+    }
+    // Identifier
+    if (ts.isIdentifier(node))
+        return { kind: 'local_ref', name: node.text };
+    // Method call: receiver.method(args)
+    if (ts.isCallExpression(node) &&
+        ts.isPropertyAccessExpression(node.expression)) {
+        const pae = node.expression;
+        // Check for Math.min / Math.max as standalone calls
+        if (ts.isIdentifier(pae.expression) &&
+            pae.expression.text === 'Math') {
+            const callee = `Math.${pae.name.text}`;
+            return { kind: 'call', callee, args: node.arguments.map(parseExpr) };
+        }
+        return {
+            kind: 'method_call',
+            receiver: parseExpr(pae.expression),
+            method: pae.name.text,
+            args: node.arguments.map(parseExpr),
+        };
+    }
+    // Standalone call: fn(args)
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+        return {
+            kind: 'call',
+            callee: node.expression.text,
+            args: node.arguments.map(parseExpr),
+        };
+    }
+    // Spread: ...x
+    if (ts.isSpreadElement(node)) {
+        return { kind: 'spread', expr: parseExpr(node.expression) };
+    }
+    // Binary: a OP b
+    if (ts.isBinaryExpression(node)) {
+        const op = node.operatorToken.kind;
+        if (op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsToken) {
+            return { kind: 'eq', left: parseExpr(node.left), right: parseExpr(node.right) };
+        }
+        const opStr = binaryOpStr(op);
+        return { kind: 'binary', op: opStr, left: parseExpr(node.left), right: parseExpr(node.right) };
+    }
+    // Ternary: a ? b : c
+    if (ts.isConditionalExpression(node)) {
+        return {
+            kind: 'ternary',
+            condition: parseExpr(node.condition),
+            then: parseExpr(node.whenTrue),
+            else: parseExpr(node.whenFalse),
+        };
+    }
+    // Arrow function: (params) => body
+    if (ts.isArrowFunction(node)) {
+        const params = node.parameters.map((p, i) => {
+            if (ts.isArrayBindingPattern(p.name)) {
+                const destructured = p.name.elements.flatMap(el => ts.isBindingElement(el) && ts.isIdentifier(el.name) ? [el.name.text] : []);
+                return { name: `_arg${i}`, destructured };
+            }
+            const name = ts.isIdentifier(p.name) ? p.name.text : `_arg${i}`;
+            return { name };
+        });
+        if (ts.isBlock(node.body)) {
+            const body = node.body.statements.flatMap(parseStatement);
+            return { kind: 'arrow_fn', params, body };
+        }
+        return { kind: 'arrow_fn', params, body: parseExpr(node.body) };
+    }
+    // Array literal
+    if (ts.isArrayLiteralExpression(node)) {
+        return { kind: 'array_literal', elements: node.elements.map(parseExpr) };
+    }
+    // Object literal
+    if (ts.isObjectLiteralExpression(node)) {
+        const properties = [];
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop) && prop.initializer) {
+                const key = ts.isIdentifier(prop.name) ? prop.name.text
+                    : ts.isStringLiteral(prop.name) ? prop.name.text : '';
+                if (key)
+                    properties.push({ key, value: parseExpr(prop.initializer) });
+            }
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                const key = prop.name.text;
+                properties.push({ key, value: { kind: 'local_ref', name: key } });
+            }
+        }
+        return { kind: 'object_literal', properties };
+    }
+    // Template expression (non-tagged): `text ${expr} text`
+    if (ts.isTemplateExpression(node)) {
+        const parts = [{ kind: 'static', text: node.head.text }];
+        for (const span of node.templateSpans) {
+            parts.push({ kind: 'expr', expr: parseExpr(span.expression) });
+            parts.push({ kind: 'static', text: span.literal.text });
+        }
+        return { kind: 'template_str', parts };
+    }
+    throw new ParseError(`Unsupported expression: ${ts.SyntaxKind[node.kind]} — ` +
+        `add support in parseExpr() for this pattern`, node);
+}
+function binaryOpStr(kind) {
+    switch (kind) {
+        case ts.SyntaxKind.PlusToken: return '+';
+        case ts.SyntaxKind.MinusToken: return '-';
+        case ts.SyntaxKind.AsteriskToken: return '*';
+        case ts.SyntaxKind.SlashToken: return '/';
+        case ts.SyntaxKind.PercentToken: return '%';
+        case ts.SyntaxKind.BarBarToken: return '||';
+        case ts.SyntaxKind.AmpersandAmpersandToken: return '&&';
+        case ts.SyntaxKind.LessThanToken: return '<';
+        case ts.SyntaxKind.GreaterThanToken: return '>';
+        case ts.SyntaxKind.LessThanEqualsToken: return '<=';
+        case ts.SyntaxKind.GreaterThanEqualsToken: return '>=';
+        case ts.SyntaxKind.ExclamationEqualsEqualsToken: return '!==';
+        default: throw new ParseError(`Unsupported binary operator: ${ts.SyntaxKind[kind]}`);
+    }
+}
+// ── Class ──────────────────────────────────────────────────────────────────────
+function parseClass(cls, tagName, source, sf) {
+    const className = cls.name?.text ?? 'UnknownComponent';
+    const props = [];
+    let styles = '';
+    let renderBindings = [];
+    let renderTemplate = [];
+    let eventBindings = [];
+    let renderBodySource = '';
+    let hydrateBodySource = '';
+    const privateMethods = [];
+    const printer = ts.createPrinter({ removeComments: false });
+    for (const member of cls.members) {
+        // Static readonly styles
+        if (ts.isPropertyDeclaration(member) &&
+            hasModifier(member, ts.SyntaxKind.StaticKeyword) &&
+            ts.isIdentifier(member.name) &&
+            member.name.text === 'styles' &&
+            member.initializer) {
+            styles = extractTemplateText(member.initializer);
+            continue;
+        }
+        // Private fields (#period, etc.) — skip; not needed in IR
+        if (ts.isPropertyDeclaration(member) && ts.isPrivateIdentifier(member.name)) {
+            continue;
+        }
+        // Instance props (public class fields with defaults)
+        if (ts.isPropertyDeclaration(member) &&
+            ts.isIdentifier(member.name) &&
+            !hasModifier(member, ts.SyntaxKind.StaticKeyword) &&
+            member.initializer) {
+            props.push({
+                name: member.name.text,
+                type: member.type ? parseType(member.type) : { kind: 'unknown' },
+                defaultValue: parseLiteral(member.initializer),
+            });
+            continue;
+        }
+        // render() method
+        if (ts.isMethodDeclaration(member) &&
+            ts.isIdentifier(member.name) &&
+            member.name.text === 'render' &&
+            member.body) {
+            const parsed = parseRenderBody(member.body, className, source);
+            renderBindings = parsed.bindings;
+            renderTemplate = parsed.template;
+            eventBindings = parsed.eventBindings;
+            const renderText = source.slice(member.body.pos, member.body.end);
+            const rOpen = renderText.indexOf('{');
+            const rClose = renderText.lastIndexOf('}');
+            renderBodySource = rOpen !== -1 ? renderText.slice(rOpen + 1, rClose).trim() : '';
+            continue;
+        }
+        // hydrate() method
+        if (ts.isMethodDeclaration(member) &&
+            ts.isIdentifier(member.name) &&
+            member.name.text === 'hydrate' &&
+            member.body) {
+            const hydrateText = source.slice(member.body.pos, member.body.end);
+            const hyOpen = hydrateText.indexOf('{');
+            const hyClose = hydrateText.lastIndexOf('}');
+            hydrateBodySource = hyOpen !== -1 ? hydrateText.slice(hyOpen + 1, hyClose).trim() : '';
+            continue;
+        }
+        // Private methods (#name)
+        if (ts.isMethodDeclaration(member) &&
+            ts.isPrivateIdentifier(member.name)) {
+            const name = member.name.text.slice(1); // strip leading #
+            const methodSrc = printer.printNode(ts.EmitHint.Unspecified, member, sf);
+            privateMethods.push({ name, source: methodSrc });
+            continue;
+        }
+    }
+    return {
+        tagName,
+        className,
+        props,
+        styles,
+        renderBindings,
+        renderTemplate,
+        eventBindings,
+        renderBodySource,
+        hydrateBodySource,
+        privateMethods,
+    };
+}
+function parseFunctionComponent(fn, tagName, stylesConstName, stylesText, source) {
+    const funcName = fn.name.text;
+    const props = [];
+    const param = fn.parameters[0];
+    if (param && ts.isObjectBindingPattern(param.name)) {
+        const typeFields = new Map();
+        if (param.type && ts.isTypeLiteralNode(param.type)) {
+            for (const member of param.type.members) {
+                if (ts.isPropertySignature(member) && member.name && member.type) {
+                    typeFields.set(member.name.text, parseType(member.type));
+                }
+            }
+        }
+        for (const el of param.name.elements) {
+            if (!ts.isBindingElement(el) || !ts.isIdentifier(el.name))
+                continue;
+            const name = el.name.text;
+            const type = typeFields.get(name) ?? { kind: 'unknown' };
+            const defaultValue = el.initializer
+                ? parseLiteral(el.initializer)
+                : { kind: 'string', value: '' };
+            props.push({ name, type, defaultValue });
+        }
+    }
+    if (!fn.body)
+        throw new ParseError('Function component must have a body', fn);
+    const { bindings, template, eventBindings } = parseRenderBody(fn.body, funcName, source);
+    const propNames = new Set(props.map(p => p.name));
+    const stylesNames = new Set(stylesConstName ? [stylesConstName] : []);
+    const renderBindings = bindings.map(b => ({
+        name: b.name,
+        init: rewriteExprRefs(b.init, propNames, stylesNames),
+    }));
+    const renderTemplate = template.map(node => node.kind === 'expr'
+        ? { kind: 'expr', expr: rewriteExprRefs(node.expr, propNames, stylesNames) }
+        : node);
+    return {
+        tagName,
+        className: funcName,
+        props,
+        styles: stylesText,
+        renderBindings,
+        renderTemplate,
+        eventBindings,
+        renderBodySource: '',
+        hydrateBodySource: '',
+        privateMethods: [],
+    };
+}
+function rewriteExprRefs(expr, propNames, stylesNames) {
+    const rw = (e) => rewriteExprRefs(e, propNames, stylesNames);
+    switch (expr.kind) {
+        case 'local_ref':
+            if (propNames.has(expr.name))
+                return { kind: 'self_field', field: expr.name };
+            if (stylesNames.has(expr.name))
+                return { kind: 'local_ref', name: '__styles__' };
+            return expr;
+        case 'self_field':
+        case 'literal':
+            return expr;
+        case 'as_expr':
+            return { kind: 'as_expr', expr: rw(expr.expr) };
+        case 'prop_access':
+            return { kind: 'prop_access', object: rw(expr.object), property: expr.property };
+        case 'index':
+            return { kind: 'index', object: rw(expr.object), index: rw(expr.index) };
+        case 'call':
+            return { kind: 'call', callee: expr.callee, args: expr.args.map(rw) };
+        case 'method_call':
+            return { kind: 'method_call', receiver: rw(expr.receiver), method: expr.method, args: expr.args.map(rw) };
+        case 'binary':
+            return { kind: 'binary', op: expr.op, left: rw(expr.left), right: rw(expr.right) };
+        case 'eq':
+            return { kind: 'eq', left: rw(expr.left), right: rw(expr.right) };
+        case 'ternary':
+            return { kind: 'ternary', condition: rw(expr.condition), then: rw(expr.then), else: rw(expr.else) };
+        case 'arrow_fn': {
+            const body = Array.isArray(expr.body)
+                ? expr.body.map(s => rewriteStmtRefs(s, propNames, stylesNames))
+                : rw(expr.body);
+            return { kind: 'arrow_fn', params: expr.params, body };
+        }
+        case 'array_literal':
+            return { kind: 'array_literal', elements: expr.elements.map(rw) };
+        case 'object_literal':
+            return { kind: 'object_literal', properties: expr.properties.map(p => ({ key: p.key, value: rw(p.value) })) };
+        case 'spread':
+            return { kind: 'spread', expr: rw(expr.expr) };
+        case 'template_str':
+            return {
+                kind: 'template_str',
+                parts: expr.parts.map(p => p.kind === 'expr' ? { kind: 'expr', expr: rw(p.expr) } : p),
+            };
+    }
+}
+function rewriteStmtRefs(stmt, propNames, stylesNames) {
+    const rw = (e) => rewriteExprRefs(e, propNames, stylesNames);
+    if (stmt.kind === 'const')
+        return { kind: 'const', names: stmt.names, init: rw(stmt.init) };
+    if (stmt.kind === 'return')
+        return { kind: 'return', value: rw(stmt.value) };
+    return { kind: 'expr_stmt', expr: rw(stmt.expr) };
+}
+const DOM_TYPES = new Set([
+    'Element', 'HTMLElement', 'EventTarget', 'ShadowRoot', 'Document', 'Window', 'Node',
+    'Event', 'MouseEvent', 'KeyboardEvent', 'SubmitEvent', 'InputEvent', 'FocusEvent',
+    'CustomEvent', 'MutationObserver', 'ResizeObserver', 'IntersectionObserver',
+]);
+function hasDomParams(fn) {
+    return fn.parameters.some(p => {
+        if (!p.type || !ts.isTypeReferenceNode(p.type) || !ts.isIdentifier(p.type.typeName))
+            return false;
+        const name = p.type.typeName.text;
+        return DOM_TYPES.has(name) || name.startsWith('HTML') || name.startsWith('SVG');
+    });
+}
+function hasModifier(node, kind) {
+    return !!ts.getModifiers(node)?.some(m => m.kind === kind);
+}
+function extractTemplateText(node) {
+    // css`...` or just a template literal
+    if (ts.isTaggedTemplateExpression(node)) {
+        return extractTemplateText(node.template);
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    if (ts.isStringLiteral(node))
+        return node.text;
+    return '';
+}
+function parseRenderBody(body, componentClassName, source) {
+    const bindings = [];
+    let template = [];
+    let eventBindings = [];
+    for (const stmt of body.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (!decl.initializer)
+                    continue;
+                const name = ts.isIdentifier(decl.name) ? decl.name.text : '';
+                if (name) {
+                    bindings.push({ name, init: parseExpr(decl.initializer) });
+                }
+            }
+            continue;
+        }
+        if (ts.isReturnStatement(stmt) && stmt.expression) {
+            const parsed = parseHtmlTemplate(stmt.expression, componentClassName, source);
+            template = parsed.nodes;
+            eventBindings = parsed.eventBindings;
+        }
+    }
+    return { bindings, template, eventBindings };
+}
+const eventAttrRe = /@(\w+)="$/;
+function parseHtmlTemplate(node, componentClassName, source) {
+    let tmpl;
+    if (ts.isTaggedTemplateExpression(node)) {
+        tmpl = node.template;
+    }
+    else if (ts.isTemplateExpression(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        tmpl = node;
+    }
+    else {
+        throw new ParseError('render() must return an html`` tagged template literal');
+    }
+    if (ts.isNoSubstitutionTemplateLiteral(tmpl)) {
+        return { nodes: [{ kind: 'static', text: tmpl.text }], eventBindings: [] };
+    }
+    const te = tmpl;
+    const nodes = [];
+    const eventBindings = [];
+    let nextIsEventHandler = false;
+    // Emit a chunk of static text, checking if it ends with @event="
+    // If so, records an event binding slot and injects data-eid="N".
+    // Returns true when the next expression is an event handler.
+    function pushText(text) {
+        const m = text.match(eventAttrRe);
+        if (m) {
+            const elementId = eventBindings.length;
+            const trimmed = text.slice(0, -m[0].length) + `data-e${elementId}`;
+            if (trimmed)
+                nodes.push({ kind: 'static', text: trimmed });
+            eventBindings.push({ eventName: m[1], handlerSource: '', elementId });
+            return true;
+        }
+        if (text)
+            nodes.push({ kind: 'static', text });
+        return false;
+    }
+    nextIsEventHandler = pushText(te.head.text);
+    for (const span of te.templateSpans) {
+        if (nextIsEventHandler) {
+            // Capture raw handler source; strip the closing `"` from the following literal.
+            const handlerSource = source.slice(span.expression.pos, span.expression.end).trim();
+            eventBindings[eventBindings.length - 1].handlerSource = handlerSource;
+            const litText = span.literal.text.startsWith('"')
+                ? span.literal.text.slice(1)
+                : span.literal.text;
+            nextIsEventHandler = pushText(litText);
+        }
+        else {
+            // Regular expression: ClassName.styles → __styles__, everything else as-is.
+            const expr = span.expression;
+            if (ts.isPropertyAccessExpression(expr) &&
+                ts.isIdentifier(expr.expression) &&
+                expr.expression.text === componentClassName &&
+                expr.name.text === 'styles') {
+                nodes.push({ kind: 'expr', expr: { kind: 'local_ref', name: '__styles__' } });
+            }
+            else {
+                nodes.push({ kind: 'expr', expr: parseExpr(expr) });
+            }
+            nextIsEventHandler = pushText(span.literal.text);
+        }
+    }
+    return { nodes, eventBindings };
+}
+//# sourceMappingURL=parser.js.map