@vesk/compiler 0.1.14 → 0.2.9

package/dist/vesk-plugin.js

@@ -1,7 +1,136 @@
 import * as acorn from 'acorn';
+const VOID_ELEMENTS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+function getJSXElementName(node) {
+    if (!node)
+        return null;
+    if (node.type === 'JSXIdentifier')
+        return node.name;
+    if (node.type === 'JSXNamespacedName' && node.namespace && node.name) {
+        return `${node.namespace.name}:${node.name.name}`;
+    }
+    if (node.type === 'JSXMemberExpression') {
+        const parts = [];
+        let cur = node;
+        while (cur && cur.type === 'JSXMemberExpression') {
+            if (cur.property && cur.property.name)
+                parts.unshift(cur.property.name);
+            cur = cur.object;
+        }
+        if (cur && cur.type === 'JSXIdentifier' && cur.name)
+            parts.unshift(cur.name);
+        return parts.join('.') || null;
+    }
+    return null;
+}
+function isIdentStartCode(code) {
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95 || code === 36;
+}
+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)))
+        i++;
+    if (i >= input.length || !isIdentStartCode(input.charCodeAt(i)))
+        return false;
+    while (i < input.length && isIdentCharCode(input.charCodeAt(i)))
+        i++;
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    if (input.charCodeAt(i) !== 44)
+        return false; // ','
+    i++;
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    if (input.charCodeAt(i) !== 62)
+        return false; // '>'
+    i++;
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    if (input.charCodeAt(i) !== 40)
+        return false; // '('
+    return true;
+}
+const TS_PRIMITIVE_TYPES = new Set(['number', 'string', 'boolean', 'any', 'unknown', 'never', 'void', 'object', 'symbol', 'bigint', 'undefined', 'null']);
+const HTML_TAGS = new Set(['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'slot', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr']);
+function looksLikeTypeAssertionAt(input, pos) {
+    let i = pos + 1;
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    const nameStart = i;
+    if (i >= input.length || !isIdentStartCode(input.charCodeAt(i)))
+        return false;
+    while (i < input.length && isIdentCharCode(input.charCodeAt(i)))
+        i++;
+    const name = input.slice(nameStart, i);
+    // If it's a known HTML tag (lowercase), it's JSX, not a type assertion
+    if (HTML_TAGS.has(name) || VOID_ELEMENTS.has(name))
+        return false;
+    // Only treat as type assertion if name is a TS primitive or capitalized type
+    const isPrimitive = TS_PRIMITIVE_TYPES.has(name);
+    const isCapitalized = name[0] >= 'A' && name[0] <= 'Z';
+    if (!isPrimitive && !isCapitalized)
+        return false;
+    // allow qualified type like `ns.Type` or `Array<string>`? For now only single identifier, skip generics check
+    // If next is '<', skip balanced <...>
+    if (input.charCodeAt(i) === 60) {
+        let depth = 0;
+        let j = i;
+        while (j < input.length) {
+            const c = input.charCodeAt(j);
+            if (c === 60)
+                depth++;
+            else if (c === 62) {
+                depth--;
+                if (depth === 0) {
+                    i = j + 1;
+                    break;
+                }
+            }
+            j++;
+            if (j - i > 100)
+                break;
+        }
+    }
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    if (input.charCodeAt(i) !== 62)
+        return false; // '>'
+    i++;
+    while (i < input.length && isWsChar(input.charCodeAt(i)))
+        i++;
+    if (i >= input.length)
+        return false;
+    const c = input.charCodeAt(i);
+    // expression start: identifier, (, [, {, ", ', `, !, ~, +, -, number, this/super etc.
+    if (isIdentStartCode(c) || c === 40 || c === 91 || c === 123 || c === 34 || c === 39 || c === 96 || c === 33 || c === 126 || c === 43 || c === 45 || (c >= 48 && c <= 57))
+        return true;
+    return false;
+}
 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;
 }
@@ -36,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);
             }
@@ -43,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)) {
@@ -58,6 +475,10 @@ export function VeskParserPlugin(config = {}) {
                         };
                         if (inType) {
                             if (startsNewStatement) {
+                                if (looksLikeGenericArrowAt(this.input, this.pos) || looksLikeTypeAssertionAt(this.input, this.pos)) {
+                                    this.#jsxStartsStatement = false;
+                                    return super.readToken(code);
+                                }
                                 this.#jsxStartsStatement = true;
                                 ++this.pos;
                                 return this.finishToken(tstt.jsxTagStart);
@@ -70,6 +491,10 @@ export function VeskParserPlugin(config = {}) {
                                 prev === tt._this || prev === tt._super || prev === tt._true || prev === tt._false ||
                                 prev === tt._null || prev === tt.jsxTagEnd;
                             if (!canEndExpr || startsNewStatement) {
+                                if (looksLikeGenericArrowAt(this.input, this.pos) || looksLikeTypeAssertionAt(this.input, this.pos)) {
+                                    this.#jsxStartsStatement = false;
+                                    return super.readToken(code);
+                                }
                                 this.#jsxStartsStatement = true;
                                 return forceJsx();
                             }
@@ -377,7 +802,99 @@ 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
+                // self-closing even without `/>`. Delegating to super would leave
+                // a stale tc_expr context (the `>` updateContext only pops the
+                // extra level when a `/` was present), so the following `}` is
+                // mis-read as JSX text: "Unexpected token `}`".
+                const node = this.startNodeAt(startPos, startLoc);
+                node.attributes = [];
+                const nodeName = this.jsx_parseElementName();
+                if (nodeName)
+                    node.name = nodeName;
+                const nameStr = getJSXElementName(nodeName);
+                const isVoid = !!(nameStr && VOID_ELEMENTS.has(nameStr));
+                while (this.type !== tt.slash && this.type !== tstt.jsxTagEnd) {
+                    node.attributes.push(this.jsx_parseAttribute());
+                }
+                const hasSlash = this.eat(tt.slash);
+                node.selfClosing = hasSlash || isVoid;
+                if (this.type !== tstt.jsxTagEnd)
+                    this.unexpected();
+                if (isVoid && !hasSlash) {
+                    const stack = this.context;
+                    if (stack.length > 0 && stack[stack.length - 1].token === '<tag>...</tag>') {
+                        stack.pop();
+                        this.exprAllowed = true;
+                    }
+                }
+                // Consume `>`. For void `>` we already popped tc_expr above so the
+                // following `}` is read as a normal JS token, not JSX text.
+                this.next();
+                return this.finishNode(node, nodeName ? 'JSXOpeningElement' : 'JSXOpeningFragment');
             }
             parseStyleElement(startPos, startLoc) {
                 const el = this.startNodeAt(startPos, startLoc);

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;AA09BD,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

@@ -388,7 +388,17 @@ function emitJSXElement(g, source, el, opts) {
         emitJSXAttr(g, source, attr);
         prev = attr.end;
     }
-    g.add(source.slice(prev, op.end), prev, op.end);
+    const tail = source.slice(prev, op.end);
+    if (op.selfClosing && !tail.includes('/')) {
+        const gt = tail.lastIndexOf('>');
+        const head = gt === -1 ? tail : tail.slice(0, gt);
+        if (head)
+            g.add(head, prev, prev + head.length);
+        g.addRaw('/>');
+    }
+    else {
+        g.add(tail, prev, op.end);
+    }
     if (op.selfClosing)
         return;
     emitJSXChildren(g, source, el.children ?? [], opts);
@@ -559,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++;
         }
@@ -1008,7 +1030,7 @@ export function compileVskCodegen(source, opts = {}) {
     g.add(clean.slice(pos), pos, source.length);
     let code = g.code;
     if (isModuleAst(ast) && containsIdentifier(code, 'Head') && !isIdentifierImported(code, 'Head')) {
-        g.prepend('declare const Head: (props: { children?: unknown }) => unknown;\n');
+        g.prepend('declare const Head: (props: { children?: Component }) => Component;\n');
         code = g.code;
     }
     return { code, mappings: g.mappings, styleRegions: g.styleRegions, errors: [] };
@@ -1057,7 +1079,7 @@ export function generateVskDts(source) {
         const hasType = propsType !== null && propsType !== undefined;
         const collision = typeDeclNames.has(typeName);
         const signature = hasType
-            ? (collision ? propsType : typeName) + ' & { children?: unknown }'
+            ? (collision ? propsType : typeName) + ' & { children?: Component }'
             : 'any';
         if (hasType && !collision) {
             lines.push(`export type ${typeName} = ${propsType};`, '');
@@ -1066,10 +1088,10 @@ export function generateVskDts(source) {
             lines.push(`export type ${typeName} = any;`, '');
         }
         if (defaultExport) {
-            lines.push(`export default function ${name}(props: ${signature}): unknown;`, '');
+            lines.push(`export default function ${name}(props: ${signature}): Component;`, '');
         }
         else {
-            lines.push(`export declare function ${name}(props: ${signature}): unknown;`, '');
+            lines.push(`export declare function ${name}(props: ${signature}): Component;`, '');
         }
     }
     return lines.join('\n');