@vesk/compiler 0.2.8 → 0.2.9

package/dist/vesk-plugin.js

@@ -31,6 +31,18 @@ function isIdentStartCode(code) {
 function isIdentCharCode(code) {
     return isIdentStartCode(code) || (code >= 48 && code <= 57);
 }
+function getQualifiedJSXName(object) {
+    if (!object)
+        return object;
+    if (object.type === 'JSXIdentifier')
+        return object.name;
+    if (object.type === 'JSXNamespacedName')
+        return object.namespace.name + ':' + object.name.name;
+    if (object.type === 'JSXMemberExpression') {
+        return getQualifiedJSXName(object.object) + '.' + getQualifiedJSXName(object.property);
+    }
+    return null;
+}
 function looksLikeGenericArrowAt(input, pos) {
     let i = pos + 1;
     while (i < input.length && isWsChar(input.charCodeAt(i)))
@@ -114,6 +126,11 @@ function looksLikeTypeAssertionAt(input, pos) {
 function isWsChar(code) {
     return code === 32 || code === 9 || code === 10 || code === 13 || code === 12;
 }
+function skipWs(input, i) {
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    return i;
+}
 function isStyleBoundary(code) {
     return isWsChar(code) || code === 62 || code === 47 || code === 123;
 }
@@ -148,6 +165,9 @@ export function VeskParserPlugin(config = {}) {
             #closeTagName = null;
             #jsxStartsStatement = false;
             #inTSTypeDecl = false;
+            #pendingChildStatement = false;
+            /** per-statement context-stack depths (LIFO — child statements may nest) */
+            #jsxChildDepthStack = [];
             constructor(options, input) {
                 super(options, input);
             }
@@ -155,7 +175,292 @@ export function VeskParserPlugin(config = {}) {
                 const ctx = this.curContext();
                 return ctx && (ctx.token === '{' || ctx.token === 'function');
             }
+            #isJsxChildrenContext() {
+                const ctx = this.curContext();
+                return !!ctx && ctx.token === '<tag>...</tag>';
+            }
+            /**
+             * Determines whether the text starting at `this.pos` opens a
+             * statement-mode control-flow header (`if (`, `for (`, `while (`,
+             * `switch (`, `try {`, `do {`) among JSX children. Scans chars only —
+             * the paren body must balance and be followed by a `{` block.
+             */
+            #scansChildStatement() {
+                const input = this.input;
+                let i = this.pos;
+                while (i < input.length && isWsChar(input.charCodeAt(i)))
+                    i++;
+                if (i >= input.length || !isIdentStartCode(input.charCodeAt(i)))
+                    return false;
+                const wordStart = i;
+                while (i < input.length && isIdentCharCode(input.charCodeAt(i)))
+                    i++;
+                const word = input.slice(wordStart, i);
+                // Declaration statements (`const`/`let`/`var …;`) are also valid
+                // statement-mode element children. Recognise them by a `=` of
+                // assignment plus either a top-level `;` or a newline at depth 0
+                // (ASI-style). Bail out (stay text) when a closing JSX tag `</` is
+                // seen before a terminator: a real element-child statement never
+                // contains its parent's closing tag, while prose text like
+                // `<p>const value = 5 apples</p>` does.
+                if (word === 'const' || word === 'let' || word === 'var') {
+                    let depth = 0;
+                    let seenAssign = false;
+                    let q = i;
+                    while (q < input.length) {
+                        const c = input.charCodeAt(q);
+                        if (c === 34 || c === 39 || c === 96) { // " ' `
+                            const quote = c;
+                            let tplDepth = 0;
+                            q++;
+                            while (q < input.length) {
+                                const ch = input.charCodeAt(q);
+                                if (ch === 92) {
+                                    q += 2;
+                                    continue;
+                                }
+                                if (quote === 96 && ch === 36 && input.charCodeAt(q + 1) === 123) {
+                                    tplDepth++;
+                                    q += 2;
+                                    continue;
+                                }
+                                if (quote === 96 && ch === 125 && tplDepth > 0) {
+                                    tplDepth--;
+                                    q++;
+                                    continue;
+                                }
+                                if (ch === quote && tplDepth === 0) {
+                                    q++;
+                                    break;
+                                }
+                                q++;
+                            }
+                            continue;
+                        }
+                        if (c === 60 && input.charCodeAt(q + 1) === 47)
+                            return false; // '</' -> it's JSX text, not a statement
+                        if (c === 40 || c === 91 || c === 123)
+                            depth++;
+                        else if (c === 41 || c === 93 || c === 125)
+                            depth--;
+                        else if (c === 61 && depth === 0) { // '='
+                            const n2 = input.charCodeAt(q + 1);
+                            const n1 = q > 0 ? input.charCodeAt(q - 1) : 0;
+                            if (n2 !== 61 && n2 !== 62 && n1 !== 33 && n1 !== 60 && n1 !== 61)
+                                seenAssign = true; // not ==, =>, !=, <=, >=
+                        }
+                        else if (c === 59 && depth === 0)
+                            return true; // ';'
+                        else if ((c === 10 || c === 13) && depth === 0 && seenAssign)
+                            return true; // ASI at end of line
+                        q++;
+                    }
+                    return false;
+                }
+                // Bare expression statements (`console.log(x)`, `alert('hi')`,
+                // `doSomething(args)`) are also valid statement-mode element children.
+                // They are ambiguous with prose, so only treat them as code when they
+                // read like a standalone line of code — not a sentence:
+                //   * an identifier call chain (`console.log`, `foo?.bar`) with NO
+                //     whitespace before the `(` (prose writes `word (`, code writes
+                //     `word(`),
+                //   * a balanced `(...)` call,
+                //   * then a terminator — a top-level `;` or ASI newline — with no
+                //     bare word after the `)` before it (`doSomething(x) then more`
+                //     is prose; `doSomething(x)` on its own line is code).
+                // Bail out (stay text) when a closing JSX tag `</` is seen first, as
+                // a real child statement never contains its parent's closing tag.
+                if (isIdentStartCode(input.charCodeAt(wordStart))) {
+                    let q = i; // position just after the first identifier
+                    // member chain: `.foo` / `?.bar`, no surrounding whitespace
+                    while (q < input.length) {
+                        const c = input.charCodeAt(q);
+                        if (c === 46 /* . */) {
+                            q++;
+                        }
+                        else if (c === 63 /* ? */ && input.charCodeAt(q + 1) === 46) {
+                            q += 2;
+                        }
+                        else
+                            break;
+                        if (q >= input.length || !isIdentStartCode(input.charCodeAt(q)))
+                            return false;
+                        q++;
+                        while (q < input.length && isIdentCharCode(input.charCodeAt(q)))
+                            q++;
+                    }
+                    // must be a call: `(` with no whitespace before it
+                    if (input.charCodeAt(q) === 40 /* ( */) {
+                        let depth = 0;
+                        let callClosed = false;
+                        let s = q;
+                        while (s < input.length) {
+                            const c = input.charCodeAt(s);
+                            if (c === 34 || c === 39 || c === 96) { // " ' `
+                                const quote = c;
+                                let tplDepth = 0;
+                                s++;
+                                while (s < input.length) {
+                                    const ch = input.charCodeAt(s);
+                                    if (ch === 92) {
+                                        s += 2;
+                                        continue;
+                                    }
+                                    if (quote === 96 && ch === 36 && input.charCodeAt(s + 1) === 123) {
+                                        tplDepth++;
+                                        s += 2;
+                                        continue;
+                                    }
+                                    if (quote === 96 && ch === 125 && tplDepth > 0) {
+                                        tplDepth--;
+                                        s++;
+                                        continue;
+                                    }
+                                    if (ch === quote && tplDepth === 0) {
+                                        s++;
+                                        break;
+                                    }
+                                    s++;
+                                }
+                                continue;
+                            }
+                            if (c === 60 && input.charCodeAt(s + 1) === 47)
+                                return false; // '</'
+                            if (c === 40 || c === 91 || c === 123)
+                                depth++;
+                            else if (c === 41 || c === 93 || c === 125) {
+                                depth--;
+                                if (c === 41 && depth === 0) {
+                                    callClosed = true;
+                                    s++;
+                                    break;
+                                }
+                            }
+                            s++;
+                        }
+                        if (!callClosed)
+                            return false;
+                        // After the call, walk forward treating each character in turn so
+                        // we can tell "standalone statement ending in `;` / newline" from
+                        // "trailing prose on the same line". Chained member calls
+                        // (`.foo(...)`) and paren-groups are consumed; a bare word on the
+                        // same line before a newline/`;` means the child is a sentence.
+                        let d = 0;
+                        for (;;) {
+                            if (s >= input.length)
+                                return false;
+                            const c = input.charCodeAt(s);
+                            if (c === 60 && input.charCodeAt(s + 1) === 47)
+                                return false; // '</' -> prose
+                            if (c === 34 || c === 39 || c === 96) { // " ' `
+                                const quote = c;
+                                let tplDepth = 0;
+                                s++;
+                                while (s < input.length) {
+                                    const ch = input.charCodeAt(s);
+                                    if (ch === 92) {
+                                        s += 2;
+                                        continue;
+                                    }
+                                    if (quote === 96 && ch === 36 && input.charCodeAt(s + 1) === 123) {
+                                        tplDepth++;
+                                        s += 2;
+                                        continue;
+                                    }
+                                    if (quote === 96 && ch === 125 && tplDepth > 0) {
+                                        tplDepth--;
+                                        s++;
+                                        continue;
+                                    }
+                                    if (ch === quote && tplDepth === 0) {
+                                        s++;
+                                        break;
+                                    }
+                                    s++;
+                                }
+                                continue;
+                            }
+                            if (c === 40 || c === 91 || c === 123)
+                                d++;
+                            else if (c === 41 || c === 93 || c === 125)
+                                d--;
+                            else if (c === 59 && d === 0)
+                                return true; // ';' -> statement
+                            else if ((c === 10 || c === 13) && d === 0)
+                                return true; // ASI newline -> standalone
+                            else if (c === 46) { // member access `.foo`; may lead to another call
+                                s++;
+                                while (s < input.length && isIdentCharCode(input.charCodeAt(s)))
+                                    s++;
+                                continue;
+                            }
+                            else if (isIdentCharCode(c) || isIdentStartCode(c))
+                                return false; // bare word -> prose
+                            s++;
+                        }
+                    }
+                }
+                if (word !== 'if' && word !== 'for' && word !== 'while' && word !== 'switch' && word !== 'try' && word !== 'do')
+                    return false;
+                let p = i;
+                while (p < input.length && isWsChar(input.charCodeAt(p)))
+                    p++;
+                if (word === 'try' || word === 'do') {
+                    return input.charCodeAt(p) === 123; // '{'
+                }
+                if (input.charCodeAt(p) !== 40)
+                    return false; // '('
+                let depth = 1;
+                let q = p + 1;
+                while (q < input.length) {
+                    const c = input.charCodeAt(q);
+                    if (c === 34 || c === 39 || c === 96) {
+                        const quote = c;
+                        q++;
+                        while (q < input.length) {
+                            const ch = input.charCodeAt(q);
+                            if (ch === 92) {
+                                q += 2;
+                                continue;
+                            }
+                            if (ch === quote) {
+                                q++;
+                                break;
+                            }
+                            q++;
+                        }
+                        continue;
+                    }
+                    if (c === 40 || c === 91 || c === 123)
+                        depth++;
+                    else if (c === 41 || c === 93 || c === 125) {
+                        depth--;
+                        if (c === 41 && depth === 0)
+                            break;
+                    }
+                    q++;
+                }
+                if (q >= input.length)
+                    return false;
+                let r = q + 1;
+                while (r < input.length && isWsChar(input.charCodeAt(r)))
+                    r++;
+                return input.charCodeAt(r) === 123; // '{'
+            }
             readToken(code) {
+                if (this.#componentDepth > 0 && this.#isJsxChildrenContext() && this.#scansChildStatement()) {
+                    this.#pendingChildStatement = true;
+                    this.#jsxChildDepthStack.push(this.context.length);
+                    this.context.push(acorn.tokContexts.b_stat);
+                    if (isWsChar(code)) {
+                        this.skipSpace();
+                        this.start = this.pos;
+                        if (this.options.locations && typeof this.curPosition === 'function') {
+                            this.startLoc = this.curPosition();
+                        }
+                    }
+                    return super.readToken(this.input.codePointAt(this.pos));
+                }
                 if (this.#componentDepth > 0 && code === 60 && this.#isBlockContext()) {
                     const next = this.input.charCodeAt(this.pos + 1);
                     if (next === 47 || (next >= 65 && next <= 90) || (next >= 97 && next <= 122)) {
@@ -497,7 +802,67 @@ export function VeskParserPlugin(config = {}) {
                 if (prefix.startsWith('<style') && isStyleBoundary(prefix.charCodeAt(6))) {
                     return this.parseStyleElement(startPos, startLoc);
                 }
-                return super.jsx_parseElementAt(startPos, startLoc);
+                return this.#parseElementWithStatements(startPos, startLoc);
+            }
+            /**
+             * Parses an entire JSX element (or fragment) starting after `<`,
+             * mirroring the vendored acorn-jsx `jsx_parseElementAt` with an added
+             * statement-mode branch: when `#pendingChildStatement` is set (a
+             * control-flow header like `if (…) {` appeared where JSX children
+             * expect text), a real statement is parsed into the children array.
+             */
+            #parseElementWithStatements(startPos, startLoc) {
+                const node = this.startNodeAt(startPos, startLoc);
+                const children = [];
+                const openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);
+                let closingElement = null;
+                if (!openingElement.selfClosing) {
+                    contents: for (;;) {
+                        if (this.#pendingChildStatement) {
+                            this.#pendingChildStatement = false;
+                            const stmt = this.parseStatement(null);
+                            children.push(stmt);
+                            // Restore the JSX-children tokenizer and re-lex the trailing
+                            // token (lexed under the temporary b_stat context) as a JSX child.
+                            this.context.length = this.#jsxChildDepthStack.pop() ?? this.context.length;
+                            this.exprAllowed = true;
+                            this.pos = this.start;
+                            this.next();
+                            continue;
+                        }
+                        switch (this.type) {
+                            case tstt?.jsxTagStart:
+                                startPos = this.start;
+                                startLoc = this.startLoc;
+                                this.next();
+                                if (this.eat(tt.slash)) {
+                                    closingElement = this.jsx_parseClosingElementAt(startPos, startLoc);
+                                    break contents;
+                                }
+                                children.push(this.jsx_parseElementAt(startPos, startLoc));
+                                break;
+                            case tstt?.jsxText:
+                                children.push(this.parseExprAtom());
+                                break;
+                            case tt.braceL:
+                                children.push(this.jsx_parseExpressionContainer());
+                                break;
+                            default:
+                                this.unexpected();
+                        }
+                    }
+                    if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
+                        this.raise(closingElement.start, "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">");
+                    }
+                }
+                const fragmentOrElement = openingElement.name ? "Element" : "Fragment";
+                node["opening" + fragmentOrElement] = openingElement;
+                node["closing" + fragmentOrElement] = closingElement;
+                node.children = children;
+                if (this.type === tt.relational && this.value === "<") {
+                    this.raise(this.start, "Adjacent JSX elements must be wrapped in an enclosing tag");
+                }
+                return this.finishNode(node, "JSX" + fragmentOrElement);
             }
             jsx_parseOpeningElementAt(startPos, startLoc) {
                 // Manual implementation that treats HTML void elements as

package/dist/vsk-imports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vsk-imports.d.ts","sourceRoot":"","sources":["../src/vsk-imports.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQjE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAahE;AA0BD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAUrF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAoBhE"}
+{"version":3,"file":"vsk-imports.d.ts","sourceRoot":"","sources":["../src/vsk-imports.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQjE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAahE;AA0BD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAUrF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAKnD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAsBhE"}

package/dist/vsk-imports.js

@@ -127,7 +127,9 @@ export function stripTypeImport(importSrc) {
         return null;
     const specs = stmt.specifiers || [];
     const kept = specs.filter((s) => s.importKind !== 'type');
-    if (kept.length === 0)
+    // A side-effect import (`import './x'`) has no specifiers at all — it is NOT
+    // type-only and must survive so both bundles run its module-level code.
+    if (specs.length > 0 && kept.length === 0)
         return null;
     if (kept.length === specs.length)
         return importSrc;

package/dist/vsk-tsx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vsk-tsx.d.ts","sourceRoot":"","sources":["../src/vsk-tsx.ts"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AAEH,MAAM,WAAW,QAAQ;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,GAAG;QAAE,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC3E,UAAU,CAAC,EAAE,OAAO,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;KAAE,CAAC;IACtG,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAk+BD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,iBAAsB,GAAG,gBAAgB,CA0ChG;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE/C;AAWD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAmDrD"}
+{"version":3,"file":"vsk-tsx.d.ts","sourceRoot":"","sources":["../src/vsk-tsx.ts"],"names":[],"mappings":"AAiBA;;;;;;;;GAQG;AAEH,MAAM,WAAW,QAAQ;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,GAAG;QAAE,eAAe,CAAC,EAAE,OAAO,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC3E,UAAU,CAAC,EAAE,OAAO,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAA;KAAE,CAAC;IACtG,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AA++BD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,iBAAsB,GAAG,gBAAgB,CA0ChG;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE/C;AAWD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAmDrD"}

package/dist/vsk-tsx.js

@@ -569,6 +569,18 @@ function emitJSXChildren(g, source, children, opts) {
             emitJSXFragment(g, source, child, opts);
             i++;
         }
+        else if (child.type === 'IfStatement' || child.type === 'ForOfStatement' ||
+            child.type === 'ForStatement' || child.type === 'ForInStatement' ||
+            child.type === 'WhileStatement' || child.type === 'DoWhileStatement' ||
+            child.type === 'SwitchStatement' || child.type === 'TryStatement' ||
+            child.type === 'VariableDeclaration' || child.type === 'ExpressionStatement') {
+            // Statement-mode control flow nested among JSX children: TSX has no
+            // statement children, so wrap each in an IIFE expression container.
+            g.addRaw('{(() => { ');
+            emitBody(g, source, [child], '', opts);
+            g.addRaw(' })()}');
+            i++;
+        }
         else {
             i++;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vesk/compiler",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "description": "Vesk compiler — lexer, parser, semantic analysis, IR, codegen",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@sveltejs/acorn-typescript": "^1.0.0",
-    "@vesk/types": "^0.2.8",
+    "@vesk/types": "^0.2.9",
     "acorn": "^8.15.0",
     "esrap": "^2.3.0",
     "is-reference": "^3.0.0",