@tsrx/core 0.1.24 → 0.1.25

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "type": "module",
   "repository": {
     "type": "git",

package/src/plugin.js

@@ -4232,7 +4232,36 @@ export function TSRXPlugin(config) {
 						body.push(text);
 					}
 				} else if (this.#isJSXControlFlowDirectiveStart()) {
-					body.push(this.#parseJSXControlFlowExpression());
+					const directive = this.#parseJSXControlFlowExpression();
+					body.push(directive);
+					// `#parseTemplateControlFlowBlock` reads the token after the block's
+					// closing `}` in a code (b_stat) context, which runs `skipSpace()` and
+					// advances `start` past any whitespace. The following token is therefore a
+					// JS token (e.g. the `else` keyword), and when it is actually sibling
+					// template raw text it reaches `#parseTemplateRawText` having lost the
+					// space(s) between `}` and the text (e.g. `@if (x) { … } else` -> the text
+					// "else" instead of " else"). JSX text after a plain element keeps that
+					// whitespace, so when raw text follows and only whitespace was skipped,
+					// rewind `start` to the block's end to re-include the dropped whitespace.
+					const blockEnd = directive.end;
+					const nextCh = this.input.charCodeAt(this.start);
+					const startsRawText =
+						this.type !== tt.eof &&
+						nextCh !== CharCode.lessThan &&
+						nextCh !== CharCode.openBrace &&
+						nextCh !== CharCode.closeBrace &&
+						!this.#isJSXControlFlowDirectiveStart();
+					if (
+						startsRawText &&
+						typeof blockEnd === 'number' &&
+						this.start > blockEnd &&
+						/^\s*$/.test(this.input.slice(blockEnd, this.start))
+					) {
+						const loc = acorn.getLineInfo(this.input, blockEnd);
+						this.pos = blockEnd;
+						this.start = blockEnd;
+						this.startLoc = new acorn.Position(loc.line, loc.column);
+					}
 				} else if (this.type === tt.braceR) {
 					// Leaving a native template body. We may still be in TSX/JSX tokenization
 					// context (e.g. after parsing markup), but the closing `}` is a JS token.
@@ -4259,6 +4288,18 @@ export function TSRXPlugin(config) {
 						this.start = startPos;
 						this.startLoc = startLoc;
 						this.exprAllowed = false;
+						// A genuine `jsxTagStart` pushes `tc_expr` + `tc_oTag` in its
+						// `updateContext`; faking the token here skips those pushes. That is
+						// harmless for an opening tag (the next token is the tag name), but a
+						// closing tag (`</`) immediately runs `context.length -= 2` in the
+						// slash `updateContext`, which would underflow the context stack and
+						// throw "Invalid array length" (e.g. `<>@if (a) { … } done</>`). Push
+						// the two contexts a real `jsxTagStart` would have added so the closing
+						// tag pops its own contexts instead of the enclosing template's.
+						if (this.input.charCodeAt(this.pos) === CharCode.slash) {
+							this.context.push(tstc.tc_expr);
+							this.context.push(tstc.tc_oTag);
+						}
 						this.next();
 					}
 					if (this.value === '/' || this.type === tt.slash) {