ember-source 5.7.0-alpha.2 → 5.7.0-alpha.4

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.7.0-alpha.2
+ * @version   5.7.0-alpha.4
  */
 
 /* eslint-disable no-var */
@@ -2570,8 +2570,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
     return normalizeDottedPath(result[1]);
   }
-  function normalizePath(head) {
-    let tail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  function normalizePath(head, tail) {
+    if (tail === void 0) {
+      tail = [];
+    }
     const pathHead = normalizePathHead(head);
     if ((0, _util.isPresentArray)(tail)) {
       return {
@@ -2772,8 +2774,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     ExpressionKind["HasBlockParams"] = "HasBlockParams";
     return ExpressionKind;
   }({});
-  function normalizeAppendExpression(expression) {
-    let forceTrusted = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  function normalizeAppendExpression(expression, forceTrusted) {
+    if (forceTrusted === void 0) {
+      forceTrusted = false;
+    }
     if (expression === null || expression === undefined) {
       return {
         expr: {
@@ -3104,8 +3108,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     statements.forEach(s => out.push(...buildStatement(s, symbols)));
     return out;
   }
-  function buildStatement(normalized) {
-    let symbols = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new ProgramSymbols();
+  function buildStatement(normalized, symbols) {
+    if (symbols === void 0) {
+      symbols = new ProgramSymbols();
+    }
     switch (normalized.kind) {
       case HeadKind.AppendPath:
         {
@@ -3457,8 +3463,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
     return [keys, values];
   }
-  function buildBlock(block, symbols) {
-    let locals = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  function buildBlock(block, symbols, locals) {
+    if (locals === void 0) {
+      locals = [];
+    }
     return [buildNormalizedStatements(block, symbols), locals];
   }
   class Template extends (0, _syntax.node)('Template').fields() {}
@@ -3530,10 +3538,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     toPresentArray() {
       return this.list;
     }
-    into(_ref) {
+    into(_ref2) {
       let {
         ifPresent
-      } = _ref;
+      } = _ref2;
       return ifPresent(this);
     }
   }
@@ -3553,10 +3561,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     toPresentArray() {
       return null;
     }
-    into(_ref2) {
+    into(_ref3) {
       let {
         ifEmpty
-      } = _ref2;
+      } = _ref3;
       return ifEmpty();
     }
   }
@@ -3573,8 +3581,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
   class ResultImpl {
     static all() {
       let out = [];
-      for (var _len = arguments.length, results = new Array(_len), _key = 0; _key < _len; _key++) {
-        results[_key] = arguments[_key];
+      for (var _len3 = arguments.length, results = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        results[_key3] = arguments[_key3];
       }
       for (let result of results) {
         if (result.isErr) {
@@ -3651,8 +3659,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     return new ErrImpl(reason);
   }
   class ResultArray {
-    constructor() {
-      let items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    constructor(items) {
+      if (items === void 0) {
+        items = [];
+      }
       this.items = items;
     }
     add(item) {
@@ -3801,8 +3811,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       if (!hasPath(expr)) {
         throw new Error("unimplemented subexpression at the head of a subexpression");
       } else {
-        return Result.all(VISIT_EXPRS.visit(expr.callee, state), VISIT_EXPRS.Args(expr.args, state)).mapOk(_ref => {
-          let [callee, args] = _ref;
+        return Result.all(VISIT_EXPRS.visit(expr.callee, state), VISIT_EXPRS.Args(expr.args, state)).mapOk(_ref4 => {
+          let [callee, args] = _ref4;
           return new CallExpression({
             loc: expr.loc,
             callee,
@@ -3811,26 +3821,26 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         });
       }
     }
-    DeprecaedCallExpression(_ref2, _state) {
+    DeprecaedCallExpression(_ref5, _state) {
       let {
         arg,
         callee,
         loc
-      } = _ref2;
+      } = _ref5;
       return Ok(new DeprecatedCallExpression({
         loc,
         arg,
         callee
       }));
     }
-    Args(_ref3, state) {
+    Args(_ref6, state) {
       let {
         positional,
         named,
         loc
-      } = _ref3;
-      return Result.all(this.Positional(positional, state), this.NamedArguments(named, state)).mapOk(_ref4 => {
-        let [positional, named] = _ref4;
+      } = _ref6;
+      return Result.all(this.Positional(positional, state), this.NamedArguments(named, state)).mapOk(_ref7 => {
+        let [positional, named] = _ref7;
         return new Args({
           loc,
           positional,
@@ -4084,18 +4094,18 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
   function keywords(type) {
     return new Keywords(type);
   }
-  function toAppend(_ref) {
+  function toAppend(_ref8) {
     let {
       assert,
       translate
-    } = _ref;
+    } = _ref8;
     return {
       assert,
-      translate(_ref2, value) {
+      translate(_ref9, value) {
         let {
           node,
           state
-        } = _ref2;
+        } = _ref9;
         let result = translate({
           node,
           state
@@ -4145,19 +4155,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     };
   }
   function translateCurryKeyword(curriedType) {
-    return (_ref, _ref2) => {
+    return (_ref10, _ref11) => {
       let {
         node,
         state
-      } = _ref;
+      } = _ref10;
       let {
         definition,
         args
-      } = _ref2;
+      } = _ref11;
       let definitionResult = VISIT_EXPRS.visit(definition, state);
       let argsResult = VISIT_EXPRS.Args(args, state);
-      return Result.all(definitionResult, argsResult).mapOk(_ref3 => {
-        let [definition, args] = _ref3;
+      return Result.all(definitionResult, argsResult).mapOk(_ref12 => {
+        let [definition, args] = _ref12;
         return new Curry({
           loc: node.loc,
           curriedType,
@@ -4189,11 +4199,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
     return Ok(varName);
   }
-  function translateGetDynamicVarKeyword(_ref, name) {
+  function translateGetDynamicVarKeyword(_ref13, name) {
     let {
       node,
       state
-    } = _ref;
+    } = _ref13;
     return VISIT_EXPRS.visit(name, state).mapOk(name => new GetDynamicVar({
       name,
       loc: node.loc
@@ -4226,13 +4236,13 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     };
   }
   function translateHasBlockKeyword(type) {
-    return (_ref, target) => {
+    return (_ref14, target) => {
       let {
         node,
         state: {
           scope
         }
-      } = _ref;
+      } = _ref14;
       let block = type === 'has-block' ? new HasBlock({
         loc: node.loc,
         target,
@@ -4282,21 +4292,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
   }
   function translateIfUnlessInlineKeyword(type) {
     let inverted = type === 'unless';
-    return (_ref, _ref2) => {
+    return (_ref15, _ref16) => {
       let {
         node,
         state
-      } = _ref;
+      } = _ref15;
       let {
         condition,
         truthy,
         falsy
-      } = _ref2;
+      } = _ref16;
       let conditionResult = VISIT_EXPRS.visit(condition, state);
       let truthyResult = VISIT_EXPRS.visit(truthy, state);
       let falsyResult = falsy ? VISIT_EXPRS.visit(falsy, state) : Ok(null);
-      return Result.all(conditionResult, truthyResult, falsyResult).mapOk(_ref3 => {
-        let [condition, truthy, falsy] = _ref3;
+      return Result.all(conditionResult, truthyResult, falsyResult).mapOk(_ref17 => {
+        let [condition, truthy, falsy] = _ref17;
         if (inverted) {
           condition = new Not({
             value: condition,
@@ -4330,11 +4340,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
     return Ok(positional);
   }
-  function translateLogKeyword(_ref, positional) {
+  function translateLogKeyword(_ref18, positional) {
     let {
       node,
       state
-    } = _ref;
+    } = _ref18;
     return VISIT_EXPRS.Positional(positional, state).mapOk(positional => new Log({
       positional,
       loc: node.loc
@@ -4369,15 +4379,15 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         }
       }
     },
-    translate(_ref, _ref2) {
+    translate(_ref19, _ref20) {
       let {
         node,
         state
-      } = _ref;
+      } = _ref19;
       let {
         target,
         positional
-      } = _ref2;
+      } = _ref20;
       return VISIT_EXPRS.Positional(positional, state).mapOk(positional => new Yield({
         loc: node.loc,
         target,
@@ -4403,13 +4413,13 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         }
       }
     },
-    translate(_ref3) {
+    translate(_ref21) {
       let {
         node,
         state: {
           scope
         }
-      } = _ref3;
+      } = _ref21;
       scope.setHasDebugger();
       return Ok(new Debugger({
         loc: node.loc,
@@ -4418,19 +4428,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
   }).kw('component', {
     assert: assertCurryKeyword(_vm.CurriedTypes.Component),
-    translate(_ref4, _ref5) {
+    translate(_ref22, _ref23) {
       let {
         node,
         state
-      } = _ref4;
+      } = _ref22;
       let {
         definition,
         args
-      } = _ref5;
+      } = _ref23;
       let definitionResult = VISIT_EXPRS.visit(definition, state);
       let argsResult = VISIT_EXPRS.Args(args, state);
-      return Result.all(definitionResult, argsResult).mapOk(_ref6 => {
-        let [definition, args] = _ref6;
+      return Result.all(definitionResult, argsResult).mapOk(_ref24 => {
+        let [definition, args] = _ref24;
         return new InvokeComponent({
           loc: node.loc,
           definition,
@@ -4441,19 +4451,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
   }).kw('helper', {
     assert: assertCurryKeyword(_vm.CurriedTypes.Helper),
-    translate(_ref7, _ref8) {
+    translate(_ref25, _ref26) {
       let {
         node,
         state
-      } = _ref7;
+      } = _ref25;
       let {
         definition,
         args
-      } = _ref8;
+      } = _ref26;
       let definitionResult = VISIT_EXPRS.visit(definition, state);
       let argsResult = VISIT_EXPRS.Args(args, state);
-      return Result.all(definitionResult, argsResult).mapOk(_ref9 => {
-        let [definition, args] = _ref9;
+      return Result.all(definitionResult, argsResult).mapOk(_ref27 => {
+        let [definition, args] = _ref27;
         let text = new CallExpression({
           callee: definition,
           args,
@@ -4488,20 +4498,20 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         destination
       });
     },
-    translate(_ref, _ref2) {
+    translate(_ref28, _ref29) {
       let {
         node,
         state
-      } = _ref;
+      } = _ref28;
       let {
         insertBefore,
         destination
-      } = _ref2;
+      } = _ref29;
       let named = node.blocks.get('default');
       let body = VISIT_STMTS.NamedBlock(named, state);
       let destinationResult = VISIT_EXPRS.visit(destination, state);
-      return Result.all(body, destinationResult).andThen(_ref3 => {
-        let [body, destination] = _ref3;
+      return Result.all(body, destinationResult).andThen(_ref30 => {
+        let [body, destination] = _ref30;
         if (insertBefore) {
           return VISIT_EXPRS.visit(insertBefore, state).mapOk(insertBefore => ({
             body,
@@ -4517,12 +4527,12 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
             })
           });
         }
-      }).mapOk(_ref4 => {
+      }).mapOk(_ref31 => {
         let {
           body,
           destination,
           insertBefore
-        } = _ref4;
+        } = _ref31;
         return new InElement({
           loc: node.loc,
           block: body,
@@ -4551,21 +4561,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         condition
       });
     },
-    translate(_ref5, _ref6) {
+    translate(_ref32, _ref33) {
       let {
         node,
         state
-      } = _ref5;
+      } = _ref32;
       let {
         condition
-      } = _ref6;
+      } = _ref33;
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
       let conditionResult = VISIT_EXPRS.visit(condition, state);
       let blockResult = VISIT_STMTS.NamedBlock(block, state);
       let inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
-      return Result.all(conditionResult, blockResult, inverseResult).mapOk(_ref7 => {
-        let [condition, block, inverse] = _ref7;
+      return Result.all(conditionResult, blockResult, inverseResult).mapOk(_ref34 => {
+        let [condition, block, inverse] = _ref34;
         return new If({
           loc: node.loc,
           condition,
@@ -4593,21 +4603,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         condition
       });
     },
-    translate(_ref8, _ref9) {
+    translate(_ref35, _ref36) {
       let {
         node,
         state
-      } = _ref8;
+      } = _ref35;
       let {
         condition
-      } = _ref9;
+      } = _ref36;
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
       let conditionResult = VISIT_EXPRS.visit(condition, state);
       let blockResult = VISIT_STMTS.NamedBlock(block, state);
       let inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
-      return Result.all(conditionResult, blockResult, inverseResult).mapOk(_ref10 => {
-        let [condition, block, inverse] = _ref10;
+      return Result.all(conditionResult, blockResult, inverseResult).mapOk(_ref37 => {
+        let [condition, block, inverse] = _ref37;
         return new If({
           loc: node.loc,
           condition: new Not({
@@ -4640,23 +4650,23 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         key
       });
     },
-    translate(_ref11, _ref12) {
+    translate(_ref38, _ref39) {
       let {
         node,
         state
-      } = _ref11;
+      } = _ref38;
       let {
         value,
         key
-      } = _ref12;
+      } = _ref39;
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
       let valueResult = VISIT_EXPRS.visit(value, state);
       let keyResult = key ? VISIT_EXPRS.visit(key, state) : Ok(null);
       let blockResult = VISIT_STMTS.NamedBlock(block, state);
       let inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
-      return Result.all(valueResult, keyResult, blockResult, inverseResult).mapOk(_ref13 => {
-        let [value, key, block, inverse] = _ref13;
+      return Result.all(valueResult, keyResult, blockResult, inverseResult).mapOk(_ref40 => {
+        let [value, key, block, inverse] = _ref40;
         return new Each({
           loc: node.loc,
           value,
@@ -4685,21 +4695,21 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         value
       });
     },
-    translate(_ref14, _ref15) {
+    translate(_ref41, _ref42) {
       let {
         node,
         state
-      } = _ref14;
+      } = _ref41;
       let {
         value
-      } = _ref15;
+      } = _ref42;
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
       let valueResult = VISIT_EXPRS.visit(value, state);
       let blockResult = VISIT_STMTS.NamedBlock(block, state);
       let inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
-      return Result.all(valueResult, blockResult, inverseResult).mapOk(_ref16 => {
-        let [value, block, inverse] = _ref16;
+      return Result.all(valueResult, blockResult, inverseResult).mapOk(_ref43 => {
+        let [value, block, inverse] = _ref43;
         return new With({
           loc: node.loc,
           value,
@@ -4726,19 +4736,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         positional: args.positional
       });
     },
-    translate(_ref17, _ref18) {
+    translate(_ref44, _ref45) {
       let {
         node,
         state
-      } = _ref17;
+      } = _ref44;
       let {
         positional
-      } = _ref18;
+      } = _ref45;
       let block = node.blocks.get('default');
       let positionalResult = VISIT_EXPRS.Positional(positional, state);
       let blockResult = VISIT_STMTS.NamedBlock(block, state);
-      return Result.all(positionalResult, blockResult).mapOk(_ref19 => {
-        let [positional, block] = _ref19;
+      return Result.all(positionalResult, blockResult).mapOk(_ref46 => {
+        let [positional, block] = _ref46;
         return new Let({
           loc: node.loc,
           positional,
@@ -4752,19 +4762,19 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         named: node.args.named
       });
     },
-    translate(_ref20, _ref21) {
+    translate(_ref47, _ref48) {
       let {
         node,
         state
-      } = _ref20;
+      } = _ref47;
       let {
         named
-      } = _ref21;
+      } = _ref48;
       let block = node.blocks.get('default');
       let namedResult = VISIT_EXPRS.NamedArguments(named, state);
       let blockResult = VISIT_STMTS.NamedBlock(block, state);
-      return Result.all(namedResult, blockResult).mapOk(_ref22 => {
-        let [named, block] = _ref22;
+      return Result.all(namedResult, blockResult).mapOk(_ref49 => {
+        let [named, block] = _ref49;
         return new WithDynamicVars({
           loc: node.loc,
           named,
@@ -4774,20 +4784,20 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }
   }).kw('component', {
     assert: assertCurryKeyword(_vm.CurriedTypes.Component),
-    translate(_ref23, _ref24) {
+    translate(_ref50, _ref51) {
       let {
         node,
         state
-      } = _ref23;
+      } = _ref50;
       let {
         definition,
         args
-      } = _ref24;
+      } = _ref51;
       let definitionResult = VISIT_EXPRS.visit(definition, state);
       let argsResult = VISIT_EXPRS.Args(args, state);
       let blocksResult = VISIT_STMTS.NamedBlocks(node.blocks, state);
-      return Result.all(definitionResult, argsResult, blocksResult).mapOk(_ref25 => {
-        let [definition, args, blocks] = _ref25;
+      return Result.all(definitionResult, argsResult, blocksResult).mapOk(_ref52 => {
+        let [definition, args, blocks] = _ref52;
         return new InvokeComponent({
           loc: node.loc,
           definition,
@@ -4914,8 +4924,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       }
       let head = VISIT_EXPRS.visit(modifier.callee, this.state);
       let args = VISIT_EXPRS.Args(modifier.args, this.state);
-      return Result.all(head, args).mapOk(_ref => {
-        let [head, args] = _ref;
+      return Result.all(head, args).mapOk(_ref53 => {
+        let [head, args] = _ref53;
         return new Modifier({
           loc: modifier.loc,
           callee: head,
@@ -4953,8 +4963,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       if (typeAttr) {
         attrs.add(this.attr(typeAttr));
       }
-      return Result.all(args.toArray(), attrs.toArray()).mapOk(_ref2 => {
-        let [args, attrs] = _ref2;
+      return Result.all(args.toArray(), attrs.toArray()).mapOk(_ref54 => {
+        let [args, attrs] = _ref54;
         return {
           attrs,
           args: new NamedArguments({
@@ -4967,8 +4977,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     prepare() {
       let attrs = this.attrs();
       let modifiers = new ResultArray(this.element.modifiers.map(m => this.modifier(m))).toArray();
-      return Result.all(attrs, modifiers).mapOk(_ref3 => {
-        let [result, modifiers] = _ref3;
+      return Result.all(attrs, modifiers).mapOk(_ref55 => {
+        let [result, modifiers] = _ref55;
         let {
           attrs,
           args
@@ -4985,11 +4995,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       });
     }
   }
-  function hasDynamicFeatures(_ref4) {
+  function hasDynamicFeatures(_ref56) {
     let {
       attrs,
       modifiers
-    } = _ref4;
+    } = _ref56;
     // ElementModifier needs the special ComponentOperations
     if (modifiers.length > 0) {
       return true;
@@ -5004,10 +5014,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       this.tag = tag;
       this.element = element;
     }
-    arg(attr, _ref) {
+    arg(attr, _ref57) {
       let {
         state
-      } = _ref;
+      } = _ref57;
       let name = attr.name;
       return VISIT_EXPRS.visit(convertPathToCallIfKeyword(attr.value), state).mapOk(value => new NamedArgument({
         loc: attr.loc,
@@ -5015,11 +5025,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         value
       }));
     }
-    toStatement(component, _ref2) {
+    toStatement(component, _ref58) {
       let {
         args,
         params
-      } = _ref2;
+      } = _ref58;
       let {
         element,
         state
@@ -5046,10 +5056,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     arg(attr) {
       return Err((0, _syntax.generateSyntaxError)(attr.name.chars + " is not a valid attribute name. @arguments are only allowed on components, but the tag for this element (`" + this.tag.chars + "`) is a regular, non-component HTML element.", attr.loc));
     }
-    toStatement(classified, _ref) {
+    toStatement(classified, _ref59) {
       let {
         params
-      } = _ref;
+      } = _ref59;
       let {
         state,
         element
@@ -5093,8 +5103,8 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       }
       let head = VISIT_EXPRS.visit(node.callee, state);
       let args = VISIT_EXPRS.Args(node.args, state);
-      return Result.all(head, args).andThen(_ref => {
-        let [head, args] = _ref;
+      return Result.all(head, args).andThen(_ref60 => {
+        let [head, args] = _ref60;
         return this.NamedBlocks(node.blocks, state).mapOk(blocks => new InvokeBlock({
           loc: node.loc,
           head,
@@ -5241,10 +5251,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     }));
   }
   class WireFormatDebugger {
-    constructor(_ref) {
+    constructor(_ref61) {
+      let [_statements, symbols, _hasEval, upvars] = _ref61;
       this.upvars = void 0;
       this.symbols = void 0;
-      let [_statements, symbols, _hasEval, upvars] = _ref;
       this.upvars = upvars;
       this.symbols = symbols;
     }
@@ -5448,10 +5458,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
           return this.Log(expr);
       }
     }
-    Literal(_ref) {
+    Literal(_ref62) {
       let {
         value
-      } = _ref;
+      } = _ref62;
       if (value === undefined) {
         return [_wireFormat.SexpOpcodes.Undefined];
       } else {
@@ -5461,97 +5471,97 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
     Missing() {
       return undefined;
     }
-    HasBlock(_ref2) {
+    HasBlock(_ref63) {
       let {
         symbol
-      } = _ref2;
+      } = _ref63;
       return [_wireFormat.SexpOpcodes.HasBlock, [_wireFormat.SexpOpcodes.GetSymbol, symbol]];
     }
-    HasBlockParams(_ref3) {
+    HasBlockParams(_ref64) {
       let {
         symbol
-      } = _ref3;
+      } = _ref64;
       return [_wireFormat.SexpOpcodes.HasBlockParams, [_wireFormat.SexpOpcodes.GetSymbol, symbol]];
     }
-    Curry(_ref4) {
+    Curry(_ref65) {
       let {
         definition,
         curriedType,
         args
-      } = _ref4;
+      } = _ref65;
       return [_wireFormat.SexpOpcodes.Curry, EXPR.expr(definition), curriedType, EXPR.Positional(args.positional), EXPR.NamedArguments(args.named)];
     }
-    Local(_ref5) {
+    Local(_ref66) {
       let {
         isTemplateLocal,
         symbol
-      } = _ref5;
+      } = _ref66;
       return [isTemplateLocal ? _wireFormat.SexpOpcodes.GetLexicalSymbol : _wireFormat.SexpOpcodes.GetSymbol, symbol];
     }
-    GetWithResolver(_ref6) {
+    GetWithResolver(_ref67) {
       let {
         symbol
-      } = _ref6;
+      } = _ref67;
       return [_wireFormat.SexpOpcodes.GetFreeAsComponentOrHelperHeadOrThisFallback, symbol];
     }
-    PathExpression(_ref7) {
+    PathExpression(_ref68) {
       let {
         head,
         tail
-      } = _ref7;
+      } = _ref68;
       let getOp = EXPR.expr(head);
       return [...getOp, EXPR.Tail(tail)];
     }
-    InterpolateExpression(_ref8) {
+    InterpolateExpression(_ref69) {
       let {
         parts
-      } = _ref8;
+      } = _ref69;
       return [_wireFormat.SexpOpcodes.Concat, parts.map(e => EXPR.expr(e)).toArray()];
     }
-    CallExpression(_ref9) {
+    CallExpression(_ref70) {
       let {
         callee,
         args
-      } = _ref9;
+      } = _ref70;
       return [_wireFormat.SexpOpcodes.Call, EXPR.expr(callee), ...EXPR.Args(args)];
     }
-    DeprecatedCallExpression(_ref10) {
+    DeprecatedCallExpression(_ref71) {
       let {
         arg,
         callee
-      } = _ref10;
+      } = _ref71;
       return [_wireFormat.SexpOpcodes.GetFreeAsDeprecatedHelperHeadOrThisFallback, callee.symbol, [arg.chars]];
     }
-    Tail(_ref11) {
+    Tail(_ref72) {
       let {
         members
-      } = _ref11;
+      } = _ref72;
       return (0, _util.mapPresentArray)(members, member => member.chars);
     }
-    Args(_ref12) {
+    Args(_ref73) {
       let {
         positional,
         named
-      } = _ref12;
+      } = _ref73;
       return [this.Positional(positional), this.NamedArguments(named)];
     }
-    Positional(_ref13) {
+    Positional(_ref74) {
       let {
         list
-      } = _ref13;
+      } = _ref74;
       return list.map(l => EXPR.expr(l)).toPresentArray();
     }
-    NamedArgument(_ref14) {
+    NamedArgument(_ref75) {
       let {
         key,
         value
-      } = _ref14;
+      } = _ref75;
       return [key.chars, EXPR.expr(value)];
     }
-    NamedArguments(_ref15) {
+    NamedArguments(_ref76) {
       let {
         entries: pairs
-      } = _ref15;
+      } = _ref76;
       let list = pairs.toArray();
       if ((0, _util.isPresentArray)(list)) {
         let names = [];
@@ -5568,34 +5578,34 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         return null;
       }
     }
-    Not(_ref16) {
+    Not(_ref77) {
       let {
         value
-      } = _ref16;
+      } = _ref77;
       return [_wireFormat.SexpOpcodes.Not, EXPR.expr(value)];
     }
-    IfInline(_ref17) {
+    IfInline(_ref78) {
       let {
         condition,
         truthy,
         falsy
-      } = _ref17;
+      } = _ref78;
       let expr = [_wireFormat.SexpOpcodes.IfInline, EXPR.expr(condition), EXPR.expr(truthy)];
       if (falsy) {
         expr.push(EXPR.expr(falsy));
       }
       return expr;
     }
-    GetDynamicVar(_ref18) {
+    GetDynamicVar(_ref79) {
       let {
         name
-      } = _ref18;
+      } = _ref79;
       return [_wireFormat.SexpOpcodes.GetDynamicVar, EXPR.expr(name)];
     }
-    Log(_ref19) {
+    Log(_ref80) {
       let {
         positional
-      } = _ref19;
+      } = _ref80;
       return [_wireFormat.SexpOpcodes.Log, this.Positional(positional)];
     }
   }
@@ -5660,20 +5670,20 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
           return (0, _util.exhausted)(stmt);
       }
     }
-    Yield(_ref) {
+    Yield(_ref81) {
       let {
         to,
         positional
-      } = _ref;
+      } = _ref81;
       return [_wireFormat.SexpOpcodes.Yield, to, EXPR.Positional(positional)];
     }
-    InElement(_ref2) {
+    InElement(_ref82) {
       let {
         guid,
         insertBefore,
         destination,
         block
-      } = _ref2;
+      } = _ref82;
       let wireBlock = CONTENT.NamedBlock(block)[1];
       // let guid = args.guid;
       let wireDestination = EXPR.expr(destination);
@@ -5684,59 +5694,59 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
         return [_wireFormat.SexpOpcodes.InElement, wireBlock, guid, wireDestination, wireInsertBefore];
       }
     }
-    InvokeBlock(_ref3) {
+    InvokeBlock(_ref83) {
       let {
         head,
         args,
         blocks
-      } = _ref3;
+      } = _ref83;
       return [_wireFormat.SexpOpcodes.Block, EXPR.expr(head), ...EXPR.Args(args), CONTENT.NamedBlocks(blocks)];
     }
-    AppendTrustedHTML(_ref4) {
+    AppendTrustedHTML(_ref84) {
       let {
         html
-      } = _ref4;
+      } = _ref84;
       return [_wireFormat.SexpOpcodes.TrustingAppend, EXPR.expr(html)];
     }
-    AppendTextNode(_ref5) {
+    AppendTextNode(_ref85) {
       let {
         text
-      } = _ref5;
+      } = _ref85;
       return [_wireFormat.SexpOpcodes.Append, EXPR.expr(text)];
     }
-    AppendComment(_ref6) {
+    AppendComment(_ref86) {
       let {
         value
-      } = _ref6;
+      } = _ref86;
       return [_wireFormat.SexpOpcodes.Comment, value.chars];
     }
-    SimpleElement(_ref7) {
+    SimpleElement(_ref87) {
       let {
         tag,
         params,
         body,
         dynamicFeatures
-      } = _ref7;
+      } = _ref87;
       let op = dynamicFeatures ? _wireFormat.SexpOpcodes.OpenElementWithSplat : _wireFormat.SexpOpcodes.OpenElement;
       return new WireStatements([[op, deflateTagName(tag.chars)], ...CONTENT.ElementParameters(params).toArray(), [_wireFormat.SexpOpcodes.FlushElement], ...CONTENT.list(body), [_wireFormat.SexpOpcodes.CloseElement]]);
     }
-    Component(_ref8) {
+    Component(_ref88) {
       let {
         tag,
         params,
         args,
         blocks
-      } = _ref8;
+      } = _ref88;
       let wireTag = EXPR.expr(tag);
       let wirePositional = CONTENT.ElementParameters(params);
       let wireNamed = EXPR.NamedArguments(args);
       let wireNamedBlocks = CONTENT.NamedBlocks(blocks);
       return [_wireFormat.SexpOpcodes.Component, wireTag, wirePositional.toPresentArray(), wireNamed, wireNamedBlocks];
     }
-    ElementParameters(_ref9) {
+    ElementParameters(_ref89) {
       let {
         body
-      } = _ref9;
+      } = _ref89;
       return body.map(p => CONTENT.ElementParameter(p));
     }
     ElementParameter(param) {
@@ -5751,10 +5761,10 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
           return [_wireFormat.SexpOpcodes.Modifier, EXPR.expr(param.callee), ...EXPR.Args(param.args)];
       }
     }
-    NamedBlocks(_ref10) {
+    NamedBlocks(_ref90) {
       let {
         blocks
-      } = _ref10;
+      } = _ref90;
       let names = [];
       let serializedBlocks = [];
       for (let block of blocks.toArray()) {
@@ -5764,85 +5774,85 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
       }
       return names.length > 0 ? [names, serializedBlocks] : null;
     }
-    NamedBlock(_ref11) {
+    NamedBlock(_ref91) {
       let {
         name,
         body,
         scope
-      } = _ref11;
+      } = _ref91;
       let nameChars = name.chars;
       if (nameChars === 'inverse') {
         nameChars = 'else';
       }
       return [nameChars, [CONTENT.list(body), scope.slots]];
     }
-    If(_ref12) {
+    If(_ref92) {
       let {
         condition,
         block,
         inverse
-      } = _ref12;
+      } = _ref92;
       return [_wireFormat.SexpOpcodes.If, EXPR.expr(condition), CONTENT.NamedBlock(block)[1], inverse ? CONTENT.NamedBlock(inverse)[1] : null];
     }
-    Each(_ref13) {
+    Each(_ref93) {
       let {
         value,
         key,
         block,
         inverse
-      } = _ref13;
+      } = _ref93;
       return [_wireFormat.SexpOpcodes.Each, EXPR.expr(value), key ? EXPR.expr(key) : null, CONTENT.NamedBlock(block)[1], inverse ? CONTENT.NamedBlock(inverse)[1] : null];
     }
-    With(_ref14) {
+    With(_ref94) {
       let {
         value,
         block,
         inverse
-      } = _ref14;
+      } = _ref94;
       return [_wireFormat.SexpOpcodes.With, EXPR.expr(value), CONTENT.NamedBlock(block)[1], inverse ? CONTENT.NamedBlock(inverse)[1] : null];
     }
-    Let(_ref15) {
+    Let(_ref95) {
       let {
         positional,
         block
-      } = _ref15;
+      } = _ref95;
       return [_wireFormat.SexpOpcodes.Let, EXPR.Positional(positional), CONTENT.NamedBlock(block)[1]];
     }
-    WithDynamicVars(_ref16) {
+    WithDynamicVars(_ref96) {
       let {
         named,
         block
-      } = _ref16;
+      } = _ref96;
       return [_wireFormat.SexpOpcodes.WithDynamicVars, EXPR.NamedArguments(named), CONTENT.NamedBlock(block)[1]];
     }
-    InvokeComponent(_ref17) {
+    InvokeComponent(_ref97) {
       let {
         definition,
         args,
         blocks
-      } = _ref17;
+      } = _ref97;
       return [_wireFormat.SexpOpcodes.InvokeComponent, EXPR.expr(definition), EXPR.Positional(args.positional), EXPR.NamedArguments(args.named), blocks ? CONTENT.NamedBlocks(blocks) : null];
     }
   }
   const CONTENT = new ContentEncoder();
-  function staticAttr(_ref18) {
+  function staticAttr(_ref98) {
     let {
       name,
       value,
       namespace
-    } = _ref18;
+    } = _ref98;
     let out = [deflateAttrName(name.chars), value.chars];
     if (namespace) {
       out.push(namespace);
     }
     return out;
   }
-  function dynamicAttr(_ref19) {
+  function dynamicAttr(_ref99) {
     let {
       name,
       value,
       namespace
-    } = _ref19;
+    } = _ref99;
     let out = [deflateAttrName(name.chars), EXPR.expr(value)];
     if (namespace) {
       out.push(namespace);
@@ -5908,9 +5918,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
    * @param {string} string a Glimmer template string
    * @return {string} a template javascript string
    */
-  function precompileJSON(string) {
+  function precompileJSON(string, options) {
     var _options$meta, _options$strictMode;
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
+    if (options === void 0) {
+      options = defaultOptions;
+    }
     const source = new _syntax.src.Source(string != null ? string : '', (_options$meta = options.meta) == null ? void 0 : _options$meta.moduleName);
     const [ast, locals] = (0, _syntax.normalize)(source, {
       lexicalScope: () => false,
@@ -5944,9 +5956,11 @@ define("@glimmer/compiler", ["exports", "@glimmer/util", "@glimmer/wire-format",
    * @param {string} string a Glimmer template string
    * @return {string} a template javascript string
    */
-  function precompile(source) {
+  function precompile(source, options) {
     var _options$meta2, _options$strictMode2;
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
+    if (options === void 0) {
+      options = defaultOptions;
+    }
     const [block, usedLocals] = precompileJSON(source, options);
     const moduleName = (_options$meta2 = options.meta) == null ? void 0 : _options$meta2.moduleName;
     const idFn = options.id || defaultId;
@@ -6106,8 +6120,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
       For example, ember-template-recast attempts to always preserve the original string
       formatting in each AST node if no modifications are made to it.
     */
-    handledByOverride(node) {
-      let ensureLeadingWhitespace = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    handledByOverride(node, ensureLeadingWhitespace) {
+      if (ensureLeadingWhitespace === void 0) {
+        ensureLeadingWhitespace = false;
+      }
       if (this.options.override !== undefined) {
         let result = this.options.override(node, this.options);
         if (typeof result === 'string') {
@@ -6511,10 +6527,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
       return this.buffer;
     }
   }
-  function build(ast) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      entityEncoding: 'transformed'
-    };
+  function build(ast, options) {
+    if (options === void 0) {
+      options = {
+        entityEncoding: 'transformed'
+      };
+    }
     if (!ast) {
       return '';
     }
@@ -6780,8 +6798,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
     static synthetic(chars) {
       return new InvisibleSpan(OffsetKind.InternalsSynthetic, NON_EXISTENT_LOCATION, chars).wrap();
     }
-    static broken() {
-      let pos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : BROKEN_LOCATION;
+    static broken(pos) {
+      if (pos === void 0) {
+        pos = BROKEN_LOCATION;
+      }
       return new InvisibleSpan(OffsetKind.Broken, pos).wrap();
     }
     constructor(data) {
@@ -7003,12 +7023,14 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
     }
   }
   class HbsSpan {
-    constructor(source, hbsPositions) {
+    constructor(source, hbsPositions, providedHbsLoc) {
+      if (providedHbsLoc === void 0) {
+        providedHbsLoc = null;
+      }
       this.kind = OffsetKind.HbsPosition;
       this._charPosSpan = null;
       // the source location from Handlebars + AST Plugins -- could be wrong
       this._providedHbsLoc = void 0;
-      let providedHbsLoc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
       this.source = source;
       this.hbsPositions = hbsPositions;
       this._providedHbsLoc = providedHbsLoc;
@@ -7089,8 +7111,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
   class InvisibleSpan {
     constructor(kind,
     // whatever was provided, possibly broken
-    loc) {
-      let string = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    loc,
+    // if the span represents a synthetic string
+    string) {
+      if (string === void 0) {
+        string = null;
+      }
       this.kind = kind;
       this.loc = loc;
       this.string = string;
@@ -7200,8 +7226,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
      * calling code determined (or knows) that the `SourceLocation` doesn't correspond correctly to
      * any part of the source.
      */
-    static broken() {
-      let pos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : UNKNOWN_POSITION;
+    static broken(pos) {
+      if (pos === void 0) {
+        pos = UNKNOWN_POSITION;
+      }
       return new InvisiblePosition(OffsetKind.Broken, pos).wrap();
     }
     constructor(data) {
@@ -7333,10 +7361,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
     }
   }
   class HbsPosition {
-    constructor(source, hbsPos) {
+    constructor(source, hbsPos, charPos) {
+      if (charPos === void 0) {
+        charPos = null;
+      }
       this.kind = OffsetKind.HbsPosition;
       this._charPos = void 0;
-      let charPos = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
       this.source = source;
       this.hbsPos = hbsPos;
       this._charPos = charPos === null ? null : new CharPosition(source, charPos);
@@ -7419,43 +7449,47 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
    *
    * @see {SourceOffset#eql}
    */
-  const eql = match(m => m.when(OffsetKind.HbsPosition, OffsetKind.HbsPosition, (_ref, _ref2) => {
+  const eql = match(m => m.when(OffsetKind.HbsPosition, OffsetKind.HbsPosition, (_ref6, _ref7) => {
     let {
       hbsPos: left
-    } = _ref;
+    } = _ref6;
     let {
       hbsPos: right
-    } = _ref2;
+    } = _ref7;
     return left.column === right.column && left.line === right.line;
-  }).when(OffsetKind.CharPosition, OffsetKind.CharPosition, (_ref3, _ref4) => {
+  }).when(OffsetKind.CharPosition, OffsetKind.CharPosition, (_ref8, _ref9) => {
     let {
       charPos: left
-    } = _ref3;
+    } = _ref8;
     let {
       charPos: right
-    } = _ref4;
+    } = _ref9;
     return left === right;
-  }).when(OffsetKind.CharPosition, OffsetKind.HbsPosition, (_ref5, right) => {
+  }).when(OffsetKind.CharPosition, OffsetKind.HbsPosition, (_ref10, right) => {
     var _right$toCharPos;
     let {
       offset: left
-    } = _ref5;
+    } = _ref10;
     return left === ((_right$toCharPos = right.toCharPos()) == null ? void 0 : _right$toCharPos.offset);
-  }).when(OffsetKind.HbsPosition, OffsetKind.CharPosition, (left, _ref6) => {
+  }).when(OffsetKind.HbsPosition, OffsetKind.CharPosition, (left, _ref11) => {
     var _left$toCharPos;
     let {
       offset: right
-    } = _ref6;
+    } = _ref11;
     return ((_left$toCharPos = left.toCharPos()) == null ? void 0 : _left$toCharPos.offset) === right;
   }).when(MatchAny, MatchAny, () => false));
   class Source {
-    static from(source) {
+    static from(source, options) {
       var _options$meta;
-      let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (options === void 0) {
+        options = {};
+      }
       return new Source(source, (_options$meta = options.meta) == null ? void 0 : _options$meta.moduleName);
     }
-    constructor(source) {
-      let module = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'an unknown module';
+    constructor(source, module) {
+      if (module === void 0) {
+        module = 'an unknown module';
+      }
       this.source = source;
       this.module = module;
     }
@@ -7475,11 +7509,11 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         column
       });
     }
-    spanFor(_ref) {
+    spanFor(_ref12) {
       let {
         start,
         end
-      } = _ref;
+      } = _ref12;
       return SourceSpan.forHbsLoc(this, {
         start: {
           line: start.line,
@@ -7544,13 +7578,17 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
     }
   }
   class SpanList {
-    static range(span) {
-      let fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SourceSpan.NON_EXISTENT;
+    static range(span, fallback) {
+      if (fallback === void 0) {
+        fallback = SourceSpan.NON_EXISTENT;
+      }
       return new SpanList(span.map(loc)).getRangeOffset(fallback);
     }
-    constructor() {
+    constructor(span) {
+      if (span === void 0) {
+        span = [];
+      }
       this._span = void 0;
-      let span = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       this._span = span;
     }
     add(offset) {
@@ -7679,12 +7717,16 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
     return new TraversalError('Replacing and removing in key handlers is not yet supported.', node, null, key);
   }
   class WalkerPath {
-    constructor(node) {
+    constructor(node, parent, parentKey) {
+      if (parent === void 0) {
+        parent = null;
+      }
+      if (parentKey === void 0) {
+        parentKey = null;
+      }
       this.node = void 0;
       this.parent = void 0;
       this.parentKey = void 0;
-      let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      let parentKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
       this.node = node;
       this.parent = parent;
       this.parentKey = parentKey;
@@ -7946,6 +7988,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
 
   // Regex to validate the identifier for block parameters.
   // Based on the ID validation regex in Handlebars.
+
   let ID_INVERSE_PATTERN = /[!"#%&'()*+./;<=>@[\\\]^`{|}~]/u;
 
   // Checks the element's attributes to see if it uses block params.
@@ -8138,8 +8181,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
 
   // Nodes
 
-  function buildElement(tag) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  function buildElement(tag, options) {
+    if (options === void 0) {
+      options = {};
+    }
     let {
       attrs,
       blockParams,
@@ -8350,9 +8395,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
       loc: buildLoc(loc || null)
     };
   }
-  function buildBlockItself(body, blockParams) {
-    let chained = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    let loc = arguments.length > 3 ? arguments[3] : undefined;
+  function buildBlockItself(body, blockParams, chained, loc) {
+    if (chained === void 0) {
+      chained = false;
+    }
     return {
       type: 'Block',
       body: body || [],
@@ -8504,13 +8550,13 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         column
       };
     }
-    blockItself(_ref) {
+    blockItself(_ref13) {
       let {
         body = [],
         blockParams = [],
         chained = false,
         loc
-      } = _ref;
+      } = _ref13;
       return {
         type: 'Block',
         body: body,
@@ -8519,12 +8565,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    template(_ref2) {
+    template(_ref14) {
       let {
         body,
         blockParams,
         loc
-      } = _ref2;
+      } = _ref14;
       return {
         type: 'Template',
         body: body || [],
@@ -8532,7 +8578,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    mustache(_ref3) {
+    mustache(_ref15) {
       let {
         path,
         params,
@@ -8540,7 +8586,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         trusting,
         loc,
         strip = DEFAULT_STRIP
-      } = _ref3;
+      } = _ref15;
       return {
         type: 'MustacheStatement',
         path,
@@ -8555,7 +8601,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         }
       };
     }
-    block(_ref4) {
+    block(_ref16) {
       let {
         path,
         params,
@@ -8566,7 +8612,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         openStrip = DEFAULT_STRIP,
         inverseStrip = DEFAULT_STRIP,
         closeStrip = DEFAULT_STRIP
-      } = _ref4;
+      } = _ref16;
       return {
         type: 'BlockStatement',
         path: path,
@@ -8601,7 +8647,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    element(_ref5) {
+    element(_ref17) {
       let {
         tag,
         selfClosing,
@@ -8611,7 +8657,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         comments,
         children,
         loc
-      } = _ref5;
+      } = _ref17;
       return {
         type: 'ElementNode',
         tag,
@@ -8624,13 +8670,13 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    elementModifier(_ref6) {
+    elementModifier(_ref18) {
       let {
         path,
         params,
         hash,
         loc
-      } = _ref6;
+      } = _ref18;
       return {
         type: 'ElementModifierStatement',
         path,
@@ -8639,12 +8685,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    attr(_ref7) {
+    attr(_ref19) {
       let {
         name,
         value,
         loc
-      } = _ref7;
+      } = _ref19;
       return {
         type: 'AttrNode',
         name: name,
@@ -8652,24 +8698,24 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    text(_ref8) {
+    text(_ref20) {
       let {
         chars,
         loc
-      } = _ref8;
+      } = _ref20;
       return {
         type: 'TextNode',
         chars,
         loc
       };
     }
-    sexpr(_ref9) {
+    sexpr(_ref21) {
       let {
         path,
         params,
         hash,
         loc
-      } = _ref9;
+      } = _ref21;
       return {
         type: 'SubExpression',
         path,
@@ -8678,12 +8724,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    path(_ref10) {
+    path(_ref22) {
       let {
         head,
         tail,
         loc
-      } = _ref10;
+      } = _ref22;
       let {
         original: originalHead
       } = headToString(head);
@@ -8730,12 +8776,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    pair(_ref11) {
+    pair(_ref23) {
       let {
         key,
         value,
         loc
-      } = _ref11;
+      } = _ref23;
       return {
         type: 'HashPair',
         key: key,
@@ -8743,12 +8789,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       };
     }
-    literal(_ref12) {
+    literal(_ref24) {
       let {
         type,
         value,
         loc
-      } = _ref12;
+      } = _ref24;
       return {
         type,
         value,
@@ -8816,15 +8862,19 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
   }
   var b = new Builders();
   class Parser {
-    constructor(source) {
+    constructor(source, entityParser, mode) {
+      if (entityParser === void 0) {
+        entityParser = new _simpleHtmlTokenizer.EntityParser(_simpleHtmlTokenizer.HTML5NamedCharRefs);
+      }
+      if (mode === void 0) {
+        mode = 'precompile';
+      }
       this.elementStack = [];
       this.lines = void 0;
       this.source = void 0;
       this.currentAttribute = null;
       this.currentNode = null;
       this.tokenizer = void 0;
-      let entityParser = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _simpleHtmlTokenizer.EntityParser(_simpleHtmlTokenizer.HTML5NamedCharRefs);
-      let mode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'precompile';
       this.source = source;
       this.lines = source.source.split(/\r\n?|\n/u);
       this.tokenizer = new _simpleHtmlTokenizer.EventedTokenizer(this, entityParser, mode);
@@ -8836,11 +8886,11 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
       } = this.tokenizer;
       return this.source.offsetFor(line, column);
     }
-    pos(_ref) {
+    pos(_ref25) {
       let {
         line,
         column
-      } = _ref;
+      } = _ref25;
       return this.source.offsetFor(line, column);
     }
     finish(node) {
@@ -9632,8 +9682,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
       return undefined;
     }
   }
-  function preprocess(input) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  function preprocess(input, options) {
+    if (options === void 0) {
+      options = {};
+    }
     let mode = options.mode || 'precompile';
     let source;
     let ast;
@@ -9747,28 +9799,31 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
    * referenced that could possible come from the parent scope. Can exclude known keywords
    * optionally.
    */
-  function getTemplateLocals(html) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      includeHtmlElements: false,
-      includeKeywords: false
-    };
+  function getTemplateLocals(html, options) {
+    var _options;
+    if (options === void 0) {
+      options = {
+        includeHtmlElements: false,
+        includeKeywords: false
+      };
+    }
     const ast = preprocess(html);
     const tokensSet = new Set();
     const scopedTokens = [];
     traverse(ast, {
       Block: {
-        enter(_ref) {
+        enter(_ref26) {
           let {
             blockParams
-          } = _ref;
+          } = _ref26;
           blockParams.forEach(param => {
             scopedTokens.push(param);
           });
         },
-        exit(_ref2) {
+        exit(_ref27) {
           let {
             blockParams
-          } = _ref2;
+          } = _ref27;
           blockParams.forEach(() => {
             scopedTokens.pop();
           });
@@ -9781,10 +9836,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
           });
           addTokens(tokensSet, node, scopedTokens, options);
         },
-        exit(_ref3) {
+        exit(_ref28) {
           let {
             blockParams
-          } = _ref3;
+          } = _ref28;
           blockParams.forEach(() => {
             scopedTokens.pop();
           });
@@ -9796,7 +9851,7 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
     });
     let tokens = [];
     tokensSet.forEach(s => tokens.push(s));
-    if (!(options != null && options.includeKeywords)) {
+    if (!((_options = options) != null && _options.includeKeywords)) {
       tokens = tokens.filter(token => !isKeyword(token));
     }
     return tokens;
@@ -10269,8 +10324,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
      *
      * @see {NamespacedAmbiguity}
      */
-    static namespaced(namespace) {
-      let isAngleBracket = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    static namespaced(namespace, isAngleBracket) {
+      if (isAngleBracket === void 0) {
+        isAngleBracket = false;
+      }
       return new LooseModeResolution({
         namespaces: [namespace],
         fallback: false
@@ -10313,10 +10370,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
      *
      * @see {ComponentOrHelperAmbiguity}
      */
-    static append(_ref) {
+    static append(_ref29) {
       let {
         invoke
-      } = _ref;
+      } = _ref29;
       return new LooseModeResolution({
         namespaces: [FreeVarNamespace.Component, FreeVarNamespace.Helper],
         fallback: !invoke
@@ -10342,10 +10399,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
      *
      * @see {HelperAmbiguity}
      */
-    static trustingAppend(_ref2) {
+    static trustingAppend(_ref30) {
       let {
         invoke
-      } = _ref2;
+      } = _ref30;
       return new LooseModeResolution({
         namespaces: [FreeVarNamespace.Helper],
         fallback: !invoke
@@ -10371,8 +10428,10 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         fallback: true
       });
     }
-    constructor(ambiguity) {
-      let isAngleBracket = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    constructor(ambiguity, isAngleBracket) {
+      if (isAngleBracket === void 0) {
+        isAngleBracket = false;
+      }
       this.ambiguity = ambiguity;
       this.isAngleBracket = isAngleBracket;
     }
@@ -10784,12 +10843,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         entries
       });
     }
-    attr(_ref, loc) {
+    attr(_ref31, loc) {
       let {
         name,
         value,
         trusting
-      } = _ref;
+      } = _ref31;
       return new HtmlAttr({
         loc,
         name,
@@ -10803,12 +10862,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       });
     }
-    arg(_ref2, loc) {
+    arg(_ref32, loc) {
       let {
         name,
         value,
         trusting
-      } = _ref2;
+      } = _ref32;
       return new ComponentArg({
         name,
         value,
@@ -10843,13 +10902,13 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         symbol
       });
     }
-    freeVar(_ref3) {
+    freeVar(_ref33) {
       let {
         name,
         context,
         symbol,
         loc
-      } = _ref3;
+      } = _ref33;
       (0, _util.assert)(name !== 'this', "You called builders.freeVar() with 'this'. Call builders.this instead");
       (0, _util.assert)(name[0] !== '@', "You called builders.freeVar() with '" + name + "'. Call builders.at('" + name + "') instead");
       return new FreeVarReference({
@@ -10899,12 +10958,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
 
     // STATEMENTS //
 
-    append(_ref4, loc) {
+    append(_ref34, loc) {
       let {
         table,
         trusting,
         value
-      } = _ref4;
+      } = _ref34;
       return new AppendContent({
         table,
         trusting,
@@ -10912,11 +10971,11 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         loc
       });
     }
-    modifier(_ref5, loc) {
+    modifier(_ref35, loc) {
       let {
         callee,
         args
-      } = _ref5;
+      } = _ref35;
       return new ElementModifier({
         loc,
         callee,
@@ -10929,12 +10988,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         blocks
       });
     }
-    blockStatement(_ref6, loc) {
+    blockStatement(_ref36, loc) {
       let {
         program,
         inverse = null,
         ...call
-      } = _ref6;
+      } = _ref36;
       let blocksLoc = program.loc;
       let blocks = [this.namedBlock(SourceSlice.synthetic('default'), program, program.loc)];
       if (inverse) {
@@ -11111,11 +11170,13 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
   function isInvokeNode(node) {
     return node.params.length > 0 || node.hash.pairs.length > 0;
   }
-  function normalize(source) {
+  function normalize(source, options) {
     var _options$customizeCom;
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      lexicalScope: () => false
-    };
+    if (options === void 0) {
+      options = {
+        lexicalScope: () => false
+      };
+    }
     let ast = preprocess(source, options);
     let normalizeOptions = {
       strictMode: false,
@@ -11450,12 +11511,12 @@ define("@glimmer/syntax", ["exports", "ember-babel", "@glimmer/util", "@handleba
         inverse: inverse ? this.Block(inverse) : null
       }, callParts), loc);
     }
-    Block(_ref) {
+    Block(_ref37) {
       let {
         body,
         loc,
         blockParams
-      } = _ref;
+      } = _ref37;
       let child = this.block.child(blockParams);
       let normalizer = new StatementNormalizer(child);
       return new BlockChildren(this.block.loc(loc), body.map(b => normalizer.normalize(b)), this.block).assertBlock(child.table);
@@ -11900,7 +11961,6 @@ define("@glimmer/util", ["exports"], function (_exports) {
   _exports.exhausted = exhausted;
   _exports.expect = expect;
   _exports.extractHandle = extractHandle;
-  _exports.fillNulls = fillNulls;
   _exports.getFirst = getFirst;
   _exports.getLast = getLast;
   _exports.ifPresent = ifPresent;
@@ -11984,8 +12044,10 @@ define("@glimmer/util", ["exports"], function (_exports) {
     if (val === null || val === undefined) throw new Error(message);
     return val;
   }
-  function unreachable() {
-    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'unreachable';
+  function unreachable(message) {
+    if (message === void 0) {
+      message = 'unreachable';
+    }
     return new Error(message);
   }
   function exhausted(value) {
@@ -12023,14 +12085,18 @@ define("@glimmer/util", ["exports"], function (_exports) {
       return null;
     }
   }
-  function assertPresentArray(list) {
-    let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "unexpected empty list";
+  function assertPresentArray(list, message) {
+    if (message === void 0) {
+      message = "unexpected empty list";
+    }
     if (!isPresentArray(list)) {
       throw new Error(message);
     }
   }
-  function asPresentArray(list) {
-    let message = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "unexpected empty list";
+  function asPresentArray(list, message) {
+    if (message === void 0) {
+      message = "unexpected empty list";
+    }
     assertPresentArray(list, message);
     return list;
   }
@@ -12060,10 +12126,12 @@ define("@glimmer/util", ["exports"], function (_exports) {
     return typeof u === 'function' || typeof u === 'object' && u !== null;
   }
   class StackImpl {
-    constructor() {
+    constructor(values) {
+      if (values === void 0) {
+        values = [];
+      }
       this.stack = void 0;
       this.current = null;
-      let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       this.stack = values;
     }
     get size() {
@@ -12225,8 +12293,8 @@ define("@glimmer/util", ["exports"], function (_exports) {
     return value > ImmediateConstants.ENCODED_UNDEFINED_HANDLE;
   }
   function constants() {
-    for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {
-      values[_key] = arguments[_key];
+    for (var _len2 = arguments.length, values = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      values[_key2] = arguments[_key2];
     }
     return [false, true, null, undefined, ...values];
   }
@@ -12315,13 +12383,6 @@ define("@glimmer/util", ["exports"], function (_exports) {
     return node.nodeValue === SERIALIZATION_FIRST_NODE_STRING;
   }
   let assign = _exports.assign = Object.assign;
-  function fillNulls(count) {
-    let arr = new Array(count);
-    for (let i = 0; i < count; i++) {
-      arr[i] = null;
-    }
-    return arr;
-  }
   function values(obj) {
     return Object.values(obj);
   }
@@ -12408,8 +12469,8 @@ define("@glimmer/util", ["exports"], function (_exports) {
   }
   function strip(strings) {
     let out = '';
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
     }
     for (const [i, string] of enumerate(strings)) {
       let dynamic = args[i] !== undefined ? String(args[i]) : '';
@@ -12501,8 +12562,10 @@ define("@glimmer/util", ["exports"], function (_exports) {
    * actually appropriate.
    */
   const LOGGER = _exports.LOGGER = console;
-  function assertNever(value) {
-    let desc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'unexpected unreachable branch';
+  function assertNever(value, desc) {
+    if (desc === void 0) {
+      desc = 'unexpected unreachable branch';
+    }
     LOGGER.log('unreachable', value);
     LOGGER.log(desc + " :: " + JSON.stringify(value) + " (" + value + ")");
     throw new Error("code reached unreachable");
@@ -16498,7 +16561,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = _exports.default = "5.7.0-alpha.2";
+  var _default = _exports.default = "5.7.0-alpha.4";
 });
 define("simple-html-tokenizer", ["exports"], function (_exports) {
   "use strict";