jslike 1.4.5 → 1.6.0

package/dist/index.js

@@ -5606,8 +5606,672 @@ Parser.acorn = {
   lineBreakG,
   nonASCIIwhitespace
 };
-function parse3(input, options) {
-  return Parser.parse(input, options);
+var XHTMLEntities = {
+  quot: '"',
+  amp: "&",
+  apos: "'",
+  lt: "<",
+  gt: ">",
+  nbsp: "\xA0",
+  iexcl: "\xA1",
+  cent: "\xA2",
+  pound: "\xA3",
+  curren: "\xA4",
+  yen: "\xA5",
+  brvbar: "\xA6",
+  sect: "\xA7",
+  uml: "\xA8",
+  copy: "\xA9",
+  ordf: "\xAA",
+  laquo: "\xAB",
+  not: "\xAC",
+  shy: "\xAD",
+  reg: "\xAE",
+  macr: "\xAF",
+  deg: "\xB0",
+  plusmn: "\xB1",
+  sup2: "\xB2",
+  sup3: "\xB3",
+  acute: "\xB4",
+  micro: "\xB5",
+  para: "\xB6",
+  middot: "\xB7",
+  cedil: "\xB8",
+  sup1: "\xB9",
+  ordm: "\xBA",
+  raquo: "\xBB",
+  frac14: "\xBC",
+  frac12: "\xBD",
+  frac34: "\xBE",
+  iquest: "\xBF",
+  Agrave: "\xC0",
+  Aacute: "\xC1",
+  Acirc: "\xC2",
+  Atilde: "\xC3",
+  Auml: "\xC4",
+  Aring: "\xC5",
+  AElig: "\xC6",
+  Ccedil: "\xC7",
+  Egrave: "\xC8",
+  Eacute: "\xC9",
+  Ecirc: "\xCA",
+  Euml: "\xCB",
+  Igrave: "\xCC",
+  Iacute: "\xCD",
+  Icirc: "\xCE",
+  Iuml: "\xCF",
+  ETH: "\xD0",
+  Ntilde: "\xD1",
+  Ograve: "\xD2",
+  Oacute: "\xD3",
+  Ocirc: "\xD4",
+  Otilde: "\xD5",
+  Ouml: "\xD6",
+  times: "\xD7",
+  Oslash: "\xD8",
+  Ugrave: "\xD9",
+  Uacute: "\xDA",
+  Ucirc: "\xDB",
+  Uuml: "\xDC",
+  Yacute: "\xDD",
+  THORN: "\xDE",
+  szlig: "\xDF",
+  agrave: "\xE0",
+  aacute: "\xE1",
+  acirc: "\xE2",
+  atilde: "\xE3",
+  auml: "\xE4",
+  aring: "\xE5",
+  aelig: "\xE6",
+  ccedil: "\xE7",
+  egrave: "\xE8",
+  eacute: "\xE9",
+  ecirc: "\xEA",
+  euml: "\xEB",
+  igrave: "\xEC",
+  iacute: "\xED",
+  icirc: "\xEE",
+  iuml: "\xEF",
+  eth: "\xF0",
+  ntilde: "\xF1",
+  ograve: "\xF2",
+  oacute: "\xF3",
+  ocirc: "\xF4",
+  otilde: "\xF5",
+  ouml: "\xF6",
+  divide: "\xF7",
+  oslash: "\xF8",
+  ugrave: "\xF9",
+  uacute: "\xFA",
+  ucirc: "\xFB",
+  uuml: "\xFC",
+  yacute: "\xFD",
+  thorn: "\xFE",
+  yuml: "\xFF",
+  OElig: "\u0152",
+  oelig: "\u0153",
+  Scaron: "\u0160",
+  scaron: "\u0161",
+  Yuml: "\u0178",
+  fnof: "\u0192",
+  circ: "\u02C6",
+  tilde: "\u02DC",
+  Alpha: "\u0391",
+  Beta: "\u0392",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Epsilon: "\u0395",
+  Zeta: "\u0396",
+  Eta: "\u0397",
+  Theta: "\u0398",
+  Iota: "\u0399",
+  Kappa: "\u039A",
+  Lambda: "\u039B",
+  Mu: "\u039C",
+  Nu: "\u039D",
+  Xi: "\u039E",
+  Omicron: "\u039F",
+  Pi: "\u03A0",
+  Rho: "\u03A1",
+  Sigma: "\u03A3",
+  Tau: "\u03A4",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Chi: "\u03A7",
+  Psi: "\u03A8",
+  Omega: "\u03A9",
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  omicron: "\u03BF",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigmaf: "\u03C2",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  thetasym: "\u03D1",
+  upsih: "\u03D2",
+  piv: "\u03D6",
+  ensp: "\u2002",
+  emsp: "\u2003",
+  thinsp: "\u2009",
+  zwnj: "\u200C",
+  zwj: "\u200D",
+  lrm: "\u200E",
+  rlm: "\u200F",
+  ndash: "\u2013",
+  mdash: "\u2014",
+  lsquo: "\u2018",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  ldquo: "\u201C",
+  rdquo: "\u201D",
+  bdquo: "\u201E",
+  dagger: "\u2020",
+  Dagger: "\u2021",
+  bull: "\u2022",
+  hellip: "\u2026",
+  permil: "\u2030",
+  prime: "\u2032",
+  Prime: "\u2033",
+  lsaquo: "\u2039",
+  rsaquo: "\u203A",
+  oline: "\u203E",
+  frasl: "\u2044",
+  euro: "\u20AC",
+  image: "\u2111",
+  weierp: "\u2118",
+  real: "\u211C",
+  trade: "\u2122",
+  alefsym: "\u2135",
+  larr: "\u2190",
+  uarr: "\u2191",
+  rarr: "\u2192",
+  darr: "\u2193",
+  harr: "\u2194",
+  crarr: "\u21B5",
+  lArr: "\u21D0",
+  uArr: "\u21D1",
+  rArr: "\u21D2",
+  dArr: "\u21D3",
+  hArr: "\u21D4",
+  forall: "\u2200",
+  part: "\u2202",
+  exist: "\u2203",
+  empty: "\u2205",
+  nabla: "\u2207",
+  isin: "\u2208",
+  notin: "\u2209",
+  ni: "\u220B",
+  prod: "\u220F",
+  sum: "\u2211",
+  minus: "\u2212",
+  lowast: "\u2217",
+  radic: "\u221A",
+  prop: "\u221D",
+  infin: "\u221E",
+  ang: "\u2220",
+  and: "\u2227",
+  or: "\u2228",
+  cap: "\u2229",
+  cup: "\u222A",
+  "int": "\u222B",
+  there4: "\u2234",
+  sim: "\u223C",
+  cong: "\u2245",
+  asymp: "\u2248",
+  ne: "\u2260",
+  equiv: "\u2261",
+  le: "\u2264",
+  ge: "\u2265",
+  sub: "\u2282",
+  sup: "\u2283",
+  nsub: "\u2284",
+  sube: "\u2286",
+  supe: "\u2287",
+  oplus: "\u2295",
+  otimes: "\u2297",
+  perp: "\u22A5",
+  sdot: "\u22C5",
+  lceil: "\u2308",
+  rceil: "\u2309",
+  lfloor: "\u230A",
+  rfloor: "\u230B",
+  lang: "\u2329",
+  rang: "\u232A",
+  loz: "\u25CA",
+  spades: "\u2660",
+  clubs: "\u2663",
+  hearts: "\u2665",
+  diams: "\u2666"
+};
+var hexNumber = /^[\da-fA-F]+$/;
+var decimalNumber = /^\d+$/;
+var acornJsxMap = /* @__PURE__ */ new WeakMap();
+function getJsxTokens(acorn) {
+  acorn = acorn.Parser.acorn || acorn;
+  let acornJsx2 = acornJsxMap.get(acorn);
+  if (!acornJsx2) {
+    const tt = acorn.tokTypes;
+    const TokContext3 = acorn.TokContext;
+    const TokenType3 = acorn.TokenType;
+    const tc_oTag = new TokContext3("<tag", false);
+    const tc_cTag = new TokContext3("</tag", false);
+    const tc_expr = new TokContext3("<tag>...</tag>", true, true);
+    const tokContexts = {
+      tc_oTag,
+      tc_cTag,
+      tc_expr
+    };
+    const tokTypes = {
+      jsxName: new TokenType3("jsxName"),
+      jsxText: new TokenType3("jsxText", { beforeExpr: true }),
+      jsxTagStart: new TokenType3("jsxTagStart", { startsExpr: true }),
+      jsxTagEnd: new TokenType3("jsxTagEnd")
+    };
+    tokTypes.jsxTagStart.updateContext = function() {
+      this.context.push(tc_expr);
+      this.context.push(tc_oTag);
+      this.exprAllowed = false;
+    };
+    tokTypes.jsxTagEnd.updateContext = function(prevType) {
+      let out = this.context.pop();
+      if (out === tc_oTag && prevType === tt.slash || out === tc_cTag) {
+        this.context.pop();
+        this.exprAllowed = this.curContext() === tc_expr;
+      } else {
+        this.exprAllowed = true;
+      }
+    };
+    acornJsx2 = { tokContexts, tokTypes };
+    acornJsxMap.set(acorn, acornJsx2);
+  }
+  return acornJsx2;
+}
+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);
+}
+function acornJsx(options) {
+  options = options || {};
+  return function(Parser3) {
+    return plugin({
+      allowNamespaces: options.allowNamespaces !== false,
+      allowNamespacedObjects: !!options.allowNamespacedObjects
+    }, Parser3);
+  };
+}
+function plugin(options, Parser3) {
+  const acorn = Parser3.acorn || { tokTypes: tt, TokContext, TokenType, isNewLine: isNewLine2, isIdentifierStart: isIdentifierStart2, isIdentifierChar: isIdentifierChar2, tokContexts };
+  const acornJsx2 = getJsxTokens(acorn);
+  const tt = acorn.tokTypes;
+  const tok = acornJsx2.tokTypes;
+  const tokContexts = acorn.tokContexts;
+  const tc_oTag = acornJsx2.tokContexts.tc_oTag;
+  const tc_cTag = acornJsx2.tokContexts.tc_cTag;
+  const tc_expr = acornJsx2.tokContexts.tc_expr;
+  const isNewLine2 = acorn.isNewLine;
+  const isIdentifierStart2 = acorn.isIdentifierStart;
+  const isIdentifierChar2 = acorn.isIdentifierChar;
+  return class extends Parser3 {
+    // Expose actual `tokTypes` and `tokContexts` to other plugins.
+    static get acornJsx() {
+      return acornJsx2;
+    }
+    // Reads inline JSX contents token.
+    jsx_readToken() {
+      let out = "", chunkStart = this.pos;
+      for (; ; ) {
+        if (this.pos >= this.input.length)
+          this.raise(this.start, "Unterminated JSX contents");
+        let ch = this.input.charCodeAt(this.pos);
+        switch (ch) {
+          case 60:
+          // '<'
+          case 123:
+            if (this.pos === this.start) {
+              if (ch === 60 && this.exprAllowed) {
+                ++this.pos;
+                return this.finishToken(tok.jsxTagStart);
+              }
+              return this.getTokenFromCode(ch);
+            }
+            out += this.input.slice(chunkStart, this.pos);
+            return this.finishToken(tok.jsxText, out);
+          case 38:
+            out += this.input.slice(chunkStart, this.pos);
+            out += this.jsx_readEntity();
+            chunkStart = this.pos;
+            break;
+          case 62:
+          // '>'
+          case 125:
+            this.raise(
+              this.pos,
+              "Unexpected token `" + this.input[this.pos] + "`. Did you mean `" + (ch === 62 ? "&gt;" : "&rbrace;") + '` or `{"' + this.input[this.pos] + '"}`?'
+            );
+          default:
+            if (isNewLine2(ch)) {
+              out += this.input.slice(chunkStart, this.pos);
+              out += this.jsx_readNewLine(true);
+              chunkStart = this.pos;
+            } else {
+              ++this.pos;
+            }
+        }
+      }
+    }
+    jsx_readNewLine(normalizeCRLF) {
+      let ch = this.input.charCodeAt(this.pos);
+      let out;
+      ++this.pos;
+      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
+        ++this.pos;
+        out = normalizeCRLF ? "\n" : "\r\n";
+      } else {
+        out = String.fromCharCode(ch);
+      }
+      if (this.options.locations) {
+        ++this.curLine;
+        this.lineStart = this.pos;
+      }
+      return out;
+    }
+    jsx_readString(quote) {
+      let out = "", chunkStart = ++this.pos;
+      for (; ; ) {
+        if (this.pos >= this.input.length)
+          this.raise(this.start, "Unterminated string constant");
+        let ch = this.input.charCodeAt(this.pos);
+        if (ch === quote) break;
+        if (ch === 38) {
+          out += this.input.slice(chunkStart, this.pos);
+          out += this.jsx_readEntity();
+          chunkStart = this.pos;
+        } else if (isNewLine2(ch)) {
+          out += this.input.slice(chunkStart, this.pos);
+          out += this.jsx_readNewLine(false);
+          chunkStart = this.pos;
+        } else {
+          ++this.pos;
+        }
+      }
+      out += this.input.slice(chunkStart, this.pos++);
+      return this.finishToken(tt.string, out);
+    }
+    jsx_readEntity() {
+      let str = "", count = 0, entity;
+      let ch = this.input[this.pos];
+      if (ch !== "&")
+        this.raise(this.pos, "Entity must start with an ampersand");
+      let startPos = ++this.pos;
+      while (this.pos < this.input.length && count++ < 10) {
+        ch = this.input[this.pos++];
+        if (ch === ";") {
+          if (str[0] === "#") {
+            if (str[1] === "x") {
+              str = str.substr(2);
+              if (hexNumber.test(str))
+                entity = String.fromCharCode(parseInt(str, 16));
+            } else {
+              str = str.substr(1);
+              if (decimalNumber.test(str))
+                entity = String.fromCharCode(parseInt(str, 10));
+            }
+          } else {
+            entity = XHTMLEntities[str];
+          }
+          break;
+        }
+        str += ch;
+      }
+      if (!entity) {
+        this.pos = startPos;
+        return "&";
+      }
+      return entity;
+    }
+    // Read a JSX identifier (valid tag or attribute name).
+    //
+    // Optimized version since JSX identifiers can't contain
+    // escape characters and so can be read as single slice.
+    // Also assumes that first character was already checked
+    // by isIdentifierStart in readToken.
+    jsx_readWord() {
+      let ch, start = this.pos;
+      do {
+        ch = this.input.charCodeAt(++this.pos);
+      } while (isIdentifierChar2(ch) || ch === 45);
+      return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));
+    }
+    // Parse next token as JSX identifier
+    jsx_parseIdentifier() {
+      let node = this.startNode();
+      if (this.type === tok.jsxName)
+        node.name = this.value;
+      else if (this.type.keyword)
+        node.name = this.type.keyword;
+      else
+        this.unexpected();
+      this.next();
+      return this.finishNode(node, "JSXIdentifier");
+    }
+    // Parse namespaced identifier.
+    jsx_parseNamespacedName() {
+      let startPos = this.start, startLoc = this.startLoc;
+      let name = this.jsx_parseIdentifier();
+      if (!options.allowNamespaces || !this.eat(tt.colon)) return name;
+      var node = this.startNodeAt(startPos, startLoc);
+      node.namespace = name;
+      node.name = this.jsx_parseIdentifier();
+      return this.finishNode(node, "JSXNamespacedName");
+    }
+    // Parses element name in any form - namespaced, member
+    // or single identifier.
+    jsx_parseElementName() {
+      if (this.type === tok.jsxTagEnd) return "";
+      let startPos = this.start, startLoc = this.startLoc;
+      let node = this.jsx_parseNamespacedName();
+      if (this.type === tt.dot && node.type === "JSXNamespacedName" && !options.allowNamespacedObjects) {
+        this.unexpected();
+      }
+      while (this.eat(tt.dot)) {
+        let newNode = this.startNodeAt(startPos, startLoc);
+        newNode.object = node;
+        newNode.property = this.jsx_parseIdentifier();
+        node = this.finishNode(newNode, "JSXMemberExpression");
+      }
+      return node;
+    }
+    // Parses any type of JSX attribute value.
+    jsx_parseAttributeValue() {
+      switch (this.type) {
+        case tt.braceL:
+          let node = this.jsx_parseExpressionContainer();
+          if (node.expression.type === "JSXEmptyExpression")
+            this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
+          return node;
+        case tok.jsxTagStart:
+        case tt.string:
+          return this.parseExprAtom();
+        default:
+          this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
+      }
+    }
+    // JSXEmptyExpression is unique type since it doesn't actually parse anything,
+    // and so it should start at the end of last read token (left brace) and finish
+    // at the beginning of the next one (right brace).
+    jsx_parseEmptyExpression() {
+      let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+      return this.finishNodeAt(node, "JSXEmptyExpression", this.start, this.startLoc);
+    }
+    // Parses JSX expression enclosed into curly brackets.
+    jsx_parseExpressionContainer() {
+      let node = this.startNode();
+      this.next();
+      node.expression = this.type === tt.braceR ? this.jsx_parseEmptyExpression() : this.parseExpression();
+      this.expect(tt.braceR);
+      return this.finishNode(node, "JSXExpressionContainer");
+    }
+    // Parses following JSX attribute name-value pair.
+    jsx_parseAttribute() {
+      let node = this.startNode();
+      if (this.eat(tt.braceL)) {
+        this.expect(tt.ellipsis);
+        node.argument = this.parseMaybeAssign();
+        this.expect(tt.braceR);
+        return this.finishNode(node, "JSXSpreadAttribute");
+      }
+      node.name = this.jsx_parseNamespacedName();
+      node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
+      return this.finishNode(node, "JSXAttribute");
+    }
+    // Parses JSX opening tag starting after '<'.
+    jsx_parseOpeningElementAt(startPos, startLoc) {
+      let node = this.startNodeAt(startPos, startLoc);
+      node.attributes = [];
+      let nodeName = this.jsx_parseElementName();
+      if (nodeName) node.name = nodeName;
+      while (this.type !== tt.slash && this.type !== tok.jsxTagEnd)
+        node.attributes.push(this.jsx_parseAttribute());
+      node.selfClosing = this.eat(tt.slash);
+      this.expect(tok.jsxTagEnd);
+      return this.finishNode(node, nodeName ? "JSXOpeningElement" : "JSXOpeningFragment");
+    }
+    // Parses JSX closing tag starting after '</'.
+    jsx_parseClosingElementAt(startPos, startLoc) {
+      let node = this.startNodeAt(startPos, startLoc);
+      let nodeName = this.jsx_parseElementName();
+      if (nodeName) node.name = nodeName;
+      this.expect(tok.jsxTagEnd);
+      return this.finishNode(node, nodeName ? "JSXClosingElement" : "JSXClosingFragment");
+    }
+    // Parses entire JSX element, including it's opening tag
+    // (starting after '<'), attributes, contents and closing tag.
+    jsx_parseElementAt(startPos, startLoc) {
+      let node = this.startNodeAt(startPos, startLoc);
+      let children = [];
+      let openingElement = this.jsx_parseOpeningElementAt(startPos, startLoc);
+      let closingElement = null;
+      if (!openingElement.selfClosing) {
+        contents: for (; ; ) {
+          switch (this.type) {
+            case tok.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 tok.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) + ">"
+          );
+        }
+      }
+      let 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);
+    }
+    // Parse JSX text
+    jsx_parseText() {
+      let node = this.parseLiteral(this.value);
+      node.type = "JSXText";
+      return node;
+    }
+    // Parses entire JSX element from current position.
+    jsx_parseElement() {
+      let startPos = this.start, startLoc = this.startLoc;
+      this.next();
+      return this.jsx_parseElementAt(startPos, startLoc);
+    }
+    parseExprAtom(refShortHandDefaultPos) {
+      if (this.type === tok.jsxText)
+        return this.jsx_parseText();
+      else if (this.type === tok.jsxTagStart)
+        return this.jsx_parseElement();
+      else
+        return super.parseExprAtom(refShortHandDefaultPos);
+    }
+    readToken(code) {
+      let context = this.curContext();
+      if (context === tc_expr) return this.jsx_readToken();
+      if (context === tc_oTag || context === tc_cTag) {
+        if (isIdentifierStart2(code)) return this.jsx_readWord();
+        if (code == 62) {
+          ++this.pos;
+          return this.finishToken(tok.jsxTagEnd);
+        }
+        if ((code === 34 || code === 39) && context == tc_oTag)
+          return this.jsx_readString(code);
+      }
+      if (code === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {
+        ++this.pos;
+        return this.finishToken(tok.jsxTagStart);
+      }
+      return super.readToken(code);
+    }
+    updateContext(prevType) {
+      if (this.type == tt.braceL) {
+        var curContext = this.curContext();
+        if (curContext == tc_oTag) this.context.push(tokContexts.b_expr);
+        else if (curContext == tc_expr) this.context.push(tokContexts.b_tmpl);
+        else super.updateContext(prevType);
+        this.exprAllowed = true;
+      } else if (this.type === tt.slash && prevType === tok.jsxTagStart) {
+        this.context.length -= 2;
+        this.context.push(tc_cTag);
+        this.exprAllowed = false;
+      } else {
+        return super.updateContext(prevType);
+      }
+    }
+  };
+}
+var JSXParser = Parser.extend(acornJsx());
+function jsxParse(input, options) {
+  return JSXParser.parse(input, options);
 }
 
 // src/runtime/environment.js
@@ -5784,19 +6448,36 @@ var Interpreter = class _Interpreter {
     this.moduleCache = /* @__PURE__ */ new Map();
     this.moduleExports = {};
     this.abortSignal = options.abortSignal;
+    this.executionController = options.executionController;
   }
-  // Check if execution should be aborted
+  // Check if execution should be aborted (sync version)
   checkAbortSignal() {
+    if (this.executionController) {
+      this.executionController._checkAbortSync();
+      return;
+    }
     if (this.abortSignal && this.abortSignal.aborted) {
       const error = new Error("The operation was aborted");
       error.name = "AbortError";
       throw error;
     }
   }
+  // Checkpoint that returns a promise only when controller is present
+  // When no controller, returns null to signal no await needed
+  _getCheckpointPromise(node, env) {
+    if (this.executionController) {
+      this.executionController._setEnv(env);
+      return this.executionController._checkpoint(node);
+    } else {
+      this.checkAbortSignal();
+      return null;
+    }
+  }
   // Async evaluation for async functions - handles await expressions
   async evaluateAsync(node, env) {
     if (!node) return void 0;
-    this.checkAbortSignal();
+    const checkpointPromise = this._getCheckpointPromise(node, env);
+    if (checkpointPromise) await checkpointPromise;
     if (node.type === "AwaitExpression") {
       const promise = await this.evaluateAsync(node.argument, env);
       return await promise;
@@ -5967,6 +6648,8 @@ var Interpreter = class _Interpreter {
         await this.evaluateAsync(node.init, forEnv);
       }
       while (!node.test || await this.evaluateAsync(node.test, forEnv)) {
+        const cp1 = this._getCheckpointPromise(node, forEnv);
+        if (cp1) await cp1;
         const result = await this.evaluateAsync(node.body, forEnv);
         if (result instanceof BreakSignal) {
           break;
@@ -5992,6 +6675,8 @@ var Interpreter = class _Interpreter {
       const declarator = node.left.declarations[0];
       const isConst = node.left.kind === "const";
       for (const value of iterable) {
+        const cp2 = this._getCheckpointPromise(node, forEnv);
+        if (cp2) await cp2;
         const iterEnv = forEnv.extend();
         if (declarator.id.type === "Identifier") {
           iterEnv.define(declarator.id.name, value, isConst);
@@ -6022,6 +6707,8 @@ var Interpreter = class _Interpreter {
       const varName = node.left.declarations[0].id.name;
       forEnv.define(varName, void 0);
       for (const key in obj) {
+        const cp3 = this._getCheckpointPromise(node, forEnv);
+        if (cp3) await cp3;
         forEnv.set(varName, key);
         const result = await this.evaluateAsync(node.body, forEnv);
         if (result instanceof BreakSignal) {
@@ -6038,6 +6725,8 @@ var Interpreter = class _Interpreter {
     }
     if (node.type === "WhileStatement") {
       while (await this.evaluateAsync(node.test, env)) {
+        const cp4 = this._getCheckpointPromise(node, env);
+        if (cp4) await cp4;
         const result = await this.evaluateAsync(node.body, env);
         if (result instanceof BreakSignal) {
           break;
@@ -6053,6 +6742,8 @@ var Interpreter = class _Interpreter {
     }
     if (node.type === "DoWhileStatement") {
       do {
+        const cp5 = this._getCheckpointPromise(node, env);
+        if (cp5) await cp5;
         const result = await this.evaluateAsync(node.body, env);
         if (result instanceof BreakSignal) {
           break;
@@ -6254,6 +6945,21 @@ var Interpreter = class _Interpreter {
     if (node.type === "ClassExpression") {
       return this.evaluateClassExpression(node, env);
     }
+    if (node.type === "JSXElement") {
+      return await this.evaluateJSXElementAsync(node, env);
+    }
+    if (node.type === "JSXFragment") {
+      return await this.evaluateJSXFragmentAsync(node, env);
+    }
+    if (node.type === "JSXExpressionContainer") {
+      if (node.expression.type === "JSXEmptyExpression") {
+        return void 0;
+      }
+      return await this.evaluateAsync(node.expression, env);
+    }
+    if (node.type === "JSXText") {
+      return this.normalizeJSXText(node.value);
+    }
     if ([
       "Literal",
       "Identifier",
@@ -6376,6 +7082,18 @@ var Interpreter = class _Interpreter {
         return this.evaluateAssignmentPattern(node, env);
       case "Property":
         return this.evaluateProperty(node, env);
+      // JSX Support
+      case "JSXElement":
+        return this.evaluateJSXElement(node, env);
+      case "JSXFragment":
+        return this.evaluateJSXFragment(node, env);
+      case "JSXExpressionContainer":
+        if (node.expression.type === "JSXEmptyExpression") {
+          return void 0;
+        }
+        return this.evaluate(node.expression, env);
+      case "JSXText":
+        return this.normalizeJSXText(node.value);
       default:
         throw new Error(`Unknown node type: ${node.type}`);
     }
@@ -6695,6 +7413,7 @@ var Interpreter = class _Interpreter {
   callUserFunction(func, args, callingEnv, thisContext = void 0) {
     const metadata = func.__metadata || func;
     const funcEnv = new Environment(metadata.closure);
+    const funcName = metadata.name || func.name || "anonymous";
     if (thisContext !== void 0) {
       funcEnv.define("this", thisContext);
     }
@@ -6717,15 +7436,46 @@ var Interpreter = class _Interpreter {
       }
     }
     if (metadata.async) {
+      if (this.executionController) {
+        this.executionController._pushCall(funcName);
+      }
       return (async () => {
+        try {
+          if (metadata.expression) {
+            const result = await this.evaluateAsync(metadata.body, funcEnv);
+            if (result instanceof ThrowSignal) {
+              throw result.value;
+            }
+            return result;
+          } else {
+            const result = await this.evaluateAsync(metadata.body, funcEnv);
+            if (result instanceof ReturnValue) {
+              return result.value;
+            }
+            if (result instanceof ThrowSignal) {
+              throw result.value;
+            }
+            return void 0;
+          }
+        } finally {
+          if (this.executionController) {
+            this.executionController._popCall();
+          }
+        }
+      })();
+    } else {
+      if (this.executionController) {
+        this.executionController._pushCall(funcName);
+      }
+      try {
         if (metadata.expression) {
-          const result = await this.evaluateAsync(metadata.body, funcEnv);
+          const result = this.evaluate(metadata.body, funcEnv);
           if (result instanceof ThrowSignal) {
             throw result.value;
           }
           return result;
         } else {
-          const result = await this.evaluateAsync(metadata.body, funcEnv);
+          const result = this.evaluate(metadata.body, funcEnv);
           if (result instanceof ReturnValue) {
             return result.value;
           }
@@ -6734,23 +7484,10 @@ var Interpreter = class _Interpreter {
           }
           return void 0;
         }
-      })();
-    } else {
-      if (metadata.expression) {
-        const result = this.evaluate(metadata.body, funcEnv);
-        if (result instanceof ThrowSignal) {
-          throw result.value;
-        }
-        return result;
-      } else {
-        const result = this.evaluate(metadata.body, funcEnv);
-        if (result instanceof ReturnValue) {
-          return result.value;
-        }
-        if (result instanceof ThrowSignal) {
-          throw result.value;
+      } finally {
+        if (this.executionController) {
+          this.executionController._popCall();
         }
-        return void 0;
       }
     }
   }
@@ -6995,7 +7732,7 @@ var Interpreter = class _Interpreter {
         throw new Error(`Cannot find module '${modulePath}'`);
       }
       const moduleCode = typeof resolution === "string" ? resolution : resolution.code;
-      const moduleAst = parse3(moduleCode, {
+      const moduleAst = jsxParse(moduleCode, {
         ecmaVersion: 2020,
         sourceType: "module",
         locations: false
@@ -7424,6 +8161,210 @@ var Interpreter = class _Interpreter {
   evaluateProperty(node, env) {
     return void 0;
   }
+  // ===== JSX Support =====
+  evaluateJSXElement(node, env) {
+    const createElement = this.getCreateElement(env);
+    const { type, props } = this.evaluateJSXOpeningElement(node.openingElement, env);
+    const children = this.evaluateJSXChildren(node.children, env);
+    if (children.length === 0) {
+      return createElement(type, props);
+    } else if (children.length === 1) {
+      return createElement(type, props, children[0]);
+    }
+    return createElement(type, props, ...children);
+  }
+  evaluateJSXFragment(node, env) {
+    const createElement = this.getCreateElement(env);
+    const Fragment = this.getFragment(env);
+    const children = this.evaluateJSXChildren(node.children, env);
+    if (children.length === 0) {
+      return createElement(Fragment, null);
+    } else if (children.length === 1) {
+      return createElement(Fragment, null, children[0]);
+    }
+    return createElement(Fragment, null, ...children);
+  }
+  evaluateJSXOpeningElement(node, env) {
+    const type = this.evaluateJSXElementName(node.name, env);
+    const props = {};
+    for (const attr of node.attributes) {
+      if (attr.type === "JSXAttribute") {
+        const name = attr.name.type === "JSXIdentifier" ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+        const value = attr.value ? this.evaluateJSXAttributeValue(attr.value, env) : true;
+        props[name] = value;
+      } else if (attr.type === "JSXSpreadAttribute") {
+        Object.assign(props, this.evaluate(attr.argument, env));
+      }
+    }
+    return { type, props: Object.keys(props).length > 0 ? props : null };
+  }
+  evaluateJSXElementName(node, env) {
+    if (node.type === "JSXIdentifier") {
+      const name = node.name;
+      if (name[0] === name[0].toLowerCase()) {
+        return name;
+      }
+      return env.get(name);
+    } else if (node.type === "JSXMemberExpression") {
+      const object = this.evaluateJSXElementName(node.object, env);
+      return object[node.property.name];
+    } else if (node.type === "JSXNamespacedName") {
+      return `${node.namespace.name}:${node.name.name}`;
+    }
+    throw new Error(`Unknown JSX element name type: ${node.type}`);
+  }
+  evaluateJSXAttributeValue(node, env) {
+    if (node.type === "Literal") return node.value;
+    if (node.type === "JSXExpressionContainer") {
+      return this.evaluate(node.expression, env);
+    }
+    if (node.type === "JSXElement") return this.evaluateJSXElement(node, env);
+    if (node.type === "JSXFragment") return this.evaluateJSXFragment(node, env);
+    throw new Error(`Unknown JSX attribute value type: ${node.type}`);
+  }
+  evaluateJSXChildren(children, env) {
+    const result = [];
+    for (const child of children) {
+      if (child.type === "JSXText") {
+        const text = this.normalizeJSXText(child.value);
+        if (text) result.push(text);
+      } else if (child.type === "JSXExpressionContainer") {
+        if (child.expression.type !== "JSXEmptyExpression") {
+          const value = this.evaluate(child.expression, env);
+          if (Array.isArray(value)) {
+            result.push(...value);
+          } else if (value !== null && value !== void 0 && value !== false) {
+            result.push(value);
+          }
+        }
+      } else if (child.type === "JSXElement") {
+        result.push(this.evaluateJSXElement(child, env));
+      } else if (child.type === "JSXFragment") {
+        result.push(this.evaluateJSXFragment(child, env));
+      }
+    }
+    return result;
+  }
+  normalizeJSXText(text) {
+    const lines = text.split("\n");
+    const normalized = lines.map((line, i) => {
+      let result = line;
+      if (i === 0) result = result.trimStart();
+      if (i === lines.length - 1) result = result.trimEnd();
+      return result;
+    }).filter((line) => line.length > 0).join(" ");
+    return normalized || null;
+  }
+  getCreateElement(env) {
+    try {
+      const React = env.get("React");
+      if (React && React.createElement) {
+        return React.createElement.bind(React);
+      }
+    } catch (e) {
+    }
+    try {
+      return env.get("createElement");
+    } catch (e) {
+    }
+    return (type, props, ...children) => ({
+      $$typeof: Symbol.for("react.element"),
+      type,
+      props: {
+        ...props,
+        children: children.length === 0 ? void 0 : children.length === 1 ? children[0] : children
+      },
+      key: (props == null ? void 0 : props.key) ?? null,
+      ref: (props == null ? void 0 : props.ref) ?? null
+    });
+  }
+  getFragment(env) {
+    try {
+      const React = env.get("React");
+      if (React && React.Fragment) {
+        return React.Fragment;
+      }
+    } catch (e) {
+    }
+    try {
+      return env.get("Fragment");
+    } catch (e) {
+    }
+    return Symbol.for("react.fragment");
+  }
+  // ===== Async JSX Support =====
+  async evaluateJSXElementAsync(node, env) {
+    const checkpointPromise = this._getCheckpointPromise(node, env);
+    if (checkpointPromise) await checkpointPromise;
+    const createElement = this.getCreateElement(env);
+    const { type, props } = await this.evaluateJSXOpeningElementAsync(node.openingElement, env);
+    const children = await this.evaluateJSXChildrenAsync(node.children, env);
+    if (children.length === 0) {
+      return createElement(type, props);
+    } else if (children.length === 1) {
+      return createElement(type, props, children[0]);
+    }
+    return createElement(type, props, ...children);
+  }
+  async evaluateJSXFragmentAsync(node, env) {
+    const checkpointPromise = this._getCheckpointPromise(node, env);
+    if (checkpointPromise) await checkpointPromise;
+    const createElement = this.getCreateElement(env);
+    const Fragment = this.getFragment(env);
+    const children = await this.evaluateJSXChildrenAsync(node.children, env);
+    if (children.length === 0) {
+      return createElement(Fragment, null);
+    } else if (children.length === 1) {
+      return createElement(Fragment, null, children[0]);
+    }
+    return createElement(Fragment, null, ...children);
+  }
+  async evaluateJSXOpeningElementAsync(node, env) {
+    const type = this.evaluateJSXElementName(node.name, env);
+    const props = {};
+    for (const attr of node.attributes) {
+      if (attr.type === "JSXAttribute") {
+        const name = attr.name.type === "JSXIdentifier" ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+        const value = attr.value ? await this.evaluateJSXAttributeValueAsync(attr.value, env) : true;
+        props[name] = value;
+      } else if (attr.type === "JSXSpreadAttribute") {
+        Object.assign(props, await this.evaluateAsync(attr.argument, env));
+      }
+    }
+    return { type, props: Object.keys(props).length > 0 ? props : null };
+  }
+  async evaluateJSXAttributeValueAsync(node, env) {
+    if (node.type === "Literal") return node.value;
+    if (node.type === "JSXExpressionContainer") {
+      return await this.evaluateAsync(node.expression, env);
+    }
+    if (node.type === "JSXElement") return await this.evaluateJSXElementAsync(node, env);
+    if (node.type === "JSXFragment") return await this.evaluateJSXFragmentAsync(node, env);
+    throw new Error(`Unknown JSX attribute value type: ${node.type}`);
+  }
+  async evaluateJSXChildrenAsync(children, env) {
+    const result = [];
+    for (const child of children) {
+      if (child.type === "JSXText") {
+        const text = this.normalizeJSXText(child.value);
+        if (text) result.push(text);
+      } else if (child.type === "JSXExpressionContainer") {
+        if (child.expression.type !== "JSXEmptyExpression") {
+          const value = await this.evaluateAsync(child.expression, env);
+          if (Array.isArray(value)) {
+            result.push(...value);
+          } else if (value !== null && value !== void 0 && value !== false) {
+            result.push(value);
+          }
+        }
+      } else if (child.type === "JSXElement") {
+        result.push(await this.evaluateJSXElementAsync(child, env));
+      } else if (child.type === "JSXFragment") {
+        result.push(await this.evaluateJSXFragmentAsync(child, env));
+      }
+    }
+    return result;
+  }
 };
 
 // src/runtime/builtins.js
@@ -7505,6 +8446,17 @@ function createGlobalEnvironment(env) {
   env.define("ReferenceError", ReferenceError);
   env.define("SyntaxError", SyntaxError);
   env.define("RangeError", RangeError);
+  env.define("createElement", (type, props, ...children) => ({
+    $$typeof: Symbol.for("react.element"),
+    type,
+    props: {
+      ...props,
+      children: children.length === 0 ? void 0 : children.length === 1 ? children[0] : children
+    },
+    key: (props == null ? void 0 : props.key) ?? null,
+    ref: (props == null ? void 0 : props.ref) ?? null
+  }));
+  env.define("Fragment", Symbol.for("react.fragment"));
   env.define("log", (...args) => {
     console.log(...args);
     return void 0;
@@ -7893,7 +8845,8 @@ var WangInterpreter = class {
     }
     const hasTopLevelReturn = this.hasTopLevelReturn(code);
     const options = {
-      moduleResolver: this.moduleResolver
+      moduleResolver: this.moduleResolver,
+      executionController: userOptions.executionController
       // sourceType will be auto-detected from code
     };
     let result;
@@ -7972,6 +8925,191 @@ var InMemoryModuleResolver = class {
   }
 };
 
+// src/runtime/execution-controller.js
+var ExecutionController = class {
+  constructor() {
+    this.state = "idle";
+    this.pauseRequested = false;
+    this.abortRequested = false;
+    this.stepCount = 0;
+    this.currentNode = null;
+    this.callStack = [];
+    this.currentEnv = null;
+    this._resolveResume = null;
+  }
+  // --- Control methods (called by user) ---
+  /**
+   * Request pause at next checkpoint. Only works during async evaluation.
+   */
+  pause() {
+    if (this.state === "running") {
+      this.pauseRequested = true;
+    }
+  }
+  /**
+   * Resume execution after pause.
+   */
+  resume() {
+    if (this.state === "paused" && this._resolveResume) {
+      this.pauseRequested = false;
+      this._resolveResume();
+      this._resolveResume = null;
+    }
+  }
+  /**
+   * Abort execution. Works for both sync and async evaluation.
+   * If paused, will resume and then abort.
+   */
+  abort() {
+    this.abortRequested = true;
+    if (this._resolveResume) {
+      this._resolveResume();
+      this._resolveResume = null;
+    }
+  }
+  // --- Status (called by user) ---
+  /**
+   * Get current execution status with full debug information.
+   * @returns {Object} Status object with state, stepCount, currentNode, callStack, and variables
+   */
+  getStatus() {
+    var _a;
+    return {
+      state: this.state,
+      stepCount: this.stepCount,
+      currentNode: ((_a = this.currentNode) == null ? void 0 : _a.type) || null,
+      callStack: [...this.callStack],
+      variables: this._getEnvironmentVariables()
+    };
+  }
+  /**
+   * Check if abort has been requested.
+   * Compatible with AbortSignal interface.
+   */
+  get aborted() {
+    return this.abortRequested;
+  }
+  // --- Internal methods (called by interpreter) ---
+  /**
+   * Mark execution as started. Called by execute().
+   * @internal
+   */
+  _start() {
+    this.state = "running";
+    this.stepCount = 0;
+    this.currentNode = null;
+    this.callStack = [];
+    this.pauseRequested = false;
+  }
+  /**
+   * Mark execution as completed. Called by execute().
+   * @internal
+   */
+  _complete() {
+    this.state = "completed";
+  }
+  /**
+   * Push a function call onto the call stack.
+   * @internal
+   */
+  _pushCall(name) {
+    this.callStack.push(name);
+  }
+  /**
+   * Pop a function call from the call stack.
+   * @internal
+   */
+  _popCall() {
+    this.callStack.pop();
+  }
+  /**
+   * Set the current environment for variable introspection.
+   * @internal
+   */
+  _setEnv(env) {
+    this.currentEnv = env;
+  }
+  /**
+   * Async checkpoint - yields if paused, throws if aborted.
+   * Called at coarse granularity points (loops, function calls).
+   * @internal
+   */
+  async _checkpoint(node) {
+    this.stepCount++;
+    this.currentNode = node;
+    if (this.abortRequested) {
+      this.state = "aborted";
+      const error = new Error("The operation was aborted");
+      error.name = "AbortError";
+      throw error;
+    }
+    if (this.pauseRequested && this.state === "running") {
+      this.state = "paused";
+      await new Promise((resolve) => {
+        this._resolveResume = resolve;
+      });
+      this.state = "running";
+      if (this.abortRequested) {
+        this.state = "aborted";
+        const error = new Error("The operation was aborted");
+        error.name = "AbortError";
+        throw error;
+      }
+    }
+  }
+  /**
+   * Sync abort check - only throws if aborted, cannot pause.
+   * Used in sync evaluate() path.
+   * @internal
+   */
+  _checkAbortSync() {
+    if (this.abortRequested) {
+      this.state = "aborted";
+      const error = new Error("The operation was aborted");
+      error.name = "AbortError";
+      throw error;
+    }
+  }
+  /**
+   * Get all variables from current environment chain.
+   * @internal
+   */
+  _getEnvironmentVariables() {
+    if (!this.currentEnv) return {};
+    const vars = {};
+    let env = this.currentEnv;
+    while (env) {
+      if (env.vars) {
+        for (const [key, value] of env.vars) {
+          if (!(key in vars)) {
+            vars[key] = this._serializeValue(value);
+          }
+        }
+      }
+      env = env.parent;
+    }
+    return vars;
+  }
+  /**
+   * Serialize a value for status reporting.
+   * @internal
+   */
+  _serializeValue(value) {
+    if (value === void 0) return { type: "undefined" };
+    if (value === null) return { type: "null" };
+    if (typeof value === "function" || value && value.__isFunction) {
+      return { type: "function", name: value.name || "anonymous" };
+    }
+    if (Array.isArray(value)) {
+      return { type: "array", length: value.length };
+    }
+    if (typeof value === "object") {
+      return { type: "object", preview: Object.keys(value).slice(0, 5) };
+    }
+    return { type: typeof value, value };
+  }
+};
+
 // src/index.js
 function containsModuleSyntax(code) {
   if (/^\s*(import|export)\s+/m.test(code)) {
@@ -7982,14 +9120,14 @@ function containsModuleSyntax(code) {
   }
   return false;
 }
-function parse4(code, options = {}) {
+function parse3(code, options = {}) {
   var _a;
   let sourceType = options.sourceType || "script";
   if (!options.sourceType && containsModuleSyntax(code)) {
     sourceType = "module";
   }
   try {
-    return parse3(code, {
+    return jsxParse(code, {
       ecmaVersion: 2022,
       // Support ES2022 features (including top-level await)
       sourceType,
@@ -8038,21 +9176,39 @@ function containsTopLevelAwait(node) {
   return false;
 }
 async function execute(code, env = null, options = {}) {
-  const ast = parse4(code, options);
-  if (!env) {
-    env = createGlobalEnvironment(new Environment());
+  const controller = options.executionController;
+  if (controller) {
+    controller._start();
   }
-  const interpreter = new Interpreter(env, {
-    moduleResolver: options.moduleResolver,
-    abortSignal: options.abortSignal
-  });
-  const needsAsync = options.sourceType === "module" || containsModuleDeclarations(ast) || containsTopLevelAwait(ast);
-  if (needsAsync) {
-    const result = await interpreter.evaluateAsync(ast, env);
-    return result instanceof ReturnValue ? result.value : result;
-  } else {
-    const result = interpreter.evaluate(ast, env);
-    return result instanceof ReturnValue ? result.value : result;
+  try {
+    const ast = parse3(code, options);
+    if (!env) {
+      env = createGlobalEnvironment(new Environment());
+    }
+    const interpreter = new Interpreter(env, {
+      moduleResolver: options.moduleResolver,
+      abortSignal: options.abortSignal,
+      executionController: controller
+    });
+    const needsAsync = options.sourceType === "module" || containsModuleDeclarations(ast) || containsTopLevelAwait(ast) || controller != null;
+    if (needsAsync) {
+      const result = await interpreter.evaluateAsync(ast, env);
+      if (controller) {
+        controller._complete();
+      }
+      return result instanceof ReturnValue ? result.value : result;
+    } else {
+      const result = interpreter.evaluate(ast, env);
+      if (controller) {
+        controller._complete();
+      }
+      return result instanceof ReturnValue ? result.value : result;
+    }
+  } catch (e) {
+    if (controller && e.name === "AbortError") {
+      controller.state = "aborted";
+    }
+    throw e;
   }
 }
 function createEnvironment() {
@@ -8089,6 +9245,7 @@ var ModuleResolver = class {
 };
 export {
   Environment,
+  ExecutionController,
   InMemoryModuleResolver,
   Interpreter,
   ModuleResolver,
@@ -8096,5 +9253,5 @@ export {
   createEnvironment,
   execute,
   isTopLevelAwait,
-  parse4 as parse
+  parse3 as parse
 };