wc-compiler 0.12.0 → 0.13.0

package/dist/wcc.dist.cjs

@@ -4,6 +4,14 @@ var fs = require('fs');
 
 function noop() { }
 
+// https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleSheet/CSSStyleSheet
+class CSSStyleSheet {
+  insertRule() { }
+  deleteRule() { }
+  replace() { }
+  replaceSync() { }
+}
+
 // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
 class EventTarget {
   constructor() {
@@ -97,6 +105,7 @@ class ShadowRoot extends DocumentFragment {
   constructor(options) {
     super();
     this.mode = options.mode || 'closed';
+    this.adoptedStyleSheets = [];
   }
 }
 
@@ -151,6 +160,7 @@ globalThis.addEventListener = globalThis.addEventListener ?? noop;
 globalThis.document = globalThis.document ?? new Document();
 globalThis.customElements = globalThis.customElements ?? new CustomElementsRegistry();
 globalThis.HTMLElement = globalThis.HTMLElement ?? HTMLElement;
+globalThis.CSSStyleSheet = globalThis.CSSStyleSheet ?? CSSStyleSheet;
 
 // Reserved word lists for various dialects of the language
 
@@ -1199,7 +1209,7 @@ pp$8.parseForStatement = function(node) {
 
 pp$8.parseFunctionStatement = function(node, isAsync, declarationPosition) {
   this.next();
-  return this.parseFunction(node, FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
+  return this.parseFunction(node, FUNC_STATEMENT$1 | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT), false, isAsync)
 };
 
 pp$8.parseIfStatement = function(node) {
@@ -1463,7 +1473,7 @@ pp$8.parseVarId = function(decl, kind) {
   this.checkLValPattern(decl.id, kind === "var" ? BIND_VAR : BIND_LEXICAL, false);
 };
 
-var FUNC_STATEMENT = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID = 4;
+var FUNC_STATEMENT$1 = 1, FUNC_HANGING_STATEMENT = 2, FUNC_NULLABLE_ID$1 = 4;
 
 // Parse a function declaration or literal (depending on the
 // `statement & FUNC_STATEMENT`).
@@ -1479,8 +1489,8 @@ pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   if (this.options.ecmaVersion >= 8)
     { node.async = !!isAsync; }
 
-  if (statement & FUNC_STATEMENT) {
-    node.id = (statement & FUNC_NULLABLE_ID) && this.type !== types$1.name ? null : this.parseIdent();
+  if (statement & FUNC_STATEMENT$1) {
+    node.id = (statement & FUNC_NULLABLE_ID$1) && this.type !== types$1.name ? null : this.parseIdent();
     if (node.id && !(statement & FUNC_HANGING_STATEMENT))
       // If it is a regular function declaration in sloppy mode, then it is
       // subject to Annex B semantics (BIND_FUNCTION). Otherwise, the binding
@@ -1495,7 +1505,7 @@ pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   this.awaitIdentPos = 0;
   this.enterScope(functionFlags(node.async, node.generator));
 
-  if (!(statement & FUNC_STATEMENT))
+  if (!(statement & FUNC_STATEMENT$1))
     { node.id = this.type === types$1.name ? this.parseIdent() : null; }
 
   this.parseFunctionParams(node);
@@ -1504,7 +1514,7 @@ pp$8.parseFunction = function(node, statement, allowExpressionBody, isAsync, for
   this.yieldPos = oldYieldPos;
   this.awaitPos = oldAwaitPos;
   this.awaitIdentPos = oldAwaitIdentPos;
-  return this.finishNode(node, (statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
+  return this.finishNode(node, (statement & FUNC_STATEMENT$1) ? "FunctionDeclaration" : "FunctionExpression")
 };
 
 pp$8.parseFunctionParams = function(node) {
@@ -1810,7 +1820,7 @@ pp$8.parseExport = function(node, exports) {
       var fNode = this.startNode();
       this.next();
       if (isAsync) { this.next(); }
-      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+      node.declaration = this.parseFunction(fNode, FUNC_STATEMENT$1 | FUNC_NULLABLE_ID$1, false, isAsync);
     } else if (this.type === types$1._class) {
       var cNode = this.startNode();
       node.declaration = this.parseClass(cNode, "nullableID");
@@ -5739,7 +5749,7 @@ function tokenizer$1(input, options) {
   return Parser$2.tokenizer(input, options)
 }
 
-var acorn = /*#__PURE__*/Object.freeze({
+var _acorn = /*#__PURE__*/Object.freeze({
   __proto__: null,
   Node: Node,
   Parser: Parser$2,
@@ -6055,35 +6065,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 = {};
 
 /*
@@ -7114,7 +7095,7 @@ var Syntax,
     quotes,
     escapeless,
     newline,
-    space,
+    space$1,
     parentheses,
     semicolons,
     safeConcatenation,
@@ -7594,7 +7575,7 @@ function toSourceNodeWhenNeeded(generated, node) {
 }
 
 function noEmptySpace() {
-    return (space) ? space : ' ';
+    return (space$1) ? space$1 : ' ';
 }
 
 function join(left, right) {
@@ -7624,7 +7605,7 @@ function join(left, right) {
             code.isWhiteSpace(rightCharCode) || code.isLineTerminator(rightCharCode)) {
         return [left, right];
     }
-    return [left, space, right];
+    return [left, space$1, right];
 }
 
 function addIndent(stmt) {
@@ -7890,7 +7871,7 @@ CodeGenerator.prototype.maybeBlock = function(stmt, flags) {
     noLeadingComment = !extra.comment || !stmt.leadingComments;
 
     if (stmt.type === Syntax.BlockStatement && noLeadingComment) {
-        return [space, this.generateStatement(stmt, flags)];
+        return [space$1, this.generateStatement(stmt, flags)];
     }
 
     if (stmt.type === Syntax.EmptyStatement && noLeadingComment) {
@@ -7910,7 +7891,7 @@ CodeGenerator.prototype.maybeBlock = function(stmt, flags) {
 CodeGenerator.prototype.maybeBlockSuffix = function (stmt, result) {
     var ends = endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString());
     if (stmt.type === Syntax.BlockStatement && (!extra.comment || !stmt.leadingComments) && !ends) {
-        return [result, space];
+        return [result, space$1];
     }
     if (ends) {
         return [result, base];
@@ -7923,12 +7904,12 @@ function generateIdentifier(node) {
 }
 
 function generateAsyncPrefix(node, spaceRequired) {
-    return node.async ? 'async' + (spaceRequired ? noEmptySpace() : space) : '';
+    return node.async ? 'async' + (spaceRequired ? noEmptySpace() : space$1) : '';
 }
 
 function generateStarSuffix(node) {
     var isGenerator = node.generator && !extra.moz.starlessGenerator;
-    return isGenerator ? '*' + space : '';
+    return isGenerator ? '*' + space$1 : '';
 }
 
 function generateMethodPrefix(prop) {
@@ -7974,13 +7955,13 @@ CodeGenerator.prototype.generateFunctionParams = function (node) {
                 result.push(this.generatePattern(node.params[i], Precedence.Assignment, E_TTT));
             }
             if (i + 1 < iz) {
-                result.push(',' + space);
+                result.push(',' + space$1);
             }
         }
 
         if (node.rest) {
             if (node.params.length) {
-                result.push(',' + space);
+                result.push(',' + space$1);
             }
             result.push('...');
             result.push(generateIdentifier(node.rest));
@@ -7998,12 +7979,12 @@ CodeGenerator.prototype.generateFunctionBody = function (node) {
     result = this.generateFunctionParams(node);
 
     if (node.type === Syntax.ArrowFunctionExpression) {
-        result.push(space);
+        result.push(space$1);
         result.push('=>');
     }
 
     if (node.expression) {
-        result.push(space);
+        result.push(space$1);
         expr = this.generateExpression(node.body, Precedence.Assignment, E_TTT);
         if (expr.toString().charAt(0) === '{') {
             expr = ['(', expr, ')'];
@@ -8017,7 +7998,7 @@ CodeGenerator.prototype.generateFunctionBody = function (node) {
 };
 
 CodeGenerator.prototype.generateIterationForStatement = function (operator, stmt, flags) {
-    var result = ['for' + (stmt.await ? noEmptySpace() + 'await' : '') + space + '('], that = this;
+    var result = ['for' + (stmt.await ? noEmptySpace() + 'await' : '') + space$1 + '('], that = this;
     withIndent(function () {
         if (stmt.left.type === Syntax.VariableDeclaration) {
             withIndent(function () {
@@ -8062,7 +8043,7 @@ CodeGenerator.prototype.generateAssignment = function (left, right, operator, pr
     return parenthesize(
         [
             this.generateExpression(left, Precedence.Call, flags),
-            space + operator + space,
+            space$1 + operator + space$1,
             this.generateExpression(right, Precedence.Assignment, flags)
         ],
         Precedence.Assignment,
@@ -8212,7 +8193,7 @@ CodeGenerator.Statement = {
             fragment = join('extends', this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
             result = join(result, fragment);
         }
-        result.push(space);
+        result.push(space$1);
         result.push(this.generateStatement(stmt.body, S_TFFT));
         return result;
     },
@@ -8229,7 +8210,7 @@ CodeGenerator.Statement = {
         var result = join('do', this.maybeBlock(stmt.body, S_TFFF));
         result = this.maybeBlockSuffix(stmt.body, result);
         return join(result, [
-            'while' + space + '(',
+            'while' + space$1 + '(',
             this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
             ')' + this.semicolon(flags)
         ]);
@@ -8242,7 +8223,7 @@ CodeGenerator.Statement = {
 
             if (stmt.param) {
                 result = [
-                    'catch' + space + '(',
+                    'catch' + space$1 + '(',
                     that.generateExpression(stmt.param, Precedence.Sequence, E_TTT),
                     ')'
                 ];
@@ -8298,7 +8279,7 @@ CodeGenerator.Statement = {
         // export ExportClause ;
         if (stmt.specifiers) {
             if (stmt.specifiers.length === 0) {
-                result = join(result, '{' + space + '}');
+                result = join(result, '{' + space$1 + '}');
             } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
                 result = join(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
             } else {
@@ -8322,7 +8303,7 @@ CodeGenerator.Statement = {
 
             if (stmt.source) {
                 result = join(result, [
-                    'from' + space,
+                    'from' + space$1,
                     // ModuleSpecifier
                     this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
                     this.semicolon(flags)
@@ -8337,9 +8318,9 @@ CodeGenerator.Statement = {
     ExportAllDeclaration: function (stmt, flags) {
         // export * FromClause ;
         return [
-            'export' + space,
-            '*' + space,
-            'from' + space,
+            'export' + space$1,
+            '*' + space$1,
+            'from' + space$1,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
             this.semicolon(flags)
@@ -8419,7 +8400,7 @@ CodeGenerator.Statement = {
             // import ModuleSpecifier ;
             return [
                 'import',
-                space,
+                space$1,
                 // ModuleSpecifier
                 this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
                 this.semicolon(flags)
@@ -8448,18 +8429,18 @@ CodeGenerator.Statement = {
             if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
                 // NameSpaceImport
                 result = join(result, [
-                        space,
+                        space$1,
                         this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
                 ]);
             } else {
                 // NamedImports
-                result.push(space + '{');
+                result.push(space$1 + '{');
 
                 if ((stmt.specifiers.length - cursor) === 1) {
                     // import { ... } from "...";
-                    result.push(space);
+                    result.push(space$1);
                     result.push(this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT));
-                    result.push(space + '}' + space);
+                    result.push(space$1 + '}' + space$1);
                 } else {
                     // import {
                     //    ...,
@@ -8479,13 +8460,13 @@ CodeGenerator.Statement = {
                     if (!endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())) {
                         result.push(newline);
                     }
-                    result.push(base + '}' + space);
+                    result.push(base + '}' + space$1);
                 }
             }
         }
 
         result = join(result, [
-            'from' + space,
+            'from' + space$1,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
             this.semicolon(flags)
@@ -8498,9 +8479,9 @@ CodeGenerator.Statement = {
         if (stmt.init) {
             return [
                 this.generateExpression(stmt.id, Precedence.Assignment, itemFlags),
-                space,
+                space$1,
                 '=',
-                space,
+                space$1,
                 this.generateExpression(stmt.init, Precedence.Assignment, itemFlags)
             ];
         }
@@ -8533,7 +8514,7 @@ CodeGenerator.Statement = {
                     result.push(',' + newline);
                     result.push(addIndent(that.generateStatement(node, bodyFlags)));
                 } else {
-                    result.push(',' + space);
+                    result.push(',' + space$1);
                     result.push(that.generateStatement(node, bodyFlags));
                 }
             }
@@ -8608,9 +8589,9 @@ CodeGenerator.Statement = {
         var result, fragment, i, iz, bodyFlags, that = this;
         withIndent(function () {
             result = [
-                'switch' + space + '(',
+                'switch' + space$1 + '(',
                 that.generateExpression(stmt.discriminant, Precedence.Sequence, E_TTT),
-                ')' + space + '{' + newline
+                ')' + space$1 + '{' + newline
             ];
         });
         if (stmt.cases) {
@@ -8673,7 +8654,7 @@ CodeGenerator.Statement = {
         var result, bodyFlags, semicolonOptional, that = this;
         withIndent(function () {
             result = [
-                'if' + space + '(',
+                'if' + space$1 + '(',
                 that.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
                 ')'
             ];
@@ -8700,7 +8681,7 @@ CodeGenerator.Statement = {
     ForStatement: function (stmt, flags) {
         var result, that = this;
         withIndent(function () {
-            result = ['for' + space + '('];
+            result = ['for' + space$1 + '('];
             if (stmt.init) {
                 if (stmt.init.type === Syntax.VariableDeclaration) {
                     result.push(that.generateStatement(stmt.init, S_FFFF));
@@ -8714,7 +8695,7 @@ CodeGenerator.Statement = {
             }
 
             if (stmt.test) {
-                result.push(space);
+                result.push(space$1);
                 result.push(that.generateExpression(stmt.test, Precedence.Sequence, E_TTT));
                 result.push(';');
             } else {
@@ -8722,7 +8703,7 @@ CodeGenerator.Statement = {
             }
 
             if (stmt.update) {
-                result.push(space);
+                result.push(space$1);
                 result.push(that.generateExpression(stmt.update, Precedence.Sequence, E_TTT));
                 result.push(')');
             } else {
@@ -8820,7 +8801,7 @@ CodeGenerator.Statement = {
         var result, that = this;
         withIndent(function () {
             result = [
-                'while' + space + '(',
+                'while' + space$1 + '(',
                 that.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
                 ')'
             ];
@@ -8833,7 +8814,7 @@ CodeGenerator.Statement = {
         var result, that = this;
         withIndent(function () {
             result = [
-                'with' + space + '(',
+                'with' + space$1 + '(',
                 that.generateExpression(stmt.object, Precedence.Sequence, E_TTT),
                 ')'
             ];
@@ -8859,7 +8840,7 @@ CodeGenerator.Expression = {
         for (i = 0, iz = expr.expressions.length; i < iz; ++i) {
             result.push(this.generateExpression(expr.expressions[i], Precedence.Assignment, flags));
             if (i + 1 < iz) {
-                result.push(',' + space);
+                result.push(',' + space$1);
             }
         }
         return parenthesize(result, Precedence.Sequence, precedence);
@@ -8880,9 +8861,9 @@ CodeGenerator.Expression = {
         return parenthesize(
             [
                 this.generateExpression(expr.test, Precedence.Coalesce, flags),
-                space + '?' + space,
+                space$1 + '?' + space$1,
                 this.generateExpression(expr.consequent, Precedence.Assignment, flags),
-                space + ':' + space,
+                space$1 + ':' + space$1,
                 this.generateExpression(expr.alternate, Precedence.Assignment, flags)
             ],
             Precedence.Conditional,
@@ -8951,7 +8932,7 @@ CodeGenerator.Expression = {
         for (i = 0, iz = expr['arguments'].length; i < iz; ++i) {
             result.push(this.generateExpression(expr['arguments'][i], Precedence.Assignment, E_TTT));
             if (i + 1 < iz) {
-                result.push(',' + space);
+                result.push(',' + space$1);
             }
         }
         result.push(')');
@@ -8991,7 +8972,7 @@ CodeGenerator.Expression = {
             for (i = 0, iz = length; i < iz; ++i) {
                 result.push(this.generateExpression(expr['arguments'][i], Precedence.Assignment, E_TTT));
                 if (i + 1 < iz) {
-                    result.push(',' + space);
+                    result.push(',' + space$1);
                 }
             }
             result.push(')');
@@ -9052,7 +9033,7 @@ CodeGenerator.Expression = {
         var result, fragment, rightCharCode, leftSource, leftCharCode;
         fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
 
-        if (space === '') {
+        if (space$1 === '') {
             result = join(expr.operator, fragment);
         } else {
             result = [expr.operator];
@@ -9133,7 +9114,7 @@ CodeGenerator.Expression = {
             result.push(generateStarSuffix(expr) || noEmptySpace());
             result.push(generateIdentifier(expr.id));
         } else {
-            result.push(generateStarSuffix(expr) || space);
+            result.push(generateStarSuffix(expr) || space$1);
         }
         result.push(this.generateFunctionBody(expr));
         return result;
@@ -9165,7 +9146,7 @@ CodeGenerator.Expression = {
                     result.push(that.generateExpression(expr.elements[i], Precedence.Assignment, E_TTT));
                 }
                 if (i + 1 < iz) {
-                    result.push(',' + (multiline ? newline : space));
+                    result.push(',' + (multiline ? newline : space$1));
                 }
             }
         });
@@ -9191,7 +9172,7 @@ CodeGenerator.Expression = {
             fragment = join('extends', this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
             result = join(result, fragment);
         }
-        result.push(space);
+        result.push(space$1);
         result.push(this.generateStatement(expr.body, S_TFFT));
         return result;
     },
@@ -9199,7 +9180,7 @@ CodeGenerator.Expression = {
     MethodDefinition: function (expr, precedence, flags) {
         var result, fragment;
         if (expr['static']) {
-            result = ['static' + space];
+            result = ['static' + space$1];
         } else {
             result = [];
         }
@@ -9244,7 +9225,7 @@ CodeGenerator.Expression = {
 
         return [
             this.generatePropertyKey(expr.key, expr.computed),
-            ':' + space,
+            ':' + space$1,
             this.generateExpression(expr.value, Precedence.Assignment, E_TTT)
         ];
     },
@@ -9271,7 +9252,7 @@ CodeGenerator.Expression = {
             //   dejavu.Class.declare({method2: function () {
             //       }});
             if (!hasLineTerminator(toSourceNodeWhenNeeded(fragment).toString())) {
-                return [ '{', space, fragment, space, '}' ];
+                return [ '{', space$1, fragment, space$1, '}' ];
             }
         }
 
@@ -9338,7 +9319,7 @@ CodeGenerator.Expression = {
                 result.push(multiline ? indent : '');
                 result.push(that.generateExpression(expr.properties[i], Precedence.Sequence, E_TTT));
                 if (i + 1 < iz) {
-                    result.push(',' + (multiline ? newline : space));
+                    result.push(',' + (multiline ? newline : space$1));
                 }
             }
         });
@@ -9371,7 +9352,7 @@ CodeGenerator.Expression = {
         var result = ['*'];
         var id = expr.id || expr.local;
         if (id) {
-            result.push(space + 'as' + noEmptySpace() + generateIdentifier(id));
+            result.push(space$1 + 'as' + noEmptySpace() + generateIdentifier(id));
         }
         return result;
     },
@@ -9474,7 +9455,7 @@ CodeGenerator.Expression = {
         }
 
         if (expr.filter) {
-            result = join(result, 'if' + space);
+            result = join(result, 'if' + space$1);
             fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
             result = join(result, [ '(', fragment, ')' ]);
         }
@@ -9503,7 +9484,7 @@ CodeGenerator.Expression = {
         fragment = join(fragment, expr.of ? 'of' : 'in');
         fragment = join(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
 
-        return [ 'for' + space + '(', fragment, ')' ];
+        return [ 'for' + space$1 + '(', fragment, ')' ];
     },
 
     SpreadElement: function (expr, precedence, flags) {
@@ -9537,9 +9518,9 @@ CodeGenerator.Expression = {
         for (i = 0, iz = expr.quasis.length; i < iz; ++i) {
             result.push(this.generateExpression(expr.quasis[i], Precedence.Primary, E_TTT));
             if (i + 1 < iz) {
-                result.push('${' + space);
+                result.push('${' + space$1);
                 result.push(this.generateExpression(expr.expressions[i], Precedence.Sequence, E_TTT));
-                result.push(space + '}');
+                result.push(space$1 + '}');
             }
         }
         result.push('`');
@@ -9648,9 +9629,9 @@ function generate(node, options) {
     quotes = json ? 'double' : options.format.quotes;
     escapeless = options.format.escapeless;
     newline = options.format.newline;
-    space = options.format.space;
+    space$1 = options.format.space;
     if (options.format.compact) {
-        newline = space = indent = base = '';
+        newline = space$1 = indent = base = '';
     }
     parentheses = options.format.parentheses;
     semicolons = options.format.semicolons;
@@ -9700,9 +9681,7 @@ function generate(node, options) {
 getDefaultOptions().format;
 updateDeeply({}, Precedence);
 
-var acornJsx = {exports: {}};
-
-var xhtml = {
+var XHTMLEntities = {
   quot: '\u0022',
   amp: '&',
   apos: '\u0027',
@@ -9958,500 +9937,489 @@ var xhtml = {
   diams: '\u2666'
 };
 
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(acorn);
-
-(function (module) {
+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')
+    };
 
-	const XHTMLEntities = xhtml;
+    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 hexNumber = /^[\da-fA-F]+$/;
-	const decimalNumber = /^\d+$/;
+    acornJsx = { tokContexts: tokContexts, tokTypes: tokTypes };
+    acornJsxMap.set(acorn, acornJsx);
+  }
 
-	// The map to `acorn-jsx` tokens from `acorn` namespace objects.
-	const acornJsxMap = new WeakMap();
+  return acornJsx;
+}
 
-	// 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')
-	    };
+// Transforms JSX element name to string.
 
-	    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;
-	      }
-	    };
+function getQualifiedJSXName(object) {
+  if (!object)
+    return object;
 
-	    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$1({
+      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$1(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 = {};
 
@@ -18373,6 +18341,294 @@ var serialize = function(node, options) {
     return serializer.serialize();
 };
 
+const leftCurlyBrace = "{".charCodeAt(0);
+const space = " ".charCodeAt(0);
+
+const withKeyword = "with";
+const assertKeyword = "assert";
+const FUNC_STATEMENT = 1, FUNC_NULLABLE_ID = 4;
+
+const importAttributes = plugin({ keyword: "with" });
+
+function plugin(options) {
+  return function(Parser) {
+    return pluginImpl(options, Parser);
+  };
+}
+
+function pluginImpl(options, Parser) {
+  // Use supplied version acorn version if present, to avoid
+  // reference mismatches due to different acorn versions. This
+  // allows this plugin to be used with Rollup which supplies
+  // its own internal version of acorn and thereby sidesteps
+  // the package manager.
+  const acorn = Parser.acorn || _acorn;
+  const { tokTypes: tt, TokenType } = acorn;
+  const { keyword } = options;
+  const isWithKeyword = keyword.includes(withKeyword);
+  const isAssertKeyword = keyword.includes(assertKeyword);
+  const isWithOrAssertKeyword = isWithKeyword && isAssertKeyword;
+
+  return class extends Parser {
+    constructor(...args) {
+      super(...args);
+      this.withToken = isWithKeyword && new TokenType(withKeyword);
+      this.assertToken = isAssertKeyword && new TokenType(assertKeyword);
+    }
+
+    _codeAt(i) {
+      return this.input.charCodeAt(i);
+    }
+
+    _eat(t) {
+      if (this.type !== t) {
+        this.unexpected();
+      }
+      this.next();
+    }
+
+    _matchKeywordToken() {
+      return (isWithOrAssertKeyword && (this.type === this.withToken || this.type === this.assertToken))
+        || (isWithKeyword && this.type === this.withToken)
+        || (isAssertKeyword && this.type === this.assertToken)
+    }
+
+    _getProperty() {
+      if (isWithOrAssertKeyword) {
+        return this.type === this.withToken ? "attributes" : "assertions";
+      }
+      return isWithKeyword ? "attributes" : "assertions";
+    }
+
+    readToken(code) {
+      let i = 0;
+      let keyword;
+      let token;
+      if (isWithOrAssertKeyword) {
+        if (this.input.slice(this.pos, this.pos + withKeyword.length) === withKeyword) {
+          keyword = withKeyword;
+          token = this.withToken;
+        } else if (this.input.slice(this.pos, this.pos + assertKeyword.length) === assertKeyword) {
+          keyword = assertKeyword;
+          token = this.assertToken;
+        } else {
+          return super.readToken(code);
+        }
+        i += keyword.length;
+      } else {
+        keyword = isWithKeyword ? withKeyword : assertKeyword;
+        token = isWithKeyword ? this.withToken : this.assertToken;
+        for (; i < keyword.length; i++) {
+          if (this._codeAt(this.pos + i) !== keyword.charCodeAt(i)) {
+            return super.readToken(code);
+          }
+        }
+      }
+
+      // ensure that the keyword is at the correct location
+      // ie `with{...` or `with {...`
+      for (;; i++) {
+        if (this._codeAt(this.pos + i) === leftCurlyBrace) {
+          // Found '{'
+          break;
+        } else if (this._codeAt(this.pos + i) === space) {
+          // white space is allowed between `with` and `{`, so continue.
+          continue;
+        } else {
+          return super.readToken(code);
+        }
+      }
+
+      // If we're inside a dynamic import expression we'll parse
+      // the `with` keyword as a standard object property name
+      // ie `import(""./foo.json", { with: { type: "json" } })`
+      if (this.type.label === "{") {
+        return super.readToken(code);
+      }
+
+      this.pos += keyword.length;
+      return this.finishToken(token);
+    }
+
+    parseDynamicImport(node) {
+      this.next(); // skip `(`
+
+      // Parse node.source.
+      node.source = this.parseMaybeAssign();
+
+      if (this.eat(tt.comma)) {
+        const expr = this.parseExpression();
+        node.arguments = [expr];
+      }
+      this._eat(tt.parenR);
+      return this.finishNode(node, "ImportExpression");
+    }
+
+    // ported from acorn/src/statement.js pp.parseExport
+    parseExport(node, exports) {
+      this.next();
+      // export * from '...'
+      if (this.eat(tt.star)) {
+        if (this.options.ecmaVersion >= 11) {
+          if (this.eatContextual("as")) {
+            node.exported = this.parseIdent(true);
+            this.checkExport(exports, node.exported.name, this.lastTokStart);
+          } else {
+            node.exported = null;
+          }
+        }
+        this.expectContextual("from");
+        if (this.type !== tt.string) { this.unexpected(); }
+        node.source = this.parseExprAtom();
+
+        if (this._matchKeywordToken()) {
+          const property = this._getProperty();
+          this.next();
+          const attributes = this.parseImportAttributes();
+          if (attributes) {
+            node[property] = attributes;
+          }
+        }
+
+        this.semicolon();
+        return this.finishNode(node, "ExportAllDeclaration")
+      }
+      if (this.eat(tt._default)) { // export default ...
+        this.checkExport(exports, "default", this.lastTokStart);
+        var isAsync;
+        if (this.type === tt._function || (isAsync = this.isAsyncFunction())) {
+          var fNode = this.startNode();
+          this.next();
+          if (isAsync) { this.next(); }
+          node.declaration = this.parseFunction(fNode, FUNC_STATEMENT | FUNC_NULLABLE_ID, false, isAsync);
+        } else if (this.type === tt._class) {
+          var cNode = this.startNode();
+          node.declaration = this.parseClass(cNode, "nullableID");
+        } else {
+          node.declaration = this.parseMaybeAssign();
+          this.semicolon();
+        }
+        return this.finishNode(node, "ExportDefaultDeclaration")
+      }
+      // export var|const|let|function|class ...
+      if (this.shouldParseExportStatement()) {
+        node.declaration = this.parseStatement(null);
+        if (node.declaration.type === "VariableDeclaration")
+          { this.checkVariableExport(exports, node.declaration.declarations); }
+        else
+          { this.checkExport(exports, node.declaration.id.name, node.declaration.id.start); }
+        node.specifiers = [];
+        node.source = null;
+      } else { // export { x, y as z } [from '...']
+        node.declaration = null;
+        node.specifiers = this.parseExportSpecifiers(exports);
+        if (this.eatContextual("from")) {
+          if (this.type !== tt.string) { this.unexpected(); }
+          node.source = this.parseExprAtom();
+
+          if (this._matchKeywordToken()) {
+            const property = this._getProperty();
+            this.next();
+            const attributes = this.parseImportAttributes();
+            if (attributes) {
+              node[property] = attributes;
+            }
+          }
+        } else {
+          for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+            // check for keywords used as local names
+            var spec = list[i];
+
+            this.checkUnreserved(spec.local);
+            // check if export is defined
+            this.checkLocalExport(spec.local);
+          }
+
+          node.source = null;
+        }
+        this.semicolon();
+      }
+      return this.finishNode(node, "ExportNamedDeclaration")
+    }
+
+    parseImport(node) {
+      this.next();
+      // import '...'
+      if (this.type === tt.string) {
+        node.specifiers = [];
+        node.source = this.parseExprAtom();
+      } else {
+        node.specifiers = this.parseImportSpecifiers();
+        this.expectContextual("from");
+        node.source =
+          this.type === tt.string ? this.parseExprAtom() : this.unexpected();
+      }
+
+      if (this._matchKeywordToken()) {
+        const property = this._getProperty();
+        this.next();
+        const attributes = this.parseImportAttributes();
+        if (attributes) {
+          node[property] = attributes;
+        }
+      }
+      this.semicolon();
+      return this.finishNode(node, "ImportDeclaration");
+    }
+
+    parseImportAttributes() {
+      this._eat(tt.braceL);
+      const attrs = this.parsewithEntries();
+      this._eat(tt.braceR);
+      return attrs;
+    }
+
+    parsewithEntries() {
+      const attrs = [];
+      const attrNames = new Set();
+
+      do {
+        if (this.type === tt.braceR) {
+          break;
+        }
+
+        const node = this.startNode();
+
+        // parse withionKey : IdentifierName, StringLiteral
+        let withionKeyNode;
+        if (this.type === tt.string) {
+          withionKeyNode = this.parseLiteral(this.value);
+        } else {
+          withionKeyNode = this.parseIdent(true);
+        }
+        this.next();
+        node.key = withionKeyNode;
+
+        // check if we already have an entry for an attribute
+        // if a duplicate entry is found, throw an error
+        // for now this logic will come into play only when someone declares `type` twice
+        if (attrNames.has(node.key.name)) {
+          this.raise(this.pos, "Duplicated key in attributes");
+        }
+        attrNames.add(node.key.name);
+
+        if (this.type !== tt.string) {
+          this.raise(
+            this.pos,
+            "Only string is supported as an attribute value"
+          );
+        }
+
+        node.value = this.parseLiteral(this.value);
+
+        attrs.push(this.finishNode(node, "ImportAttribute"));
+      } while (this.eat(tt.comma));
+
+      return attrs;
+    }
+  };
+}
+
 /* eslint-disable max-depth, complexity */
 // https://nodejs.org/api/esm.html#esm_loaders
 
@@ -18396,7 +18652,7 @@ function getParser(moduleURL) {
   }
 
   return {
-    parser: Parser$2.extend(jsx()),
+    parser: Parser$2.extend(acornJsx(), importAttributes),
     config: {
       // https://github.com/acornjs/acorn/issues/829#issuecomment-1172586171
       ...base$1,
@@ -18603,7 +18859,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(), importAttributes).parse(moduleContents, {
     ecmaVersion: 'latest',
     sourceType: 'module'
   });
@@ -18728,7 +18984,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'
     });
@@ -18792,12 +19048,12 @@ function registerDependencies(moduleURL, definitions, depth = 0) {
   const moduleContents = fs.readFileSync(moduleURL, 'utf-8');
   const nextDepth = depth += 1;
   const customParser = getParser(moduleURL);
-  const parser = customParser ? customParser.parser : acorn;
+  const parser = customParser ? customParser.parser : Parser$2;
   const config = customParser ? customParser.config : {
     ...base$1
   };
 
-  simple(parser.parse(moduleContents, {
+  simple(parser.extend(importAttributes).parse(moduleContents, {
     ecmaVersion: 'latest',
     sourceType: 'module'
   }), {
@@ -18837,13 +19093,13 @@ function registerDependencies(moduleURL, definitions, depth = 0) {
 async function getTagName(moduleURL) {
   const moduleContents = await fs.promises.readFile(moduleURL, 'utf-8');
   const customParser = getParser(moduleURL);
-  const parser = customParser ? customParser.parser : acorn;
+  const parser = customParser ? customParser.parser : Parser$2;
   const config = customParser ? customParser.config : {
     ...base$1
   };
   let tagName;
 
-  simple(parser.parse(moduleContents, {
+  simple(parser.extend(importAttributes).parse(moduleContents, {
     ecmaVersion: 'latest',
     sourceType: 'module'
   }), {
@@ -18864,9 +19120,10 @@ async function initializeCustomElement(elementURL, tagName, attrs = [], definiti
   }
 
   // https://github.com/ProjectEvergreen/wcc/pull/67/files#r902061804
-  const { pathname } = elementURL;
-  const element = customElements.get(tagName) ?? (await import(pathname)).default;
-  const dataLoader = (await import(pathname)).getData;
+  // https://github.com/ProjectEvergreen/wcc/pull/159
+  const { href } = elementURL;
+  const element = customElements.get(tagName) ?? (await import(href)).default;
+  const dataLoader = (await import(href)).getData;
   const data = props
     ? props
     : dataLoader