ember-source 5.0.0-alpha.7 → 5.0.0-beta.3

package/dist/ember-template-compiler.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   5.0.0-alpha.7
+ * @version   5.0.0-beta.3
  */
 
 /* eslint-disable no-var */
@@ -951,17 +951,6 @@ define("@ember/-internals/utils/index", ["exports", "@glimmer/util", "@ember/deb
       }
     };
   }
-
-  /*
-   This package will be eagerly parsed and should have no dependencies on external
-   packages.
-  
-   It is intended to be used to share utility methods that will be needed
-   by every Ember application (and is **not** a dumping ground of useful utilities).
-  
-   Utility methods that are needed in < 80% of cases should be placed
-   elsewhere (so they can be lazily evaluated / parsed).
-  */
 });
 define("@ember/canary-features/index", ["exports", "@ember/-internals/environment"], function (_exports, _environment) {
   "use strict";
@@ -2011,13 +2000,13 @@ define("@ember/debug/lib/deprecate", ["exports", "@ember/-internals/environment"
     };
     var formatMessage = function formatMessage(_message, options) {
       var message = _message;
-      if (options === null || options === void 0 ? void 0 : options.id) {
+      if (options != null && options.id) {
         message = message + (" [deprecation id: " + options.id + "]");
       }
-      if (options === null || options === void 0 ? void 0 : options.until) {
+      if (options != null && options.until) {
         message = message + (" This will be removed in " + options.for + " " + options.until + ".");
       }
-      if (options === null || options === void 0 ? void 0 : options.url) {
+      if (options != null && options.url) {
         message += " See " + options.url + " for more details.";
       }
       return message;
@@ -2659,11 +2648,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       }
       this.types = nodes;
     }
-    match(node$$1) {
-      if (!this.types.has(node$$1.type)) {
+    match(node) {
+      if (!this.types.has(node.type)) {
         return false;
       }
-      var path = getCalleeExpression(node$$1);
+      var path = getCalleeExpression(node);
       if (path !== null && path.type === 'Path' && path.ref.type === 'Free') {
         if (path.tail.length > 0) {
           if (path.ref.resolution.serialize() === 'Loose') {
@@ -2677,15 +2666,15 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         return false;
       }
     }
-    translate(node$$1, state) {
-      if (this.match(node$$1)) {
-        var path = getCalleeExpression(node$$1);
+    translate(node, state) {
+      if (this.match(node)) {
+        var path = getCalleeExpression(node);
         if (path !== null && path.type === 'Path' && path.tail.length > 0) {
-          return Err((0, _syntax.generateSyntaxError)("The `" + this.keyword + "` keyword was used incorrectly. It was used as `" + path.loc.asString() + "`, but it cannot be used with additional path segments. \n\nError caused by", node$$1.loc));
+          return Err((0, _syntax.generateSyntaxError)("The `" + this.keyword + "` keyword was used incorrectly. It was used as `" + path.loc.asString() + "`, but it cannot be used with additional path segments. \n\nError caused by", node.loc));
         }
-        var param = this.delegate.assert(node$$1, state);
+        var param = this.delegate.assert(node, state);
         return param.andThen(param => this.delegate.translate({
-          node: node$$1,
+          node,
           state
         }, param));
       } else {
@@ -2702,18 +2691,18 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   function keyword(keyword, type, delegate) {
     return new KeywordImpl(keyword, type, delegate);
   }
-  function getCalleeExpression(node$$1) {
-    switch (node$$1.type) {
+  function getCalleeExpression(node) {
+    switch (node.type) {
       // This covers the inside of attributes and expressions, as well as the callee
       // of call nodes
       case 'Path':
-        return node$$1;
+        return node;
       case 'AppendContent':
-        return getCalleeExpression(node$$1.value);
+        return getCalleeExpression(node.value);
       case 'Call':
       case 'InvokeBlock':
       case 'ElementModifier':
-        return node$$1.callee;
+        return node.callee;
       default:
         return null;
     }
@@ -2727,14 +2716,14 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       this._keywords.push(keyword(name, this._type, delegate));
       return this;
     }
-    translate(node$$1, state) {
+    translate(node, state) {
       for (var _keyword of this._keywords) {
-        var result = _keyword.translate(node$$1, state);
+        var result = _keyword.translate(node, state);
         if (result !== null) {
           return result;
         }
       }
-      var path = getCalleeExpression(node$$1);
+      var path = getCalleeExpression(node);
       if (path && path.type === 'Path' && path.ref.type === 'Free' && (0, _syntax.isKeyword)(path.ref.name)) {
         var {
           name
@@ -2742,7 +2731,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         var usedType = this._type;
         var validTypes = _syntax.KEYWORDS_TYPES[name];
         if (validTypes.indexOf(usedType) === -1) {
-          return Err((0, _syntax.generateSyntaxError)("The `" + name + "` keyword was used incorrectly. It was used as " + typesToReadableName[usedType] + ", but its valid usages are:\n\n" + generateTypesMessage(name, validTypes) + "\n\nError caused by", node$$1.loc));
+          return Err((0, _syntax.generateSyntaxError)("The `" + name + "` keyword was used incorrectly. It was used as " + typesToReadableName[usedType] + ", but its valid usages are:\n\n" + generateTypesMessage(name, validTypes) + "\n\nError caused by", node.loc));
         }
       }
       return null;
@@ -2855,14 +2844,14 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   function keywords(type) {
     return new Keywords(type);
   }
-  function hasPath(node$$1) {
-    return node$$1.callee.type === 'Path';
+  function hasPath(node) {
+    return node.callee.type === 'Path';
   }
-  function isHelperInvocation(node$$1) {
-    if (!hasPath(node$$1)) {
+  function isHelperInvocation(node) {
+    if (!hasPath(node)) {
       return false;
     }
-    return !node$$1.args.isEmpty();
+    return !node.args.isEmpty();
   }
   function isSimplePath(path) {
     if (path.type === 'Path') {
@@ -2920,22 +2909,22 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     }
   }
   class NormalizeExpressions {
-    visit(node$$1, state) {
-      switch (node$$1.type) {
+    visit(node, state) {
+      switch (node.type) {
         case 'Literal':
-          return Ok(this.Literal(node$$1));
+          return Ok(this.Literal(node));
         case 'Interpolate':
-          return this.Interpolate(node$$1, state);
+          return this.Interpolate(node, state);
         case 'Path':
-          return this.PathExpression(node$$1);
+          return this.PathExpression(node);
         case 'Call':
-          var translated = CALL_KEYWORDS.translate(node$$1, state);
+          var translated = CALL_KEYWORDS.translate(node, state);
           if (translated !== null) {
             return translated;
           }
-          return this.CallExpression(node$$1, state);
+          return this.CallExpression(node, state);
         case 'DeprecatedCall':
-          return this.DeprecaedCallExpression(node$$1, state);
+          return this.DeprecaedCallExpression(node, state);
       }
     }
     visitList(nodes, state) {
@@ -3062,23 +3051,23 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     /* Modifier */]: 'modifier'
   };
   function assertCurryKeyword(curriedType) {
-    return (node$$1, state) => {
+    return (node, state) => {
       var readableType = CurriedTypeToReadableType[curriedType];
       var stringsAllowed = curriedType === 0
       /* Component */;
 
       var {
         args
-      } = node$$1;
+      } = node;
       var definition = args.nth(0);
       if (definition === null) {
         return Err((0, _syntax.generateSyntaxError)("(" + readableType + ") requires a " + readableType + " definition or identifier as its first positional parameter, did not receive any parameters.", args.loc));
       }
       if (definition.type === 'Literal') {
         if (stringsAllowed && state.isStrict) {
-          return Err((0, _syntax.generateSyntaxError)("(" + readableType + ") cannot resolve string values in strict mode templates", node$$1.loc));
+          return Err((0, _syntax.generateSyntaxError)("(" + readableType + ") cannot resolve string values in strict mode templates", node.loc));
         } else if (!stringsAllowed) {
-          return Err((0, _syntax.generateSyntaxError)("(" + readableType + ") cannot resolve string values, you must pass a " + readableType + " definition directly", node$$1.loc));
+          return Err((0, _syntax.generateSyntaxError)("(" + readableType + ") cannot resolve string values, you must pass a " + readableType + " definition directly", node.loc));
         }
       }
       args = new _syntax.ASTv2.Args({
@@ -3098,7 +3087,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   function translateCurryKeyword(curriedType) {
     return (_ref7, _ref8) => {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref7;
       var {
@@ -3110,7 +3099,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       return Result.all(definitionResult, argsResult).mapOk(_ref9 => {
         var [definition, args] = _ref9;
         return new Curry({
-          loc: node$$1.loc,
+          loc: node.loc,
           curriedType,
           definition,
           args
@@ -3124,30 +3113,30 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       translate: translateCurryKeyword(curriedType)
     };
   }
-  function assertGetDynamicVarKeyword(node$$1) {
-    var call = node$$1.type === 'AppendContent' ? node$$1.value : node$$1;
+  function assertGetDynamicVarKeyword(node) {
+    var call = node.type === 'AppendContent' ? node.value : node;
     var named = call.type === 'Call' ? call.args.named : null;
     var positionals = call.type === 'Call' ? call.args.positional : null;
     if (named && !named.isEmpty()) {
-      return Err((0, _syntax.generateSyntaxError)("(-get-dynamic-vars) does not take any named arguments", node$$1.loc));
+      return Err((0, _syntax.generateSyntaxError)("(-get-dynamic-vars) does not take any named arguments", node.loc));
     }
     var varName = positionals === null || positionals === void 0 ? void 0 : positionals.nth(0);
     if (!varName) {
-      return Err((0, _syntax.generateSyntaxError)("(-get-dynamic-vars) requires a var name to get", node$$1.loc));
+      return Err((0, _syntax.generateSyntaxError)("(-get-dynamic-vars) requires a var name to get", node.loc));
     }
     if (positionals && positionals.size > 1) {
-      return Err((0, _syntax.generateSyntaxError)("(-get-dynamic-vars) only receives one positional arg", node$$1.loc));
+      return Err((0, _syntax.generateSyntaxError)("(-get-dynamic-vars) only receives one positional arg", node.loc));
     }
     return Ok(varName);
   }
   function translateGetDynamicVarKeyword(_ref10, name) {
     var {
-      node: node$$1,
+      node,
       state
     } = _ref10;
     return VISIT_EXPRS.visit(name, state).mapOk(name => new GetDynamicVar({
       name,
-      loc: node$$1.loc
+      loc: node.loc
     }));
   }
   var getDynamicVarKeyword = {
@@ -3155,8 +3144,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     translate: translateGetDynamicVarKeyword
   };
   function assertHasBlockKeyword(type) {
-    return node$$1 => {
-      var call = node$$1.type === 'AppendContent' ? node$$1.value : node$$1;
+    return node => {
+      var call = node.type === 'AppendContent' ? node.value : node;
       var named = call.type === 'Call' ? call.args.named : null;
       var positionals = call.type === 'Call' ? call.args.positional : null;
       if (named && !named.isEmpty()) {
@@ -3179,17 +3168,17 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   function translateHasBlockKeyword(type) {
     return (_ref11, target) => {
       var {
-        node: node$$1,
+        node,
         state: {
           scope
         }
       } = _ref11;
       var block = type === 'has-block' ? new HasBlock({
-        loc: node$$1.loc,
+        loc: node.loc,
         target,
         symbol: scope.allocateBlock(target.chars)
       }) : new HasBlockParams({
-        loc: node$$1.loc,
+        loc: node.loc,
         target,
         symbol: scope.allocateBlock(target.chars)
       });
@@ -3206,9 +3195,9 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     return originalNode => {
       var _a;
       var inverted = type === 'unless';
-      var node$$1 = originalNode.type === 'AppendContent' ? originalNode.value : originalNode;
-      var named = node$$1.type === 'Call' ? node$$1.args.named : null;
-      var positional = node$$1.type === 'Call' ? node$$1.args.positional : null;
+      var node = originalNode.type === 'AppendContent' ? originalNode.value : originalNode;
+      var named = node.type === 'Call' ? node.args.named : null;
+      var positional = node.type === 'Call' ? node.args.positional : null;
       if (named && !named.isEmpty()) {
         return Err((0, _syntax.generateSyntaxError)("(" + type + ") cannot receive named parameters, received " + named.entries.map(e => e.name.chars).join(', '), originalNode.loc));
       }
@@ -3235,7 +3224,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     var inverted = type === 'unless';
     return (_ref12, _ref13) => {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref12;
       var {
@@ -3251,11 +3240,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         if (inverted) {
           condition = new Not({
             value: condition,
-            loc: node$$1.loc
+            loc: node.loc
           });
         }
         return new IfInline({
-          loc: node$$1.loc,
+          loc: node.loc,
           condition,
           truthy,
           falsy
@@ -3269,26 +3258,26 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       translate: translateIfUnlessInlineKeyword(type)
     };
   }
-  function assertLogKeyword(node$$1) {
+  function assertLogKeyword(node) {
     var {
       args: {
         named,
         positional
       }
-    } = node$$1;
+    } = node;
     if (named && !named.isEmpty()) {
-      return Err((0, _syntax.generateSyntaxError)("(log) does not take any named arguments", node$$1.loc));
+      return Err((0, _syntax.generateSyntaxError)("(log) does not take any named arguments", node.loc));
     }
     return Ok(positional);
   }
   function translateLogKeyword(_ref15, positional) {
     var {
-      node: node$$1,
+      node,
       state
     } = _ref15;
     return VISIT_EXPRS.Positional(positional, state).mapOk(positional => new Log({
       positional,
-      loc: node$$1.loc
+      loc: node.loc
     }));
   }
   var logKeyword = {
@@ -3309,25 +3298,25 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       assert,
       translate(_ref17, value) {
         var {
-          node: node$$1,
+          node,
           state
         } = _ref17;
         var result = translate({
-          node: node$$1,
+          node,
           state
         }, value);
         return result.mapOk(text => new AppendTextNode({
           text,
-          loc: node$$1.loc
+          loc: node.loc
         }));
       }
     };
   }
   var APPEND_KEYWORDS = keywords('Append').kw('has-block', toAppend(hasBlockKeyword('has-block'))).kw('has-block-params', toAppend(hasBlockKeyword('has-block-params'))).kw('-get-dynamic-var', toAppend(getDynamicVarKeyword)).kw('log', toAppend(logKeyword)).kw('if', toAppend(ifUnlessInlineKeyword('if'))).kw('unless', toAppend(ifUnlessInlineKeyword('unless'))).kw('yield', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       if (args.named.isEmpty()) {
         return Ok({
           target: _syntax.SourceSpan.synthetic('default').toSlice(),
@@ -3350,7 +3339,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref18, _ref19) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref18;
       var {
@@ -3358,17 +3347,17 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         positional
       } = _ref19;
       return VISIT_EXPRS.Positional(positional, state).mapOk(positional => new Yield({
-        loc: node$$1.loc,
+        loc: node.loc,
         target,
         to: state.scope.allocateBlock(target.chars),
         positional
       }));
     }
   }).kw('debugger', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       var {
         positional
       } = args;
@@ -3376,22 +3365,22 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         return Ok(undefined);
       } else {
         if (positional.isEmpty()) {
-          return Err((0, _syntax.generateSyntaxError)("debugger does not take any named arguments", node$$1.loc));
+          return Err((0, _syntax.generateSyntaxError)("debugger does not take any named arguments", node.loc));
         } else {
-          return Err((0, _syntax.generateSyntaxError)("debugger does not take any positional arguments", node$$1.loc));
+          return Err((0, _syntax.generateSyntaxError)("debugger does not take any positional arguments", node.loc));
         }
       }
     },
     translate(_ref20) {
       var {
-        node: node$$1,
+        node,
         state: {
           scope
         }
       } = _ref20;
       scope.setHasEval();
       return Ok(new Debugger({
-        loc: node$$1.loc,
+        loc: node.loc,
         scope
       }));
     }
@@ -3401,7 +3390,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
     translate(_ref21, _ref22) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref21;
       var {
@@ -3413,7 +3402,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       return Result.all(definitionResult, argsResult).mapOk(_ref23 => {
         var [definition, args] = _ref23;
         return new InvokeComponent({
-          loc: node$$1.loc,
+          loc: node.loc,
           definition,
           args,
           blocks: null
@@ -3426,7 +3415,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
     translate(_ref24, _ref25) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref24;
       var {
@@ -3440,20 +3429,20 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         var text = new CallExpression({
           callee: definition,
           args,
-          loc: node$$1.loc
+          loc: node.loc
         });
         return new AppendTextNode({
-          loc: node$$1.loc,
+          loc: node.loc,
           text
         });
       });
     }
   });
   var BLOCK_KEYWORDS = keywords('Block').kw('in-element', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       var guid = args.get('guid');
       if (guid) {
         return Err((0, _syntax.generateSyntaxError)("Cannot pass `guid` to `{{#in-element}}`", guid.loc));
@@ -3471,14 +3460,14 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref27, _ref28) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref27;
       var {
         insertBefore,
         destination
       } = _ref28;
-      var named = node$$1.blocks.get('default');
+      var named = node.blocks.get('default');
       var body = VISIT_STMTS.NamedBlock(named, state);
       var destinationResult = VISIT_EXPRS.visit(destination, state);
       return Result.all(body, destinationResult).andThen(_ref29 => {
@@ -3494,7 +3483,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
             body,
             destination,
             insertBefore: new Missing({
-              loc: node$$1.callee.loc.collapse('end')
+              loc: node.callee.loc.collapse('end')
             })
           });
         }
@@ -3505,7 +3494,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
           insertBefore
         } = _ref30;
         return new InElement({
-          loc: node$$1.loc,
+          loc: node.loc,
           block: body,
           insertBefore,
           guid: state.generateUniqueCursor(),
@@ -3514,19 +3503,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       });
     }
   }).kw('if', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       if (!args.named.isEmpty()) {
-        return Err((0, _syntax.generateSyntaxError)("{{#if}} cannot receive named parameters, received " + args.named.entries.map(e => e.name.chars).join(', '), node$$1.loc));
+        return Err((0, _syntax.generateSyntaxError)("{{#if}} cannot receive named parameters, received " + args.named.entries.map(e => e.name.chars).join(', '), node.loc));
       }
       if (args.positional.size > 1) {
-        return Err((0, _syntax.generateSyntaxError)("{{#if}} can only receive one positional parameter in block form, the conditional value. Received " + args.positional.size + " parameters", node$$1.loc));
+        return Err((0, _syntax.generateSyntaxError)("{{#if}} can only receive one positional parameter in block form, the conditional value. Received " + args.positional.size + " parameters", node.loc));
       }
       var condition = args.nth(0);
       if (condition === null) {
-        return Err((0, _syntax.generateSyntaxError)("{{#if}} requires a condition as its first positional parameter, did not receive any parameters", node$$1.loc));
+        return Err((0, _syntax.generateSyntaxError)("{{#if}} requires a condition as its first positional parameter, did not receive any parameters", node.loc));
       }
       return Ok({
         condition
@@ -3534,21 +3523,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref31, _ref32) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref31;
       var {
         condition
       } = _ref32;
-      var block = node$$1.blocks.get('default');
-      var inverse = node$$1.blocks.get('else');
+      var block = node.blocks.get('default');
+      var inverse = node.blocks.get('else');
       var conditionResult = VISIT_EXPRS.visit(condition, state);
       var blockResult = VISIT_STMTS.NamedBlock(block, state);
       var inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
       return Result.all(conditionResult, blockResult, inverseResult).mapOk(_ref33 => {
         var [condition, block, inverse] = _ref33;
         return new If({
-          loc: node$$1.loc,
+          loc: node.loc,
           condition,
           block,
           inverse
@@ -3556,19 +3545,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       });
     }
   }).kw('unless', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       if (!args.named.isEmpty()) {
-        return Err((0, _syntax.generateSyntaxError)("{{#unless}} cannot receive named parameters, received " + args.named.entries.map(e => e.name.chars).join(', '), node$$1.loc));
+        return Err((0, _syntax.generateSyntaxError)("{{#unless}} cannot receive named parameters, received " + args.named.entries.map(e => e.name.chars).join(', '), node.loc));
       }
       if (args.positional.size > 1) {
-        return Err((0, _syntax.generateSyntaxError)("{{#unless}} can only receive one positional parameter in block form, the conditional value. Received " + args.positional.size + " parameters", node$$1.loc));
+        return Err((0, _syntax.generateSyntaxError)("{{#unless}} can only receive one positional parameter in block form, the conditional value. Received " + args.positional.size + " parameters", node.loc));
       }
       var condition = args.nth(0);
       if (condition === null) {
-        return Err((0, _syntax.generateSyntaxError)("{{#unless}} requires a condition as its first positional parameter, did not receive any parameters", node$$1.loc));
+        return Err((0, _syntax.generateSyntaxError)("{{#unless}} requires a condition as its first positional parameter, did not receive any parameters", node.loc));
       }
       return Ok({
         condition
@@ -3576,24 +3565,24 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref34, _ref35) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref34;
       var {
         condition
       } = _ref35;
-      var block = node$$1.blocks.get('default');
-      var inverse = node$$1.blocks.get('else');
+      var block = node.blocks.get('default');
+      var inverse = node.blocks.get('else');
       var conditionResult = VISIT_EXPRS.visit(condition, state);
       var blockResult = VISIT_STMTS.NamedBlock(block, state);
       var inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
       return Result.all(conditionResult, blockResult, inverseResult).mapOk(_ref36 => {
         var [condition, block, inverse] = _ref36;
         return new If({
-          loc: node$$1.loc,
+          loc: node.loc,
           condition: new Not({
             value: condition,
-            loc: node$$1.loc
+            loc: node.loc
           }),
           block,
           inverse
@@ -3601,10 +3590,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       });
     }
   }).kw('each', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       if (!args.named.entries.every(e => e.name.chars === 'key')) {
         return Err((0, _syntax.generateSyntaxError)("{{#each}} can only receive the 'key' named parameter, received " + args.named.entries.filter(e => e.name.chars !== 'key').map(e => e.name.chars).join(', '), args.named.loc));
       }
@@ -3623,15 +3612,15 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref37, _ref38) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref37;
       var {
         value,
         key
       } = _ref38;
-      var block = node$$1.blocks.get('default');
-      var inverse = node$$1.blocks.get('else');
+      var block = node.blocks.get('default');
+      var inverse = node.blocks.get('else');
       var valueResult = VISIT_EXPRS.visit(value, state);
       var keyResult = key ? VISIT_EXPRS.visit(key, state) : Ok(null);
       var blockResult = VISIT_STMTS.NamedBlock(block, state);
@@ -3639,7 +3628,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       return Result.all(valueResult, keyResult, blockResult, inverseResult).mapOk(_ref39 => {
         var [value, key, block, inverse] = _ref39;
         return new Each({
-          loc: node$$1.loc,
+          loc: node.loc,
           value,
           key,
           block,
@@ -3648,10 +3637,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       });
     }
   }).kw('with', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       if (!args.named.isEmpty()) {
         return Err((0, _syntax.generateSyntaxError)("{{#with}} cannot receive named parameters, received " + args.named.entries.map(e => e.name.chars).join(', '), args.named.loc));
       }
@@ -3668,21 +3657,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref40, _ref41) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref40;
       var {
         value
       } = _ref41;
-      var block = node$$1.blocks.get('default');
-      var inverse = node$$1.blocks.get('else');
+      var block = node.blocks.get('default');
+      var inverse = node.blocks.get('else');
       var valueResult = VISIT_EXPRS.visit(value, state);
       var blockResult = VISIT_STMTS.NamedBlock(block, state);
       var inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
       return Result.all(valueResult, blockResult, inverseResult).mapOk(_ref42 => {
         var [value, block, inverse] = _ref42;
         return new With({
-          loc: node$$1.loc,
+          loc: node.loc,
           value,
           block,
           inverse
@@ -3690,17 +3679,17 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       });
     }
   }).kw('let', {
-    assert(node$$1) {
+    assert(node) {
       var {
         args
-      } = node$$1;
+      } = node;
       if (!args.named.isEmpty()) {
         return Err((0, _syntax.generateSyntaxError)("{{#let}} cannot receive named parameters, received " + args.named.entries.map(e => e.name.chars).join(', '), args.named.loc));
       }
       if (args.positional.size === 0) {
         return Err((0, _syntax.generateSyntaxError)("{{#let}} requires at least one value as its first positional parameter, did not receive any parameters", args.positional.loc));
       }
-      if (node$$1.blocks.get('else')) {
+      if (node.blocks.get('else')) {
         return Err((0, _syntax.generateSyntaxError)("{{#let}} cannot receive an {{else}} block", args.positional.loc));
       }
       return Ok({
@@ -3709,45 +3698,45 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     },
     translate(_ref43, _ref44) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref43;
       var {
         positional
       } = _ref44;
-      var block = node$$1.blocks.get('default');
+      var block = node.blocks.get('default');
       var positionalResult = VISIT_EXPRS.Positional(positional, state);
       var blockResult = VISIT_STMTS.NamedBlock(block, state);
       return Result.all(positionalResult, blockResult).mapOk(_ref45 => {
         var [positional, block] = _ref45;
         return new Let({
-          loc: node$$1.loc,
+          loc: node.loc,
           positional,
           block
         });
       });
     }
   }).kw('-with-dynamic-vars', {
-    assert(node$$1) {
+    assert(node) {
       return Ok({
-        named: node$$1.args.named
+        named: node.args.named
       });
     },
     translate(_ref46, _ref47) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref46;
       var {
         named
       } = _ref47;
-      var block = node$$1.blocks.get('default');
+      var block = node.blocks.get('default');
       var namedResult = VISIT_EXPRS.NamedArguments(named, state);
       var blockResult = VISIT_STMTS.NamedBlock(block, state);
       return Result.all(namedResult, blockResult).mapOk(_ref48 => {
         var [named, block] = _ref48;
         return new WithDynamicVars({
-          loc: node$$1.loc,
+          loc: node.loc,
           named,
           block
         });
@@ -3759,7 +3748,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
     translate(_ref49, _ref50) {
       var {
-        node: node$$1,
+        node,
         state
       } = _ref49;
       var {
@@ -3768,11 +3757,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       } = _ref50;
       var definitionResult = VISIT_EXPRS.visit(definition, state);
       var argsResult = VISIT_EXPRS.Args(args, state);
-      var blocksResult = VISIT_STMTS.NamedBlocks(node$$1.blocks, state);
+      var blocksResult = VISIT_STMTS.NamedBlocks(node.blocks, state);
       return Result.all(definitionResult, argsResult, blocksResult).mapOk(_ref51 => {
         var [definition, args, blocks] = _ref51;
         return new InvokeComponent({
-          loc: node$$1.loc,
+          loc: node.loc,
           definition,
           args,
           blocks
@@ -4068,35 +4057,35 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     visitList(nodes, state) {
       return new ResultArray(nodes.map(e => VISIT_STMTS.visit(e, state))).toOptionalList().mapOk(list => list.filter(s => s !== null));
     }
-    visit(node$$1, state) {
-      switch (node$$1.type) {
+    visit(node, state) {
+      switch (node.type) {
         case 'GlimmerComment':
           return Ok(null);
         case 'AppendContent':
-          return this.AppendContent(node$$1, state);
+          return this.AppendContent(node, state);
         case 'HtmlText':
-          return Ok(this.TextNode(node$$1));
+          return Ok(this.TextNode(node));
         case 'HtmlComment':
-          return Ok(this.HtmlComment(node$$1));
+          return Ok(this.HtmlComment(node));
         case 'InvokeBlock':
-          return this.InvokeBlock(node$$1, state);
+          return this.InvokeBlock(node, state);
         case 'InvokeComponent':
-          return this.Component(node$$1, state);
+          return this.Component(node, state);
         case 'SimpleElement':
-          return this.SimpleElement(node$$1, state);
+          return this.SimpleElement(node, state);
       }
     }
-    InvokeBlock(node$$1, state) {
-      var translated = BLOCK_KEYWORDS.translate(node$$1, state);
+    InvokeBlock(node, state) {
+      var translated = BLOCK_KEYWORDS.translate(node, state);
       if (translated !== null) {
         return translated;
       }
-      var head = VISIT_EXPRS.visit(node$$1.callee, state);
-      var args = VISIT_EXPRS.Args(node$$1.args, state);
+      var head = VISIT_EXPRS.visit(node.callee, state);
+      var args = VISIT_EXPRS.Args(node.args, state);
       return Result.all(head, args).andThen(_ref59 => {
         var [head, args] = _ref59;
-        return this.NamedBlocks(node$$1.blocks, state).mapOk(blocks => new InvokeBlock({
-          loc: node$$1.loc,
+        return this.NamedBlocks(node.blocks, state).mapOk(blocks => new InvokeBlock({
+          loc: node.loc,
           head,
           args,
           blocks
@@ -4231,7 +4220,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
    * ```
    */
 
-  function normalize$1(source, root, isStrict) {
+  function normalize(source, root, isStrict) {
     // create a new context for the normalization pass
     var state = new NormalizationState(root.table, isStrict);
     var body = VISIT_STMTS.visitList(root.body, state);
@@ -4619,15 +4608,15 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       var list = pairs.toArray();
       if ((0, _util.isPresent)(list)) {
         var names = [];
-        var values$$1 = [];
+        var _values = [];
         for (var pair of list) {
           var [name, value] = EXPR.NamedArgument(pair);
           names.push(name);
-          values$$1.push(value);
+          _values.push(value);
         }
         (0, _util.assertPresent)(names);
-        (0, _util.assertPresent)(values$$1);
-        return [names, values$$1];
+        (0, _util.assertPresent)(_values);
+        return [names, _values];
       } else {
         return null;
       }
@@ -5013,7 +5002,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     var _a, _b;
     var source = new _syntax.Source(string, (_a = options.meta) === null || _a === void 0 ? void 0 : _a.moduleName);
     var [ast, locals] = (0, _syntax.normalize)(source, options);
-    var block = normalize$1(source, ast, (_b = options.strictMode) !== null && _b !== void 0 ? _b : false).mapOk(pass2In => {
+    var block = normalize(source, ast, (_b = options.strictMode) !== null && _b !== void 0 ? _b : false).mapOk(pass2In => {
       return visit(pass2In);
     });
     if (block.isOk) {
@@ -5429,9 +5418,9 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
       blockParams
     };
   }
-  function entries(dict$$1, callback) {
-    Object.keys(dict$$1).forEach(key => {
-      var value = dict$$1[key];
+  function entries(dict, callback) {
+    Object.keys(dict).forEach(key => {
+      var value = dict[key];
       callback(key, value);
     });
   }
@@ -6020,8 +6009,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
 
     if (Array.isArray(block)) {
       block.forEach(s => out.push(...buildStatement(s, symbols)));
-    } else if (block === null) {// do nothing
-    } else {
+    } else if (block === null) ;else {
       throw (0, _util.assertNever)(block);
     }
     out.push([13
@@ -6038,7 +6026,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   function buildElementParams(attrs, symbols) {
     var params = [];
     var keys = [];
-    var values$$1 = [];
+    var values = [];
     Object.keys(attrs).forEach(key => {
       var value = attrs[key];
       if (value === "Splat"
@@ -6047,7 +6035,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
         /* AttrSplat */, symbols.block('&attrs')]);
       } else if (key[0] === '@') {
         keys.push(key);
-        values$$1.push(buildExpression(value, 'Strict', symbols));
+        values.push(buildExpression(value, 'Strict', symbols));
       } else {
         params.push(...buildAttributeValue(key, value,
         // TODO: extract namespace from key
@@ -6056,7 +6044,7 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
     });
     return {
       params,
-      args: (0, _util.isPresent)(keys) && (0, _util.isPresent)(values$$1) ? [keys, values$$1] : null
+      args: (0, _util.isPresent)(keys) && (0, _util.isPresent)(values) ? [keys, values] : null
     };
   }
   function extractNamespace(name) {
@@ -6317,17 +6305,17 @@ define("@glimmer/compiler", ["exports", "@glimmer/syntax", "@glimmer/util"], fun
   }
   function buildBlocks(blocks, blockParams, parent) {
     var keys = [];
-    var values$$1 = [];
+    var values = [];
     Object.keys(blocks).forEach(name => {
       keys.push(name);
       if (name === 'default') {
         var symbols = parent.child(blockParams || []);
-        values$$1.push(buildBlock(blocks[name], symbols, symbols.paramSymbols));
+        values.push(buildBlock(blocks[name], symbols, symbols.paramSymbols));
       } else {
-        values$$1.push(buildBlock(blocks[name], parent, []));
+        values.push(buildBlock(blocks[name], parent, []));
       }
     });
-    return [keys, values$$1];
+    return [keys, values];
   }
   function buildBlock(block, symbols, locals) {
     if (locals === void 0) {
@@ -6348,7 +6336,7 @@ define("@glimmer/env", ["exports"], function (_exports) {
   var CI = false;
   _exports.CI = CI;
 });
-define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer", "@handlebars/parser"], function (_exports, _util, _simpleHtmlTokenizer, _parser) {
+define("@glimmer/syntax", ["exports", "@glimmer/util", "@handlebars/parser", "simple-html-tokenizer"], function (_exports, _util, _parser, _simpleHtmlTokenizer) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -7853,7 +7841,9 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       return buildLiteral(type, value, loc);
     };
   }
-  var api = /*#__PURE__*/Object.freeze({});
+  var api = /*#__PURE__*/Object.freeze({
+    __proto__: null
+  });
 
   /**
    * A free variable is resolved according to a resolution rule:
@@ -7869,7 +7859,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * 1. in a strict mode template
    * 2. in an unambiguous invocation with dot paths
    */
-  _exports.AST = _exports.ASTv1 = api;
+  _exports.ASTv1 = _exports.AST = api;
   class StrictResolution {
     constructor() {
       this.isAngleBracket = false;
@@ -8398,14 +8388,14 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * Returns true if an input {@see ExpressionNode} is a literal.
    */
 
-  function isLiteral(node$$1, kind) {
-    if (node$$1.type === 'Literal') {
+  function isLiteral(node, kind) {
+    if (node.type === 'Literal') {
       if (kind === undefined) {
         return true;
       } else if (kind === 'null') {
-        return node$$1.value === null;
+        return node.value === null;
       } else {
-        return typeof node$$1.value === kind;
+        return typeof node.value === kind;
       }
     } else {
       return false;
@@ -8525,6 +8515,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
   }
   var api$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
     StrictResolution: StrictResolution,
     STRICT_RESOLUTION: STRICT_RESOLUTION,
     LooseModeResolution: LooseModeResolution,
@@ -9378,7 +9369,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       }
     }
   }
-  _exports.Path = _exports.Walker = Walker;
+  _exports.Walker = _exports.Path = Walker;
   var visitors = {
     Program(walker, node, callback) {
       for (var i = 0; i < node.body.length; i++) {
@@ -10781,9 +10772,9 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       return slot === -1 ? this.parent.get(name) : [this.slots[slot], false];
     }
     getLocalsMap() {
-      var dict$$1 = this.parent.getLocalsMap();
-      this.symbols.forEach(symbol => dict$$1[symbol] = this.get(symbol)[0]);
-      return dict$$1;
+      var dict = this.parent.getLocalsMap();
+      this.symbols.forEach(symbol => dict[symbol] = this.get(symbol)[0]);
+      return dict;
     }
     getEvalInfo() {
       var locals = this.getLocalsMap();
@@ -10818,56 +10809,56 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
   };
   class Builder {
     // TEMPLATE //
-    template(symbols, body, loc$$1) {
+    template(symbols, body, loc) {
       return new Template({
         table: symbols,
         body,
-        loc: loc$$1
+        loc
       });
     } // INTERNAL (these nodes cannot be reached when doing general-purpose visiting) //
 
-    block(symbols, body, loc$$1) {
+    block(symbols, body, loc) {
       return new Block({
         scope: symbols,
         body,
-        loc: loc$$1
+        loc
       });
     }
-    namedBlock(name, block, loc$$1) {
+    namedBlock(name, block, loc) {
       return new NamedBlock({
         name,
         block,
         attrs: [],
         componentArgs: [],
         modifiers: [],
-        loc: loc$$1
+        loc
       });
     }
-    simpleNamedBlock(name, block, loc$$1) {
+    simpleNamedBlock(name, block, loc) {
       return new BuildElement({
         selfClosing: false,
         attrs: [],
         componentArgs: [],
         modifiers: [],
         comments: []
-      }).named(name, block, loc$$1);
+      }).named(name, block, loc);
     }
-    slice(chars, loc$$1) {
+    slice(chars, loc) {
       return new SourceSlice({
-        loc: loc$$1,
+        loc,
         chars
       });
     }
-    args(positional, named, loc$$1) {
+    args(positional, named, loc) {
       return new Args({
-        loc: loc$$1,
+        loc,
         positional,
         named
       });
     }
-    positional(exprs, loc$$1) {
+    positional(exprs, loc) {
       return new PositionalArguments({
-        loc: loc$$1,
+        loc,
         exprs
       });
     }
@@ -10877,32 +10868,32 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         value
       });
     }
-    named(entries, loc$$1) {
+    named(entries, loc) {
       return new NamedArguments({
-        loc: loc$$1,
+        loc,
         entries
       });
     }
-    attr(_ref28, loc$$1) {
+    attr(_ref28, loc) {
       var {
         name,
         value,
         trusting
       } = _ref28;
       return new HtmlAttr({
-        loc: loc$$1,
+        loc,
         name,
         value,
         trusting
       });
     }
-    splatAttr(symbol, loc$$1) {
+    splatAttr(symbol, loc) {
       return new SplatAttr({
         symbol,
-        loc: loc$$1
+        loc
       });
     }
-    arg(_ref29, loc$$1) {
+    arg(_ref29, loc) {
       var {
         name,
         value,
@@ -10912,27 +10903,27 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         name,
         value,
         trusting,
-        loc: loc$$1
+        loc
       });
     } // EXPRESSIONS //
 
-    path(head, tail, loc$$1) {
+    path(head, tail, loc) {
       return new PathExpression({
-        loc: loc$$1,
+        loc,
         ref: head,
         tail
       });
     }
-    self(loc$$1) {
+    self(loc) {
       return new ThisReference({
-        loc: loc$$1
+        loc
       });
     }
-    at(name, symbol, loc$$1) {
+    at(name, symbol, loc) {
       return new ArgReference({
-        loc: loc$$1,
+        loc,
         name: new SourceSlice({
-          loc: loc$$1,
+          loc,
           chars: name
         }),
         symbol
@@ -10943,52 +10934,52 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         name,
         context,
         symbol,
-        loc: loc$$1
+        loc
       } = _ref30;
       return new FreeVarReference({
         name,
         resolution: context,
         symbol,
-        loc: loc$$1
+        loc
       });
     }
-    localVar(name, symbol, isTemplateLocal, loc$$1) {
+    localVar(name, symbol, isTemplateLocal, loc) {
       return new LocalVarReference({
-        loc: loc$$1,
+        loc,
         name,
         isTemplateLocal,
         symbol
       });
     }
-    sexp(parts, loc$$1) {
+    sexp(parts, loc) {
       return new CallExpression({
-        loc: loc$$1,
+        loc,
         callee: parts.callee,
         args: parts.args
       });
     }
-    deprecatedCall(arg, callee, loc$$1) {
+    deprecatedCall(arg, callee, loc) {
       return new DeprecatedCallExpression({
-        loc: loc$$1,
+        loc,
         arg,
         callee
       });
     }
-    interpolate(parts, loc$$1) {
+    interpolate(parts, loc) {
       (0, _util.assertPresent)(parts);
       return new InterpolateExpression({
-        loc: loc$$1,
+        loc,
         parts
       });
     }
-    literal(value, loc$$1) {
+    literal(value, loc) {
       return new LiteralExpression({
-        loc: loc$$1,
+        loc,
         value
       });
     } // STATEMENTS //
 
-    append(_ref31, loc$$1) {
+    append(_ref31, loc) {
       var {
         table,
         trusting,
@@ -10998,27 +10989,27 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         table,
         trusting,
         value,
-        loc: loc$$1
+        loc
       });
     }
-    modifier(_ref32, loc$$1) {
+    modifier(_ref32, loc) {
       var {
         callee,
         args
       } = _ref32;
       return new ElementModifier({
-        loc: loc$$1,
+        loc,
         callee,
         args
       });
     }
-    namedBlocks(blocks, loc$$1) {
+    namedBlocks(blocks, loc) {
       return new NamedBlocks({
-        loc: loc$$1,
+        loc,
         blocks
       });
     }
-    blockStatement(_a, loc$$1) {
+    blockStatement(_a, loc) {
       var {
           symbols,
           program,
@@ -11032,7 +11023,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         blocks.push(this.namedBlock(SourceSlice.synthetic('else'), inverse, inverse.loc));
       }
       return new InvokeBlock({
-        loc: loc$$1,
+        loc,
         blocks: this.namedBlocks(blocks, blocksLoc),
         callee: call.callee,
         args: call.args
@@ -11047,80 +11038,80 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       this.base = base;
       this.builder = new Builder();
     }
-    simple(tag, body, loc$$1) {
+    simple(tag, body, loc) {
       return new SimpleElement((0, _util.assign)({
         tag,
         body,
         componentArgs: [],
-        loc: loc$$1
+        loc
       }, this.base));
     }
-    named(name, block, loc$$1) {
+    named(name, block, loc) {
       return new NamedBlock((0, _util.assign)({
         name,
         block,
         componentArgs: [],
-        loc: loc$$1
+        loc
       }, this.base));
     }
-    selfClosingComponent(callee, loc$$1) {
+    selfClosingComponent(callee, loc) {
       return new InvokeComponent((0, _util.assign)({
-        loc: loc$$1,
+        loc,
         callee,
         // point the empty named blocks at the `/` self-closing tag
         blocks: new NamedBlocks({
           blocks: [],
-          loc: loc$$1.sliceEndChars({
+          loc: loc.sliceEndChars({
             skipEnd: 1,
             chars: 1
           })
         })
       }, this.base));
     }
-    componentWithDefaultBlock(callee, children, symbols, loc$$1) {
-      var block = this.builder.block(symbols, children, loc$$1);
-      var namedBlock = this.builder.namedBlock(SourceSlice.synthetic('default'), block, loc$$1); // BUILDER.simpleNamedBlock('default', children, symbols, loc);
+    componentWithDefaultBlock(callee, children, symbols, loc) {
+      var block = this.builder.block(symbols, children, loc);
+      var namedBlock = this.builder.namedBlock(SourceSlice.synthetic('default'), block, loc); // BUILDER.simpleNamedBlock('default', children, symbols, loc);
 
       return new InvokeComponent((0, _util.assign)({
-        loc: loc$$1,
+        loc,
         callee,
         blocks: this.builder.namedBlocks([namedBlock], namedBlock.loc)
       }, this.base));
     }
-    componentWithNamedBlocks(callee, blocks, loc$$1) {
+    componentWithNamedBlocks(callee, blocks, loc) {
       return new InvokeComponent((0, _util.assign)({
-        loc: loc$$1,
+        loc,
         callee,
         blocks: this.builder.namedBlocks(blocks, SpanList.range(blocks))
       }, this.base));
     }
   }
-  function SexpSyntaxContext(node$$1) {
-    if (isSimpleCallee(node$$1)) {
+  function SexpSyntaxContext(node) {
+    if (isSimpleCallee(node)) {
       return LooseModeResolution.namespaced("Helper"
       /* Helper */);
     } else {
       return null;
     }
   }
-  function ModifierSyntaxContext(node$$1) {
-    if (isSimpleCallee(node$$1)) {
+  function ModifierSyntaxContext(node) {
+    if (isSimpleCallee(node)) {
       return LooseModeResolution.namespaced("Modifier"
       /* Modifier */);
     } else {
       return null;
     }
   }
-  function BlockSyntaxContext(node$$1) {
-    if (isSimpleCallee(node$$1)) {
+  function BlockSyntaxContext(node) {
+    if (isSimpleCallee(node)) {
       return LooseModeResolution.namespaced("Component"
       /* Component */);
     } else {
       return LooseModeResolution.fallback();
     }
   }
-  function ComponentSyntaxContext(node$$1) {
-    if (isSimplePath(node$$1)) {
+  function ComponentSyntaxContext(node) {
+    if (isSimplePath(node)) {
       return LooseModeResolution.namespaced("Component"
       /* Component */, true);
     } else {
@@ -11132,9 +11123,9 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * curlies). In strict mode, this also corresponds to arg curlies.
    */
 
-  function AttrValueSyntaxContext(node$$1) {
-    var isSimple = isSimpleCallee(node$$1);
-    var isInvoke = isInvokeNode(node$$1);
+  function AttrValueSyntaxContext(node) {
+    var isSimple = isSimpleCallee(node);
+    var isInvoke = isInvokeNode(node);
     if (isSimple) {
       return isInvoke ? LooseModeResolution.namespaced("Helper"
       /* Helper */) : LooseModeResolution.attr();
@@ -11147,10 +11138,10 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * curlies). In strict mode, this also corresponds to arg curlies.
    */
 
-  function AppendSyntaxContext(node$$1) {
-    var isSimple = isSimpleCallee(node$$1);
-    var isInvoke = isInvokeNode(node$$1);
-    var trusting = node$$1.trusting;
+  function AppendSyntaxContext(node) {
+    var isSimple = isSimpleCallee(node);
+    var isInvoke = isInvokeNode(node);
+    var trusting = node.trusting;
     if (isSimple) {
       return trusting ? LooseModeResolution.trustingAppend({
         invoke: isInvoke
@@ -11188,13 +11179,13 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * ```
    */
 
-  function isSimpleCallee(node$$1) {
-    var path = node$$1.path;
+  function isSimpleCallee(node) {
+    var path = node.path;
     return isSimplePath(path);
   }
-  function isSimplePath(node$$1) {
-    if (node$$1.type === 'PathExpression' && node$$1.head.type === 'VarHead') {
-      return node$$1.tail.length === 0;
+  function isSimplePath(node) {
+    if (node.type === 'PathExpression' && node.head.type === 'VarHead') {
+      return node.tail.length === 0;
     } else {
       return false;
     }
@@ -11203,8 +11194,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
    * The call expression has at least one argument.
    */
 
-  function isInvokeNode(node$$1) {
-    return node$$1.params.length > 0 || node$$1.hash.pairs.length > 0;
+  function isInvokeNode(node) {
+    return node.params.length > 0 || node.hash.pairs.length > 0;
   }
   function normalize(source, options) {
     if (options === void 0) {
@@ -11221,7 +11212,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     options.customizeComponentName) !== null && _a !== void 0 ? _a : name => name);
     var block = new BlockContext(source, normalizeOptions, top);
     var normalizer = new StatementNormalizer(block);
-    var astV2 = new TemplateChildren(block.loc(ast.loc), ast.body.map(b$$1 => normalizer.normalize(b$$1)), block).assertTemplate(top);
+    var astV2 = new TemplateChildren(block.loc(ast.loc), ast.body.map(b => normalizer.normalize(b)), block).assertTemplate(top);
     var locals = top.getUsedTemplateLocals();
     return [astV2, locals];
   }
@@ -11247,22 +11238,22 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     get strict() {
       return this.options.strictMode || false;
     }
-    loc(loc$$1) {
-      return this.source.spanFor(loc$$1);
+    loc(loc) {
+      return this.source.spanFor(loc);
     }
-    resolutionFor(node$$1, resolution) {
+    resolutionFor(node, resolution) {
       if (this.strict) {
         return {
           resolution: STRICT_RESOLUTION
         };
       }
-      if (this.isFreeVar(node$$1)) {
-        var r = resolution(node$$1);
+      if (this.isFreeVar(node)) {
+        var r = resolution(node);
         if (r === null) {
           return {
             resolution: 'error',
-            path: printPath(node$$1),
-            head: printHead(node$$1)
+            path: printPath(node),
+            head: printHead(node)
           };
         }
         return {
@@ -11435,55 +11426,55 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     constructor(block) {
       this.block = block;
     }
-    normalize(node$$1) {
-      switch (node$$1.type) {
+    normalize(node) {
+      switch (node.type) {
         case 'PartialStatement':
           throw new Error("Handlebars partial syntax ({{> ...}}) is not allowed in Glimmer");
         case 'BlockStatement':
-          return this.BlockStatement(node$$1);
+          return this.BlockStatement(node);
         case 'ElementNode':
-          return new ElementNormalizer(this.block).ElementNode(node$$1);
+          return new ElementNormalizer(this.block).ElementNode(node);
         case 'MustacheStatement':
-          return this.MustacheStatement(node$$1);
+          return this.MustacheStatement(node);
         // These are the same in ASTv2
 
         case 'MustacheCommentStatement':
-          return this.MustacheCommentStatement(node$$1);
+          return this.MustacheCommentStatement(node);
         case 'CommentStatement':
           {
-            var loc$$1 = this.block.loc(node$$1.loc);
+            var _loc3 = this.block.loc(node.loc);
             return new HtmlComment({
-              loc: loc$$1,
-              text: loc$$1.slice({
+              loc: _loc3,
+              text: _loc3.slice({
                 skipStart: 4,
                 skipEnd: 3
-              }).toSlice(node$$1.value)
+              }).toSlice(node.value)
             });
           }
         case 'TextNode':
           return new HtmlText({
-            loc: this.block.loc(node$$1.loc),
-            chars: node$$1.chars
+            loc: this.block.loc(node.loc),
+            chars: node.chars
           });
       }
     }
-    MustacheCommentStatement(node$$1) {
-      var loc$$1 = this.block.loc(node$$1.loc);
+    MustacheCommentStatement(node) {
+      var loc = this.block.loc(node.loc);
       var textLoc;
-      if (loc$$1.asString().slice(0, 5) === '{{!--') {
-        textLoc = loc$$1.slice({
+      if (loc.asString().slice(0, 5) === '{{!--') {
+        textLoc = loc.slice({
           skipStart: 5,
           skipEnd: 4
         });
       } else {
-        textLoc = loc$$1.slice({
+        textLoc = loc.slice({
           skipStart: 3,
           skipEnd: 2
         });
       }
       return new GlimmerComment({
-        loc: loc$$1,
-        text: textLoc.toSlice(node$$1.value)
+        loc,
+        text: textLoc.toSlice(node.value)
       });
     }
     /**
@@ -11494,19 +11485,19 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       var {
         escaped
       } = mustache;
-      var loc$$1 = this.block.loc(mustache.loc); // Normalize the call parts in AppendSyntaxContext
+      var loc = this.block.loc(mustache.loc); // Normalize the call parts in AppendSyntaxContext
 
       var callParts = this.expr.callParts({
         path: mustache.path,
         params: mustache.params,
         hash: mustache.hash
       }, AppendSyntaxContext(mustache));
-      var value = callParts.args.isEmpty() ? callParts.callee : this.block.builder.sexp(callParts, loc$$1);
+      var value = callParts.args.isEmpty() ? callParts.callee : this.block.builder.sexp(callParts, loc);
       return this.block.builder.append({
         table: this.block.table,
         trusting: !escaped,
         value
-      }, loc$$1);
+      }, loc);
     }
     /**
      * Normalizes a ASTv1.BlockStatement to an ASTv2.BlockStatement
@@ -11517,27 +11508,27 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         program,
         inverse
       } = block;
-      var loc$$1 = this.block.loc(block.loc);
+      var loc = this.block.loc(block.loc);
       var resolution = this.block.resolutionFor(block, BlockSyntaxContext);
       if (resolution.resolution === 'error') {
-        throw generateSyntaxError("You attempted to invoke a path (`{{#" + resolution.path + "}}`) but " + resolution.head + " was not in scope", loc$$1);
+        throw generateSyntaxError("You attempted to invoke a path (`{{#" + resolution.path + "}}`) but " + resolution.head + " was not in scope", loc);
       }
       var callParts = this.expr.callParts(block, resolution.resolution);
       return this.block.builder.blockStatement((0, _util.assign)({
         symbols: this.block.table,
         program: this.Block(program),
         inverse: inverse ? this.Block(inverse) : null
-      }, callParts), loc$$1);
+      }, callParts), loc);
     }
     Block(_ref33) {
       var {
         body,
-        loc: loc$$1,
+        loc,
         blockParams
       } = _ref33;
       var child = this.block.child(blockParams);
       var normalizer = new StatementNormalizer(child);
-      return new BlockChildren(this.block.loc(loc$$1), body.map(b$$1 => normalizer.normalize(b$$1)), this.block).assertBlock(child.table);
+      return new BlockChildren(this.block.loc(loc), body.map(b => normalizer.normalize(b)), this.block).assertBlock(child.table);
     }
     get expr() {
       return new ExpressionNormalizer(this.block);
@@ -11568,7 +11559,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         selfClosing,
         comments
       } = element;
-      var loc$$1 = this.ctx.loc(element.loc);
+      var loc = this.ctx.loc(element.loc);
       var [tagHead, ...rest] = tag.split('.'); // the head, attributes and modifiers are in the current scope
 
       var path = this.classifyTag(tagHead, rest, element.loc);
@@ -11586,7 +11577,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         modifiers,
         comments: comments.map(c => new StatementNormalizer(this.ctx).MustacheCommentStatement(c))
       });
-      var children = new ElementChildren(el, loc$$1, childNodes, this.ctx);
+      var children = new ElementChildren(el, loc, childNodes, this.ctx);
       var offsets = this.ctx.loc(element.loc);
       var tagOffsets = offsets.sliceStartChars({
         chars: tag.length,
@@ -11602,10 +11593,10 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         }
       }
       if (element.selfClosing) {
-        return el.selfClosingComponent(path, loc$$1);
+        return el.selfClosingComponent(path, loc);
       } else {
         var blocks = children.assertComponent(tag, child.table, element.blockParams.length > 0);
-        return el.componentWithNamedBlocks(path, blocks, loc$$1);
+        return el.componentWithNamedBlocks(path, blocks, loc);
       }
     }
     modifier(m) {
@@ -11755,12 +11746,12 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
      * 6. Otherwise, return `'ElementHead'`
      */
 
-    classifyTag(variable, tail, loc$$1) {
+    classifyTag(variable, tail, loc) {
       var uppercase = isUpperCase(variable);
       var inScope = variable[0] === '@' || variable === 'this' || this.ctx.hasBinding(variable);
       if (this.ctx.strict && !inScope) {
         if (uppercase) {
-          throw generateSyntaxError("Attempted to invoke a component that was not in scope in a strict mode template, `<" + variable + ">`. If you wanted to create an element with that name, convert it to lowercase - `<" + variable.toLowerCase() + ">`", loc$$1);
+          throw generateSyntaxError("Attempted to invoke a component that was not in scope in a strict mode template, `<" + variable + ">`. If you wanted to create an element with that name, convert it to lowercase - `<" + variable.toLowerCase() + ">`", loc);
         } // In strict mode, values are always elements unless they are in scope
 
         return 'ElementHead';
@@ -11769,7 +11760,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       // expression normalizer.
 
       var isComponent = inScope || uppercase;
-      var variableLoc = loc$$1.sliceStartChars({
+      var variableLoc = loc.sliceStartChars({
         skipStart: 1,
         chars: variable.length
       });
@@ -11784,14 +11775,14 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         });
         var resolution = this.ctx.resolutionFor(path, ComponentSyntaxContext);
         if (resolution.resolution === 'error') {
-          throw generateSyntaxError("You attempted to invoke a path (`<" + resolution.path + ">`) but " + resolution.head + " was not in scope", loc$$1);
+          throw generateSyntaxError("You attempted to invoke a path (`<" + resolution.path + ">`) but " + resolution.head + " was not in scope", loc);
         }
         return new ExpressionNormalizer(this.ctx).normalize(path, resolution.resolution);
       } // If the tag name wasn't a valid component but contained a `.`, it's
       // a syntax error.
 
       if (tail.length > 0) {
-        throw generateSyntaxError("You used " + variable + "." + tail.join('.') + " as a tag name, but " + variable + " is not in scope", loc$$1);
+        throw generateSyntaxError("You used " + variable + "." + tail.join('.') + " as a tag name, but " + variable + " is not in scope", loc);
       }
       return 'ElementHead';
     }
@@ -11800,8 +11791,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
   }
   class Children {
-    constructor(loc$$1, children, block) {
-      this.loc = loc$$1;
+    constructor(loc, children, block) {
+      this.loc = loc;
       this.children = children;
       this.block = block;
       this.namedBlocks = children.filter(c => c instanceof NamedBlock);
@@ -11839,8 +11830,8 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
     }
   }
   class ElementChildren extends Children {
-    constructor(el, loc$$1, children, block) {
-      super(loc$$1, children, block);
+    constructor(el, loc, children, block) {
+      super(loc, children, block);
       this.el = el;
     }
     assertNamedBlock(name, table) {
@@ -11864,7 +11855,7 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
         throw generateSyntaxError("Unexpected block params in <" + name + ">: simple elements cannot have block params", this.loc);
       }
       if ((0, _util.isPresent)(this.namedBlocks)) {
-        var names = this.namedBlocks.map(b$$1 => b$$1.name);
+        var names = this.namedBlocks.map(b => b.name);
         if (names.length === 1) {
           throw generateSyntaxError("Unexpected named block <:foo> inside <" + name.chars + "> HTML element", this.loc);
         } else {
@@ -11899,30 +11890,30 @@ define("@glimmer/syntax", ["exports", "@glimmer/util", "simple-html-tokenizer",
       }
     }
   }
-  function printPath(node$$1) {
-    if (node$$1.type !== 'PathExpression' && node$$1.path.type === 'PathExpression') {
-      return printPath(node$$1.path);
+  function printPath(node) {
+    if (node.type !== 'PathExpression' && node.path.type === 'PathExpression') {
+      return printPath(node.path);
     } else {
       return new Printer({
         entityEncoding: 'raw'
-      }).print(node$$1);
+      }).print(node);
     }
   }
-  function printHead(node$$1) {
-    if (node$$1.type === 'PathExpression') {
-      switch (node$$1.head.type) {
+  function printHead(node) {
+    if (node.type === 'PathExpression') {
+      switch (node.head.type) {
         case 'AtHead':
         case 'VarHead':
-          return node$$1.head.name;
+          return node.head.name;
         case 'ThisHead':
           return 'this';
       }
-    } else if (node$$1.path.type === 'PathExpression') {
-      return printHead(node$$1.path);
+    } else if (node.path.type === 'PathExpression') {
+      return printHead(node.path);
     } else {
       return new Printer({
         entityEncoding: 'raw'
-      }).print(node$$1);
+      }).print(node);
     }
   }
   function isKeyword(word) {
@@ -12073,7 +12064,7 @@ define("@glimmer/util", ["exports"], function (_exports) {
     value: true
   });
   _exports._WeakSet = _exports.Stack = _exports.SERIALIZATION_FIRST_NODE_STRING = _exports.LOGGER = _exports.LOCAL_LOGGER = _exports.HAS_NATIVE_SYMBOL = _exports.HAS_NATIVE_PROXY = _exports.EMPTY_STRING_ARRAY = _exports.EMPTY_NUMBER_ARRAY = _exports.EMPTY_ARRAY = void 0;
-  _exports.assert = debugAssert$$1;
+  _exports.assert = debugAssert;
   _exports.assertNever = assertNever;
   _exports.assertPresent = assertPresent;
   _exports.beginTestSteps = _exports.assign = void 0;
@@ -12088,7 +12079,7 @@ define("@glimmer/util", ["exports"], function (_exports) {
   _exports.decodeImmediate = decodeImmediate;
   _exports.decodeNegative = decodeNegative;
   _exports.decodePositive = decodePositive;
-  _exports.deprecate = deprecate$$1;
+  _exports.deprecate = deprecate;
   _exports.dict = dict;
   _exports.emptyArray = emptyArray;
   _exports.encodeHandle = encodeHandle;
@@ -12145,7 +12136,7 @@ define("@glimmer/util", ["exports"], function (_exports) {
 
   // import Logger from './logger';
 
-  function debugAssert$$1(test, msg) {
+  function debugAssert(test, msg) {
     // if (!alreadyWarned) {
     //   alreadyWarned = true;
     //   Logger.warn("Don't leave debug assertions on in public builds");
@@ -12154,7 +12145,7 @@ define("@glimmer/util", ["exports"], function (_exports) {
       throw new Error(msg || 'assertion failure');
     }
   }
-  function deprecate$$1(desc) {
+  function deprecate(desc) {
     LOCAL_LOGGER.warn("DEPRECATION: " + desc);
   }
   function dict() {
@@ -13287,7 +13278,6 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
         switch (yystate) {
           case 1:
             return $$[$0 - 1];
-            break;
           case 2:
             this.$ = yy.prepareProgram($$[$0]);
             break;
@@ -14105,7 +14095,7 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
         } else {
           this.parseError = Object.getPrototypeOf(this).parseError;
         }
-        _token_stack: var lex = function () {
+        var lex = function () {
           var token;
           token = lexer.lex() || EOF;
           if (typeof token !== 'number') {
@@ -14114,7 +14104,6 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
           return token;
         };
         var symbol,
-          preErrorSymbol,
           state,
           action,
           r,
@@ -14164,14 +14153,11 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
               lstack.push(lexer.yylloc);
               stack.push(action[1]);
               symbol = null;
-              if (!preErrorSymbol) {
+              {
                 yyleng = lexer.yyleng;
                 yytext = lexer.yytext;
                 yylineno = lexer.yylineno;
                 yyloc = lexer.yylloc;
-              } else {
-                symbol = preErrorSymbol;
-                preErrorSymbol = null;
               }
               break;
             case 2:
@@ -14514,15 +14500,12 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
               break;
             case 1:
               return 15;
-              break;
             case 2:
               this.popState();
               return 15;
-              break;
             case 3:
               this.begin('raw');
               return 15;
-              break;
             case 4:
               this.popState();
               // Should be using `this.topState()` below, but it currently
@@ -14534,60 +14517,43 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
                 strip(5, 9);
                 return 18;
               }
-              break;
             case 5:
               return 15;
-              break;
             case 6:
               this.popState();
               return 14;
-              break;
             case 7:
               return 64;
-              break;
             case 8:
               return 67;
-              break;
             case 9:
               return 19;
-              break;
             case 10:
               this.popState();
               this.begin('raw');
               return 23;
-              break;
             case 11:
               return 56;
-              break;
             case 12:
               return 60;
-              break;
             case 13:
               return 29;
-              break;
             case 14:
               return 47;
-              break;
             case 15:
               this.popState();
               return 44;
-              break;
             case 16:
               this.popState();
               return 44;
-              break;
             case 17:
               return 34;
-              break;
             case 18:
               return 39;
-              break;
             case 19:
               return 52;
-              break;
             case 20:
               return 48;
-              break;
             case 21:
               this.unput(yy_.yytext);
               this.popState();
@@ -14596,78 +14562,56 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
             case 22:
               this.popState();
               return 14;
-              break;
             case 23:
               return 48;
-              break;
             case 24:
               return 72;
-              break;
             case 25:
               return 71;
-              break;
             case 26:
               return 71;
-              break;
             case 27:
               return 86;
-              break;
             case 28:
               // ignore whitespace
               break;
             case 29:
               this.popState();
               return 55;
-              break;
             case 30:
               this.popState();
               return 33;
-              break;
             case 31:
               yy_.yytext = strip(1, 2).replace(/\\"/g, '"');
               return 79;
-              break;
             case 32:
               yy_.yytext = strip(1, 2).replace(/\\'/g, "'");
               return 79;
-              break;
             case 33:
               return 84;
-              break;
             case 34:
               return 81;
-              break;
             case 35:
               return 81;
-              break;
             case 36:
               return 82;
-              break;
             case 37:
               return 83;
-              break;
             case 38:
               return 80;
-              break;
             case 39:
               return 74;
-              break;
             case 40:
               return 76;
-              break;
             case 41:
               return 71;
-              break;
             case 42:
               yy_.yytext = yy_.yytext.replace(/\\([\\\]])/g, '$1');
               return 71;
-              break;
             case 43:
               return 'INVALID';
-              break;
             case 44:
               return 5;
-              break;
           }
         },
         rules: [/^(?:[^\x00]*?(?=(\{\{)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/, /^(?:\{\{\{\{(?=[^/]))/, /^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/, /^(?:[^\x00]+?(?=(\{\{\{\{)))/, /^(?:[\s\S]*?--(~)?\}\})/, /^(?:\()/, /^(?:\))/, /^(?:\{\{\{\{)/, /^(?:\}\}\}\})/, /^(?:\{\{(~)?>)/, /^(?:\{\{(~)?#>)/, /^(?:\{\{(~)?#\*?)/, /^(?:\{\{(~)?\/)/, /^(?:\{\{(~)?\^\s*(~)?\}\})/, /^(?:\{\{(~)?\s*else\s*(~)?\}\})/, /^(?:\{\{(~)?\^)/, /^(?:\{\{(~)?\s*else\b)/, /^(?:\{\{(~)?\{)/, /^(?:\{\{(~)?&)/, /^(?:\{\{(~)?!--)/, /^(?:\{\{(~)?![\s\S]*?\}\})/, /^(?:\{\{(~)?\*?)/, /^(?:=)/, /^(?:\.\.)/, /^(?:\.(?=([=~}\s\/.)|])))/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:\}(~)?\}\})/, /^(?:(~)?\}\})/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@)/, /^(?:true(?=([~}\s)])))/, /^(?:false(?=([~}\s)])))/, /^(?:undefined(?=([~}\s)])))/, /^(?:null(?=([~}\s)])))/, /^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/, /^(?:as\s+\|)/, /^(?:\|)/, /^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/, /^(?:\[(\\\]|[^\]])*\])/, /^(?:.)/, /^(?:$)/],
@@ -15025,6 +14969,7 @@ define("@handlebars/parser/index", ["exports"], function (_exports) {
     };
   }
   var Helpers = /*#__PURE__*/Object.freeze({
+    __proto__: null,
     SourceLocation: SourceLocation,
     id: id,
     stripFlags: stripFlags,
@@ -15365,11 +15310,11 @@ define("ember-template-compiler/lib/plugins/assert-against-attrs", ["exports", "
     @class AssertAgainstAttrs
   */
   function assertAgainstAttrs(env) {
-    var _a;
+    var _env$meta;
     var {
       builders: b
     } = env.syntax;
-    var moduleName = (_a = env.meta) === null || _a === void 0 ? void 0 : _a.moduleName;
+    var moduleName = (_env$meta = env.meta) == null ? void 0 : _env$meta.moduleName;
     var stack = [[]];
     function updateBlockParamsStack(blockParams) {
       var parent = stack[stack.length - 1];
@@ -15436,8 +15381,8 @@ define("ember-template-compiler/lib/plugins/assert-against-named-outlets", ["exp
     @class AssertAgainstNamedOutlets
   */
   function assertAgainstNamedOutlets(env) {
-    var _a;
-    var moduleName = (_a = env.meta) === null || _a === void 0 ? void 0 : _a.moduleName;
+    var _env$meta;
+    var moduleName = (_env$meta = env.meta) == null ? void 0 : _env$meta.moduleName;
     return {
       name: 'assert-against-named-outlets',
       visitor: {
@@ -15459,8 +15404,8 @@ define("ember-template-compiler/lib/plugins/assert-input-helper-without-block",
   });
   _exports.default = errorOnInputWithContent;
   function errorOnInputWithContent(env) {
-    var _a;
-    var moduleName = (_a = env.meta) === null || _a === void 0 ? void 0 : _a.moduleName;
+    var _env$meta;
+    var moduleName = (_env$meta = env.meta) == null ? void 0 : _env$meta.moduleName;
     return {
       name: 'assert-input-helper-without-block',
       visitor: {
@@ -15485,8 +15430,8 @@ define("ember-template-compiler/lib/plugins/assert-reserved-named-arguments", ["
   });
   _exports.default = assertReservedNamedArguments;
   function assertReservedNamedArguments(env) {
-    var _a;
-    var moduleName = (_a = env.meta) === null || _a === void 0 ? void 0 : _a.moduleName;
+    var _env$meta;
+    var moduleName = (_env$meta = env.meta) == null ? void 0 : _env$meta.moduleName;
     return {
       name: 'assert-reserved-named-arguments',
       visitor: {
@@ -15540,8 +15485,8 @@ define("ember-template-compiler/lib/plugins/assert-splattribute-expression", ["e
   });
   _exports.default = assertSplattributeExpressions;
   function assertSplattributeExpressions(env) {
-    var _a;
-    var moduleName = (_a = env.meta) === null || _a === void 0 ? void 0 : _a.moduleName;
+    var _env$meta;
+    var moduleName = (_env$meta = env.meta) == null ? void 0 : _env$meta.moduleName;
     return {
       name: 'assert-splattribute-expressions',
       visitor: {
@@ -15903,11 +15848,11 @@ define("ember-template-compiler/lib/plugins/transform-resolutions", ["exports",
   */
   var TARGETS = Object.freeze(['helper', 'modifier']);
   function transformResolutions(env) {
-    var _a;
+    var _env$meta;
     var {
       builders: b
     } = env.syntax;
-    var moduleName = (_a = env.meta) === null || _a === void 0 ? void 0 : _a.moduleName;
+    var moduleName = (_env$meta = env.meta) == null ? void 0 : _env$meta.moduleName;
     var {
       hasLocal,
       node: tracker
@@ -16193,7 +16138,7 @@ define("ember-template-compiler/lib/system/compile-options", ["exports", "@ember
     }, _options, {
       moduleName,
       customizeComponentName(tagname) {
-        (true && !(!malformedComponentLookup(tagname)) && (0, _debug.assert)("You tried to invoke a component named <" + tagname + " /> in \"" + (moduleName !== null && moduleName !== void 0 ? moduleName : '[NO MODULE]') + "\", but that is not a valid name for a component. Did you mean to use the \"::\" syntax for nested components?", !malformedComponentLookup(tagname)));
+        (true && !(!malformedComponentLookup(tagname)) && (0, _debug.assert)("You tried to invoke a component named <" + tagname + " /> in \"" + (moduleName != null ? moduleName : '[NO MODULE]') + "\", but that is not a valid name for a component. Did you mean to use the \"::\" syntax for nested components?", !malformedComponentLookup(tagname)));
         return _dasherizeComponentName.default.get(tagname);
       }
     });
@@ -16363,7 +16308,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "5.0.0-alpha.7";
+  var _default = "5.0.0-beta.3";
   _exports.default = _default;
 });
 define("simple-html-tokenizer", ["exports"], function (_exports) {