wc-compiler 0.12.0 → 0.12.1

package/dist/wcc.dist.cjs

@@ -6055,35 +6055,6 @@ base$1.MethodDefinition = base$1.PropertyDefinition = base$1.Property = function
   if (node.value) { c(node.value, st, "Expression"); }
 };
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-        return Reflect.construct(f, arguments, this.constructor);
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
 var estraverse = {};
 
 /*
@@ -9700,9 +9671,7 @@ function generate(node, options) {
 getDefaultOptions().format;
 updateDeeply({}, Precedence);
 
-var acornJsx = {exports: {}};
-
-var xhtml = {
+var XHTMLEntities = {
   quot: '\u0022',
   amp: '&',
   apos: '\u0027',
@@ -9958,500 +9927,489 @@ var xhtml = {
   diams: '\u2666'
 };
 
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(acorn);
+const hexNumber = /^[\da-fA-F]+$/;
+const decimalNumber = /^\d+$/;
+
+// The map to `acorn-jsx` tokens from `acorn` namespace objects.
+const acornJsxMap = new WeakMap();
+
+// Get the original tokens for the given `acorn` namespace object.
+function getJsxTokens(acorn) {
+  acorn = acorn.Parser.acorn || acorn;
+  let acornJsx = acornJsxMap.get(acorn);
+  if (!acornJsx) {
+    const tt = acorn.tokTypes;
+    const TokContext = acorn.TokContext;
+    const TokenType = acorn.TokenType;
+    const tc_oTag = new TokContext('<tag', false);
+    const tc_cTag = new TokContext('</tag', false);
+    const tc_expr = new TokContext('<tag>...</tag>', true, true);
+    const tokContexts = {
+      tc_oTag: tc_oTag,
+      tc_cTag: tc_cTag,
+      tc_expr: tc_expr
+    };
+    const tokTypes = {
+      jsxName: new TokenType('jsxName'),
+      jsxText: new TokenType('jsxText', {beforeExpr: true}),
+      jsxTagStart: new TokenType('jsxTagStart', {startsExpr: true}),
+      jsxTagEnd: new TokenType('jsxTagEnd')
+    };
 
-(function (module) {
+    tokTypes.jsxTagStart.updateContext = function() {
+      this.context.push(tc_expr); // treat as beginning of JSX expression
+      this.context.push(tc_oTag); // start opening tag context
+      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;
+      }
+    };
 
-	const XHTMLEntities = xhtml;
+    acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };
+    acornJsxMap.set(acorn, acornJsx);
+  }
 
-	const hexNumber = /^[\da-fA-F]+$/;
-	const decimalNumber = /^\d+$/;
+  return acornJsx;
+}
 
-	// The map to `acorn-jsx` tokens from `acorn` namespace objects.
-	const acornJsxMap = new WeakMap();
+// Transforms JSX element name to string.
 
-	// Get the original tokens for the given `acorn` namespace object.
-	function getJsxTokens(acorn) {
-	  acorn = acorn.Parser.acorn || acorn;
-	  let acornJsx = acornJsxMap.get(acorn);
-	  if (!acornJsx) {
-	    const tt = acorn.tokTypes;
-	    const TokContext = acorn.TokContext;
-	    const TokenType = acorn.TokenType;
-	    const tc_oTag = new TokContext('<tag', false);
-	    const tc_cTag = new TokContext('</tag', false);
-	    const tc_expr = new TokContext('<tag>...</tag>', true, true);
-	    const tokContexts = {
-	      tc_oTag: tc_oTag,
-	      tc_cTag: tc_cTag,
-	      tc_expr: tc_expr
-	    };
-	    const tokTypes = {
-	      jsxName: new TokenType('jsxName'),
-	      jsxText: new TokenType('jsxText', {beforeExpr: true}),
-	      jsxTagStart: new TokenType('jsxTagStart', {startsExpr: true}),
-	      jsxTagEnd: new TokenType('jsxTagEnd')
-	    };
+function getQualifiedJSXName(object) {
+  if (!object)
+    return object;
 
-	    tokTypes.jsxTagStart.updateContext = function() {
-	      this.context.push(tc_expr); // treat as beginning of JSX expression
-	      this.context.push(tc_oTag); // start opening tag context
-	      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;
-	      }
-	    };
-
-	    acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };
-	    acornJsxMap.set(acorn, acornJsx);
-	  }
-
-	  return acornJsx;
-	}
-
-	// Transforms JSX element name to string.
-
-	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);
-	}
-
-	module.exports = function(options) {
-	  options = options || {};
-	  return function(Parser) {
-	    return plugin({
-	      allowNamespaces: options.allowNamespaces !== false,
-	      allowNamespacedObjects: !!options.allowNamespacedObjects
-	    }, Parser);
-	  };
-	};
-
-	// This is `tokTypes` of the peer dep.
-	// This can be different instances from the actual `tokTypes` this plugin uses.
-	Object.defineProperty(module.exports, "tokTypes", {
-	  get: function get_tokTypes() {
-	    return getJsxTokens(require$$1).tokTypes;
-	  },
-	  configurable: true,
-	  enumerable: true
-	});
-
-	function plugin(options, Parser) {
-	  const acorn = Parser.acorn || require$$1;
-	  const acornJsx = getJsxTokens(acorn);
-	  const tt = acorn.tokTypes;
-	  const tok = acornJsx.tokTypes;
-	  const tokContexts = acorn.tokContexts;
-	  const tc_oTag = acornJsx.tokContexts.tc_oTag;
-	  const tc_cTag = acornJsx.tokContexts.tc_cTag;
-	  const tc_expr = acornJsx.tokContexts.tc_expr;
-	  const isNewLine = acorn.isNewLine;
-	  const isIdentifierStart = acorn.isIdentifierStart;
-	  const isIdentifierChar = acorn.isIdentifierChar;
-
-	  return class extends Parser {
-	    // Expose actual `tokTypes` and `tokContexts` to other plugins.
-	    static get acornJsx() {
-	      return acornJsx;
-	    }
+  if (object.type === 'JSXIdentifier')
+    return object.name;
 
-	    // 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 (isNewLine(ch)) {
-	            out += this.input.slice(chunkStart, this.pos);
-	            out += this.jsx_readNewLine(true);
-	            chunkStart = this.pos;
-	          } else {
-	            ++this.pos;
-	          }
-	        }
-	      }
-	    }
+  if (object.type === 'JSXNamespacedName')
+    return object.namespace.name + ':' + object.name.name;
 
-	    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;
-	    }
+  if (object.type === 'JSXMemberExpression')
+    return getQualifiedJSXName(object.object) + '.' +
+    getQualifiedJSXName(object.property);
+}
 
-	    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 (isNewLine(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);
-	    }
+function acornJsx(options) {
+  options = options || {};
+  return function(Parser) {
+    return plugin({
+      allowNamespaces: options.allowNamespaces !== false,
+      allowNamespacedObjects: !!options.allowNamespacedObjects
+    }, Parser);
+  };
+}
+// This is `tokTypes` of the peer dep.
+// This can be different instances from the actual `tokTypes` this plugin uses.
+Object.defineProperty(acornJsx, "tokTypes", {
+  get: function get_tokTypes() {
+    return getJsxTokens(acorn).tokTypes
+  },
+  configurable: true,
+  enumerable: true
+});
 
-	    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;
-	    }
+function plugin(options, Parser) {
+  const acorn = Parser.acorn || require("acorn");
+  const acornJsx = getJsxTokens(acorn);
+  const tt = acorn.tokTypes;
+  const tok = acornJsx.tokTypes;
+  const tokContexts = acorn.tokContexts;
+  const tc_oTag = acornJsx.tokContexts.tc_oTag;
+  const tc_cTag = acornJsx.tokContexts.tc_cTag;
+  const tc_expr = acornJsx.tokContexts.tc_expr;
+  const isNewLine = acorn.isNewLine;
+  const isIdentifierStart = acorn.isIdentifierStart;
+  const isIdentifierChar = acorn.isIdentifierChar;
+
+  return class extends Parser {
+    // Expose actual `tokTypes` and `tokContexts` to other plugins.
+    static get acornJsx() {
+      return acornJsx;
+    }
+
+    // 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] + "\"}" + "`?"
+          );
 
-	    // 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 (isIdentifierChar(ch) || ch === 45); // '-'
-	      return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));
-	    }
+        default:
+          if (isNewLine(ch)) {
+            out += this.input.slice(chunkStart, this.pos);
+            out += this.jsx_readNewLine(true);
+            chunkStart = this.pos;
+          } else {
+            ++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');
-	    }
+    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;
+      }
 
-	    // Parse namespaced identifier.
+      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 (isNewLine(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;
+    }
 
-	    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');
-	    }
+    // 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.
 
-	    // 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;
-	    }
+    jsx_readWord() {
+      let ch, start = this.pos;
+      do {
+        ch = this.input.charCodeAt(++this.pos);
+      } while (isIdentifierChar(ch) || ch === 45); // '-'
+      return this.finishToken(tok.jsxName, this.input.slice(start, this.pos));
+    }
 
-	    // Parses any type of JSX attribute value.
+    // Parse next token as JSX identifier
 
-	    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;
+    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');
+    }
 
-	      case tok.jsxTagStart:
-	      case tt.string:
-	        return this.parseExprAtom();
+    // Parse namespaced identifier.
 
-	      default:
-	        this.raise(this.start, 'JSX value should be either an expression or a quoted JSX text');
-	      }
-	    }
+    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');
+    }
 
-	    // 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).
+    // Parses element name in any form - namespaced, member
+    // or single identifier.
 
-	    jsx_parseEmptyExpression() {
-	      let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
-	      return this.finishNodeAt(node, 'JSXEmptyExpression', this.start, this.startLoc);
-	    }
+    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 JSX expression enclosed into curly brackets.
+    // Parses any type of JSX attribute value.
 
-	    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');
-	    }
+    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;
 
-	    // 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');
-	    }
+      case tok.jsxTagStart:
+      case tt.string:
+        return this.parseExprAtom();
 
-	    // 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');
-	    }
+      default:
+        this.raise(this.start, 'JSX value should be either an expression or a quoted JSX text');
+      }
+    }
 
-	    // Parses JSX closing tag starting after '</'.
+    // 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_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');
-	    }
+    jsx_parseEmptyExpression() {
+      let node = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+      return this.finishNodeAt(node, 'JSXEmptyExpression', this.start, this.startLoc);
+    }
 
-	    // 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;
+    // Parses JSX expression enclosed into curly brackets.
 
-	          case tok.jsxText:
-	            children.push(this.parseExprAtom());
-	            break;
+    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 tt.braceL:
-	            children.push(this.jsx_parseExpressionContainer());
-	            break;
+          case tok.jsxText:
+            children.push(this.parseExprAtom());
+            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);
-	    }
+          case tt.braceL:
+            children.push(this.jsx_parseExpressionContainer());
+            break;
 
-	    // Parse JSX text
+          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';
 
-	    jsx_parseText() {
-	      let node = this.parseLiteral(this.value);
-	      node.type = "JSXText";
-	      return node;
-	    }
+      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);
+    }
 
-	    // Parses entire JSX element from current position.
+    // Parse JSX text
 
-	    jsx_parseElement() {
-	      let startPos = this.start, startLoc = this.startLoc;
-	      this.next();
-	      return this.jsx_parseElementAt(startPos, startLoc);
-	    }
+    jsx_parseText() {
+      let node = this.parseLiteral(this.value);
+      node.type = "JSXText";
+      return node;
+    }
 
-	    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);
-	    }
+    // Parses entire JSX element from current position.
 
-	    readToken(code) {
-	      let context = this.curContext();
+    jsx_parseElement() {
+      let startPos = this.start, startLoc = this.startLoc;
+      this.next();
+      return this.jsx_parseElementAt(startPos, startLoc);
+    }
 
-	      if (context === tc_expr) return this.jsx_readToken();
+    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);
+    }
 
-	      if (context === tc_oTag || context === tc_cTag) {
-	        if (isIdentifierStart(code)) return this.jsx_readWord();
+    readToken(code) {
+      let context = this.curContext();
 
-	        if (code == 62) {
-	          ++this.pos;
-	          return this.finishToken(tok.jsxTagEnd);
-	        }
+      if (context === tc_expr) return this.jsx_readToken();
 
-	        if ((code === 34 || code === 39) && context == tc_oTag)
-	          return this.jsx_readString(code);
-	      }
+      if (context === tc_oTag || context === tc_cTag) {
+        if (isIdentifierStart(code)) return this.jsx_readWord();
 
-	      if (code === 60 && this.exprAllowed && this.input.charCodeAt(this.pos + 1) !== 33) {
-	        ++this.pos;
-	        return this.finishToken(tok.jsxTagStart);
-	      }
-	      return super.readToken(code);
-	    }
+        if (code == 62) {
+          ++this.pos;
+          return this.finishToken(tok.jsxTagEnd);
+        }
 
-	    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; // do not consider JSX expr -> JSX open tag -> ... anymore
-	        this.context.push(tc_cTag); // reconsider as closing tag context
-	        this.exprAllowed = false;
-	      } else {
-	        return super.updateContext(prevType);
-	      }
-	    }
-	  };
-	} 
-} (acornJsx));
+        if ((code === 34 || code === 39) && context == tc_oTag)
+          return this.jsx_readString(code);
+      }
 
-var acornJsxExports = acornJsx.exports;
-var jsx = /*@__PURE__*/getDefaultExportFromCjs(acornJsxExports);
+      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; // do not consider JSX expr -> JSX open tag -> ... anymore
+        this.context.push(tc_cTag); // reconsider as closing tag context
+        this.exprAllowed = false;
+      } else {
+        return super.updateContext(prevType);
+      }
+    }
+  };
+}
 
 var unicode$3 = {};
 
@@ -18396,7 +18354,7 @@ function getParser(moduleURL) {
   }
 
   return {
-    parser: Parser$2.extend(jsx()),
+    parser: Parser$2.extend(acornJsx()),
     config: {
       // https://github.com/acornjs/acorn/issues/829#issuecomment-1172586171
       ...base$1,
@@ -18603,7 +18561,7 @@ function parseJsx(moduleURL) {
   const hasOwnObservedAttributes = undefined;
   let inferredObservability = false;
   let observedAttributes = [];
-  let tree = Parser$2.extend(jsx()).parse(moduleContents, {
+  let tree = Parser$2.extend(acornJsx()).parse(moduleContents, {
     ecmaVersion: 'latest',
     sourceType: 'module'
   });
@@ -18728,7 +18686,7 @@ function parseJsx(moduleURL) {
     `;
     /* eslint-enable indent */
 
-    tree = Parser$2.extend(jsx()).parse(newModuleContents, {
+    tree = Parser$2.extend(acornJsx()).parse(newModuleContents, {
       ecmaVersion: 'latest',
       sourceType: 'module'
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wc-compiler",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Experimental native Web Components compiler.",
   "repository": {
     "type": "git",

package/src/jsx-loader.js

@@ -4,7 +4,7 @@ import * as acorn from 'acorn';
 import * as walk from 'acorn-walk';
 import { generate } from '@projectevergreen/escodegen-esm';
 import fs from 'fs';
-import jsx from 'acorn-jsx';
+import jsx from '@projectevergreen/acorn-jsx-esm';
 import { parse, parseFragment, serialize } from 'parse5';
 
 const jsxRegex = /\.(jsx)$/;