@tsrx/core 0.1.51 → 0.1.53

package/package.json

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

package/src/plugin.js

@@ -2348,8 +2348,9 @@ export function TSRXPlugin(config) {
 
 			/**
 			 * @param {ESTreeJSX.JSXElement | ESTreeJSX.JSXFragment} node
+			 * @param {number} enclosing_context_depth
 			 */
-			#popTokenContextsAfterTemplateExpressionElement(node) {
+			#popTokenContextsAfterTemplateExpressionElement(node, enclosing_context_depth) {
 				// A fragment in expression position (`() => <>…</>`) leaves the tokenizer
 				// at `exprAllowed === false`, unlike a self-closing element. When the next
 				// token is a `;` or ASI can insert one, the following statement may
@@ -2452,13 +2453,20 @@ export function TSRXPlugin(config) {
 				// Closing token after the template at expression position. For `}`
 				// only pop if it actually closes this `b_expr` — otherwise the
 				// brace targets an inner callback/object body that should pop it
-				// naturally on the next token step.
+				// naturally on the next token step. Only compensate while the stack
+				// has not unwound below the enclosing expression's depth: a balanced
+				// element leaves the stack at that depth and the closing token's own
+				// `updateContext` then pops its real opener (going one below), so a
+				// remaining `(`/`[`/b_expr on top belongs to a still-open outer
+				// group — popping it would make the group's own closer pop the
+				// context underneath it (e.g. an attribute container's brace).
 				if (
-					(this.type === tt.braceR &&
+					ctx.length >= enclosing_context_depth &&
+					((this.type === tt.braceR &&
 						top === b_expr &&
 						(this.#countFollowingRightBraces() === 0 || second === b_expr)) ||
-					(this.type === tt.parenR && top?.token === '(') ||
-					(this.type === tt.bracketR && top?.token === '[')
+						(this.type === tt.parenR && top?.token === '(') ||
+						(this.type === tt.bracketR && top?.token === '['))
 				) {
 					ctx.pop();
 					this.exprAllowed = false;
@@ -4314,11 +4322,15 @@ export function TSRXPlugin(config) {
 					}
 				}
 
+				// This element's `jsxTagStart` has already pushed its own `tc_expr` and
+				// `tc_oTag`, so everything below them is the enclosing expression's
+				// stack — the depth a balanced element parse must return to.
+				const enclosing_context_depth = this.context.length - 2;
 				this.next();
 				const parsed = /** @type {import('estree-jsx').JSXElement} */ (
 					/** @type {unknown} */ (this.parseElement())
 				);
-				this.#popTokenContextsAfterTemplateExpressionElement(parsed);
+				this.#popTokenContextsAfterTemplateExpressionElement(parsed, enclosing_context_depth);
 				return parsed;
 			}
 
@@ -4595,7 +4607,34 @@ export function TSRXPlugin(config) {
 					// text never starts at `<`, so drop the leaked context and re-read the
 					// tag instead of emitting an empty node.
 					if (this.input.charCodeAt(this.start) === CharCode.lessThan) {
-						if (this.input.charCodeAt(this.start + 1) === CharCode.slash) {
+						if (this.#jsxExpressionContainerDepth > 0) {
+							// Inside a `{ … }` container the whole-stack counts below are
+							// blind: the enclosing template's `tc_expr` contexts sit on the
+							// stack but their elements are not on the container-scoped
+							// `#path`. Scope both counts to the container instead — each
+							// element opened inside it (all on `#path` above the container's
+							// baseline) still owns one `tc_expr` that its closing tag's
+							// `jsxTagEnd` pops itself, so only the run's excess above that
+							// quota is leaked. Popping deeper would make a re-read closing
+							// tag pop the container's brace or the enclosing tag context.
+							const path_baseline = this.#expressionContainerPathBaselines.at(-1) ?? 0;
+							let open_elements = 0;
+							for (let i = path_baseline; i < this.#path.length; i++) {
+								if (this.#isNativeTemplateNode(this.#path[i])) open_elements++;
+							}
+							let run = 0;
+							for (
+								let i = this.context.length - 1;
+								i >= 0 && this.context[i] === tstc.tc_expr;
+								i--
+							) {
+								run++;
+							}
+							while (run > open_elements && this.curContext() === tstc.tc_expr) {
+								this.context.pop();
+								run--;
+							}
+						} else if (this.input.charCodeAt(this.start + 1) === CharCode.slash) {
 							while (this.curContext() === tstc.tc_expr) {
 								this.context.pop();
 							}