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

package/dist/ember.debug.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 */
 /* globals global globalThis self */
@@ -2491,6 +2491,8 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   function installAttributeBinding(component, rootRef, parsed, operations) {
     let [prop, attribute, isSimple] = parsed;
     if (attribute === 'id') {
+      // SAFETY: `get` could not infer the type of `prop` and just gave us `unknown`.
+      //         we may want to throw an error in the future if the value isn't string or null/undefined.
       let elementId = (0, _metal.get)(component, prop);
       if (elementId === undefined || elementId === null) {
         elementId = component.elementId;
@@ -26274,19 +26276,12 @@ define("@glimmer/debug", ["exports", "@glimmer/util", "@glimmer/vm"], function (
   _exports.wrap = wrap;
   /* This file is generated by build/debug.js */
 
-  function fillNulls(count) {
-    let arr = new Array(count);
-    for (let i = 0; i < count; i++) {
-      arr[i] = null;
-    }
-    return arr;
-  }
   function opcodeMetadata(op, isMachine) {
     let value = isMachine ? MACHINE_METADATA[op] : METADATA[op];
     return value || null;
   }
-  const METADATA = fillNulls(_vm.Op.Size);
-  const MACHINE_METADATA = fillNulls(_vm.MachineOp.Size);
+  const METADATA = new Array(_vm.Op.Size).fill(null);
+  const MACHINE_METADATA = new Array(_vm.Op.Size).fill(null);
   MACHINE_METADATA[_vm.MachineOp.PushFrame] = {
     name: 'PushFrame',
     mnemonic: 'pushf',
@@ -27486,11 +27481,8 @@ define("@glimmer/debug", ["exports", "@glimmer/util", "@glimmer/vm"], function (
       predicate
     };
   }
-  function strip(strings) {
+  function strip(strings, ...args) {
     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 (let i = 0; i < strings.length; i++) {
       let string = strings[i];
       let dynamic = args[i] !== undefined ? String(args[i]) : '';
@@ -27499,8 +27491,7 @@ define("@glimmer/debug", ["exports", "@glimmer/util", "@glimmer/vm"], function (
 
     // eslint-disable-next-line regexp/no-super-linear-backtracking
     out = /^\s*?\n?([\s\S]*?)\s*$/u.exec(out)[1];
-    let min = 9007199254740991; // Number.MAX_SAFE_INTEGER isn't available on IE11
-
+    let min = Number.MAX_SAFE_INTEGER;
     for (let line of out.split('\n')) {
       let leading = /^\s*/u.exec(line)[0].length;
       min = Math.min(min, leading);
@@ -27645,14 +27636,10 @@ define("@glimmer/debug", ["exports", "@glimmer/util", "@glimmer/vm"], function (
     validate(obj) {
       if (typeof obj !== 'object') return false;
       if (obj === null || obj === undefined) return false;
-      return Object.entries(this.checkers).every(_ref => {
-        let [k, checker] = _ref;
-        return k in obj ? checker.validate(obj[k]) : false;
-      });
+      return Object.entries(this.checkers).every(([k, checker]) => k in obj ? checker.validate(obj[k]) : false);
     }
     expected() {
-      let pairs = Object.entries(this.checkers).map(_ref2 => {
-        let [k, checker] = _ref2;
+      let pairs = Object.entries(this.checkers).map(([k, checker]) => {
         return `${k}: ${checker.expected()}`;
       });
       return `{ ${pairs.join(',')} }`;
@@ -27740,8 +27727,7 @@ define("@glimmer/debug", ["exports", "@glimmer/util", "@glimmer/vm"], function (
   function defaultMessage(value, expected) {
     return `Got ${value}, expected:\n${expected}`;
   }
-  function check(value, checker) {
-    let message = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultMessage;
+  function check(value, checker, message = defaultMessage) {
     if (typeof checker === 'function') {
       checker(value);
       return value;
@@ -27774,8 +27760,7 @@ define("@glimmer/debug", ["exports", "@glimmer/util", "@glimmer/vm"], function (
   function CheckOr(left, right) {
     return new OrChecker(left, right);
   }
-  function CheckValue(value) {
-    let desc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : String(value);
+  function CheckValue(value, desc = String(value)) {
     return new ExactValueChecker(value, desc);
   }
   const CheckBlockSymbolTable = _exports.CheckBlockSymbolTable = CheckInterface({
@@ -27882,8 +27867,7 @@ define("@glimmer/destroyable", ["exports", "@glimmer/global-context", "@glimmer/
     childMeta.parents = push(childMeta.parents, parent);
     return child;
   }
-  function registerDestructor(destroyable, destructor) {
-    let eager = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  function registerDestructor(destroyable, destructor, eager = false) {
     if (true /* DEBUG */ && isDestroying(destroyable)) {
       throw new Error('Attempted to register a destructor with an object that is already destroying or destroyed');
     }
@@ -27892,8 +27876,7 @@ define("@glimmer/destroyable", ["exports", "@glimmer/global-context", "@glimmer/
     meta[destructorsKey] = push(meta[destructorsKey], destructor);
     return destructor;
   }
-  function unregisterDestructor(destroyable, destructor) {
-    let eager = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  function unregisterDestructor(destroyable, destructor, eager = false) {
     if (true /* DEBUG */ && isDestroying(destroyable)) {
       throw new Error('Attempted to unregister a destructor with an object that is already destroying or destroyed');
     }
@@ -27996,10 +27979,7 @@ define("@glimmer/encoder", ["exports", "@glimmer/vm"], function (_exports, _vm)
       this.size = 0;
       this.buffer = buffer;
     }
-    encode(type, machine) {
-      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-        args[_key - 2] = arguments[_key];
-      }
+    encode(type, machine, ...args) {
       if (type > _vm.TYPE_SIZE) {
         throw new Error(`Opcode type over 8-bits. Got ${type}.`);
       }
@@ -28403,8 +28383,7 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
     (0, _debug.check)(capabilities, _debug.CheckNumber);
     return !!(capabilities & capability);
   }
-  function helperCapabilities(managerAPI) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  function helperCapabilities(managerAPI, options = {}) {
     if (true /* DEBUG */ && managerAPI !== '3.23') {
       throw new Error('Invalid helper manager compatibility specified');
     }
@@ -28505,11 +28484,10 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
         args
       };
     }
-    getValue(_ref) {
-      let {
-        fn,
-        args
-      } = _ref;
+    getValue({
+      fn,
+      args
+    }) {
       if (Object.keys(args.named).length > 0) {
         let argsForFn = [...args.positional, args.named];
         return fn(...argsForFn);
@@ -28642,8 +28620,7 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
     willDestroy: false,
     hasSubOwner: false
   };
-  function componentCapabilities(managerAPI) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  function componentCapabilities(managerAPI, options = {}) {
     if (true /* DEBUG */ && managerAPI !== '3.13') {
       throw new Error('Invalid component manager compatibility specified');
     }
@@ -28736,31 +28713,28 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
         delegate.updateComponent(component, args);
       }
     }
-    didCreate(_ref) {
-      let {
-        component,
-        delegate
-      } = _ref;
+    didCreate({
+      component,
+      delegate
+    }) {
       if (hasAsyncLifeCycleCallbacks(delegate)) {
         delegate.didCreateComponent(component);
       }
     }
-    didUpdate(_ref2) {
-      let {
-        component,
-        delegate
-      } = _ref2;
+    didUpdate({
+      component,
+      delegate
+    }) {
       if (hasAsyncUpdateHook(delegate)) {
         delegate.didUpdateComponent(component);
       }
     }
     didRenderLayout() {}
     didUpdateLayout() {}
-    getSelf(_ref3) {
-      let {
-        component,
-        delegate
-      } = _ref3;
+    getSelf({
+      component,
+      delegate
+    }) {
       return (0, _reference.createConstRef)(delegate.getContext(component), 'this');
     }
     getDestroyable(bucket) {
@@ -28792,8 +28766,7 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
       this.args = args;
     }
   }
-  function modifierCapabilities(managerAPI) {
-    let optionalFeatures = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  function modifierCapabilities(managerAPI, optionalFeatures = {}) {
     if (true /* DEBUG */ && managerAPI !== '3.22') {
       throw new Error('Invalid modifier manager compatibility specified');
     }
@@ -28867,25 +28840,22 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
       (0, _destroyable.registerDestructor)(state, () => delegate.destroyModifier(instance, args));
       return state;
     }
-    getDebugName(_ref) {
-      let {
-        debugName
-      } = _ref;
+    getDebugName({
+      debugName
+    }) {
       return debugName;
     }
-    getTag(_ref2) {
-      let {
-        tag
-      } = _ref2;
+    getTag({
+      tag
+    }) {
       return tag;
     }
-    install(_ref3) {
-      let {
-        element,
-        args,
-        modifier,
-        delegate
-      } = _ref3;
+    install({
+      element,
+      args,
+      modifier,
+      delegate
+    }) {
       let {
         capabilities
       } = delegate;
@@ -28895,12 +28865,11 @@ define("@glimmer/manager", ["exports", "@glimmer/util", "@glimmer/destroyable",
         delegate.installModifier(modifier, (0, _util.castToBrowser)(element, 'ELEMENT'), args);
       }
     }
-    update(_ref4) {
-      let {
-        args,
-        modifier,
-        delegate
-      } = _ref4;
+    update({
+      args,
+      modifier,
+      delegate
+    }) {
       let {
         capabilities
       } = delegate;
@@ -29081,8 +29050,7 @@ define("@glimmer/node", ["exports", "@glimmer/runtime", "@simple-dom/document"],
       }
       return super.openElement(tag);
     }
-    pushRemoteElement(element, cursorId) {
-      let insertBefore = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    pushRemoteElement(element, cursorId, insertBefore = null) {
       let {
         dom
       } = this;
@@ -29151,8 +29119,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
    * <Foo></Foo>
    * <Foo @arg={{true}} />
    */
-  function resolveComponent(resolver, constants, meta, _ref) {
-    let [, expr, then] = _ref;
+  function resolveComponent(resolver, constants, meta, [, expr, then]) {
     (0, _util.assert)(isGetFreeComponent(expr), 'Attempted to resolve a component with incorrect opcode');
     let type = expr[0];
     if (true /* DEBUG */ && expr[0] === _wireFormat.SexpOpcodes.GetStrictKeyword) {
@@ -29183,8 +29150,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
    * (helper)
    * (helper arg)
    */
-  function resolveHelper(resolver, constants, meta, _ref2) {
-    let [, expr, then] = _ref2;
+  function resolveHelper(resolver, constants, meta, [, expr, then]) {
     (0, _util.assert)(isGetFreeHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
     let type = expr[0];
     if (type === _wireFormat.SexpOpcodes.GetLexicalSymbol) {
@@ -29214,8 +29180,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
    * <div {{modifier arg}}/>
    * <Foo {{modifier}}/>
    */
-  function resolveModifier(resolver, constants, meta, _ref3) {
-    let [, expr, then] = _ref3;
+  function resolveModifier(resolver, constants, meta, [, expr, then]) {
     (0, _util.assert)(isGetFreeModifier(expr), 'Attempted to resolve a modifier with incorrect opcode');
     let type = expr[0];
     if (type === _wireFormat.SexpOpcodes.GetLexicalSymbol) {
@@ -29251,11 +29216,10 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
   /**
    * {{component-or-helper arg}}
    */
-  function resolveComponentOrHelper(resolver, constants, meta, _ref4) {
-    let [, expr, {
-      ifComponent,
-      ifHelper
-    }] = _ref4;
+  function resolveComponentOrHelper(resolver, constants, meta, [, expr, {
+    ifComponent,
+    ifHelper
+  }]) {
     (0, _util.assert)(isGetFreeComponentOrHelper(expr), 'Attempted to resolve a component or helper with incorrect opcode');
     let type = expr[0];
     if (type === _wireFormat.SexpOpcodes.GetLexicalSymbol) {
@@ -29298,10 +29262,9 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
   /**
    * <Foo @arg={{helper}}>
    */
-  function resolveOptionalHelper(resolver, constants, meta, _ref5) {
-    let [, expr, {
-      ifHelper
-    }] = _ref5;
+  function resolveOptionalHelper(resolver, constants, meta, [, expr, {
+    ifHelper
+  }]) {
     (0, _util.assert)(isGetFreeOptionalHelper(expr) || isGetFreeDeprecatedHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
     let {
       upvars,
@@ -29317,12 +29280,11 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
   /**
    * {{maybeHelperOrComponent}}
    */
-  function resolveOptionalComponentOrHelper(resolver, constants, meta, _ref6) {
-    let [, expr, {
-      ifComponent,
-      ifHelper,
-      ifValue
-    }] = _ref6;
+  function resolveOptionalComponentOrHelper(resolver, constants, meta, [, expr, {
+    ifComponent,
+    ifHelper,
+    ifValue
+  }]) {
     (0, _util.assert)(isGetFreeOptionalComponentOrHelper(expr), 'Attempted to resolve an optional component or helper with incorrect opcode');
     let type = expr[0];
     if (type === _wireFormat.SexpOpcodes.GetLexicalSymbol) {
@@ -29564,7 +29526,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
         return handle;
       }
     }
-    push(constants, type) {
+    push(constants, type, ...args) {
       let {
         heap
       } = this;
@@ -29572,10 +29534,10 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
         throw new Error(`Opcode type over 8-bits. Got ${type}.`);
       }
       let machine = (0, _vm.isMachineOp)(type) ? _vm.MACHINE_MASK : 0;
-      let first = type | machine | (arguments.length <= 2 ? 0 : arguments.length - 2) << _vm.ARG_SHIFT;
+      let first = type | machine | args.length << _vm.ARG_SHIFT;
       heap.pushRaw(first);
-      for (let i = 0; i < (arguments.length <= 2 ? 0 : arguments.length - 2); i++) {
-        let op = i + 2 < 2 || arguments.length <= i + 2 ? undefined : arguments[i + 2];
+      for (let i = 0; i < args.length; i++) {
+        let op = args[i];
         heap.pushRaw(this.operand(constants, op));
       }
     }
@@ -29799,15 +29761,13 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
     }
   }
   const EXPRESSIONS = new Compilers();
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Concat, (op, _ref) => {
-    let [, parts] = _ref;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Concat, (op, [, parts]) => {
     for (let part of parts) {
       expr(op, part);
     }
     op(_vm.Op.Concat, parts.length);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Call, (op, _ref2) => {
-    let [, expression, positional, named] = _ref2;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Call, (op, [, expression, positional, named]) => {
     if (isGetFreeHelper(expression)) {
       op(HighLevelResolutionOpcodes.Helper, expression, handle => {
         Call(op, handle, positional, named);
@@ -29817,24 +29777,20 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       CallDynamic(op, positional, named);
     }
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Curry, (op, _ref3) => {
-    let [, expr, type, positional, named] = _ref3;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Curry, (op, [, expr, type, positional, named]) => {
     Curry(op, type, expr, positional, named);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetSymbol, (op, _ref4) => {
-    let [, sym, path] = _ref4;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetSymbol, (op, [, sym, path]) => {
     op(_vm.Op.GetVariable, sym);
     withPath(op, path);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetLexicalSymbol, (op, _ref5) => {
-    let [, sym, path] = _ref5;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetLexicalSymbol, (op, [, sym, path]) => {
     op(HighLevelResolutionOpcodes.TemplateLocal, sym, handle => {
       op(_vm.Op.ConstantReference, handle);
       withPath(op, path);
     });
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetStrictKeyword, (op, _ref6) => {
-    let [, sym, _path] = _ref6;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetStrictKeyword, (op, [, sym, _path]) => {
     op(HighLevelResolutionOpcodes.Free, sym, _handle => {
       // TODO: Implement in strict mode
     });
@@ -29880,38 +29836,32 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
     }
   }
   EXPRESSIONS.add(_wireFormat.SexpOpcodes.Undefined, op => PushPrimitiveReference(op, undefined));
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.HasBlock, (op, _ref7) => {
-    let [, block] = _ref7;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.HasBlock, (op, [, block]) => {
     expr(op, block);
     op(_vm.Op.HasBlock);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.HasBlockParams, (op, _ref8) => {
-    let [, block] = _ref8;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.HasBlockParams, (op, [, block]) => {
     expr(op, block);
     op(_vm.Op.SpreadBlock);
     op(_vm.Op.CompileBlock);
     op(_vm.Op.HasBlockParams);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.IfInline, (op, _ref9) => {
-    let [, condition, truthy, falsy] = _ref9;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.IfInline, (op, [, condition, truthy, falsy]) => {
     // Push in reverse order
     expr(op, falsy);
     expr(op, truthy);
     expr(op, condition);
     op(_vm.Op.IfInline);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Not, (op, _ref10) => {
-    let [, value] = _ref10;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Not, (op, [, value]) => {
     expr(op, value);
     op(_vm.Op.Not);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetDynamicVar, (op, _ref11) => {
-    let [, expression] = _ref11;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.GetDynamicVar, (op, [, expression]) => {
     expr(op, expression);
     op(_vm.Op.GetDynamicVar);
   });
-  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Log, (op, _ref12) => {
-    let [, positional] = _ref12;
+  EXPRESSIONS.add(_wireFormat.SexpOpcodes.Log, (op, [, positional]) => {
     op(_vm.MachineOp.PushFrame);
     SimpleArgs(op, positional, null, false);
     op(_vm.Op.Log);
@@ -30355,15 +30305,14 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       op(HighLevelBuilderOpcodes.Label, 'ELSE');
     });
   }
-  function InvokeStaticComponent(op, _ref) {
-    let {
-      capabilities,
-      layout,
-      elementBlock,
-      positional,
-      named,
-      blocks
-    } = _ref;
+  function InvokeStaticComponent(op, {
+    capabilities,
+    layout,
+    elementBlock,
+    positional,
+    named,
+    blocks
+  }) {
     let {
       symbolTable
     } = layout;
@@ -30526,16 +30475,15 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
     op(_vm.Op.CommitComponentTransaction);
     op(_vm.Op.Load, _vm.$s0);
   }
-  function InvokeNonStaticComponent(op, _ref2) {
-    let {
-      capabilities,
-      elementBlock,
-      positional,
-      named,
-      atNames,
-      blocks: namedBlocks,
-      layout
-    } = _ref2;
+  function InvokeNonStaticComponent(op, {
+    capabilities,
+    elementBlock,
+    positional,
+    named,
+    atNames,
+    blocks: namedBlocks,
+    layout
+  }) {
     let bindableBlocks = !!namedBlocks;
     let bindableAtNames = capabilities === true || (0, _manager.hasCapability)(capabilities, _vm.InternalComponentCapabilities.prepareArgs) || !!(named && named[0].length !== 0);
     let blocks = namedBlocks.with('attrs', elementBlock);
@@ -30580,8 +30528,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
     op(_vm.Op.Load, _vm.$s1);
     op(HighLevelBuilderOpcodes.StopLabels);
   }
-  function invokePreparedComponent(op, hasBlock, bindableBlocks, bindableAtNames) {
-    let populateLayout = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+  function invokePreparedComponent(op, hasBlock, bindableBlocks, bindableAtNames, populateLayout = null) {
     op(_vm.Op.BeginComponentTransaction, _vm.$s0);
     op(_vm.Op.PushDynamicScope);
     op(_vm.Op.CreateComponent, hasBlock | 0, _vm.$s0);
@@ -30709,10 +30656,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       resolver
     } = program;
     let encoder = new EncoderImpl(heap, STDLIB_META);
-    function pushOp() {
-      for (var _len = arguments.length, op = new Array(_len), _key = 0; _key < _len; _key++) {
-        op[_key] = arguments[_key];
-      }
+    function pushOp(...op) {
       encodeOp(encoder, constants, resolver, STDLIB_META, op);
     }
     builder(pushOp);
@@ -30725,14 +30669,13 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
     }
   }
   class CompileTimeCompilationContextImpl {
-    constructor(_ref, resolver, createOp) {
+    constructor({
+      constants,
+      heap
+    }, resolver, createOp) {
       this.constants = void 0;
       this.heap = void 0;
       this.stdlib = void 0;
-      let {
-        constants,
-        heap
-      } = _ref;
       this.resolver = resolver;
       this.createOp = createOp;
       this.constants = constants;
@@ -30764,8 +30707,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
   STATEMENTS.add(_wireFormat.SexpOpcodes.Comment, (op, sexp) => op(_vm.Op.Comment, sexp[1]));
   STATEMENTS.add(_wireFormat.SexpOpcodes.CloseElement, op => op(_vm.Op.CloseElement));
   STATEMENTS.add(_wireFormat.SexpOpcodes.FlushElement, op => op(_vm.Op.FlushElement));
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Modifier, (op, _ref) => {
-    let [, expression, positional, named] = _ref;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Modifier, (op, [, expression, positional, named]) => {
     if (isGetFreeModifier(expression)) {
       op(HighLevelResolutionOpcodes.Modifier, expression, handle => {
         op(_vm.MachineOp.PushFrame);
@@ -30782,45 +30724,36 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       op(_vm.MachineOp.PopFrame);
     }
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.StaticAttr, (op, _ref2) => {
-    let [, name, value, namespace] = _ref2;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.StaticAttr, (op, [, name, value, namespace]) => {
     op(_vm.Op.StaticAttr, inflateAttrName(name), value, namespace ?? null);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.StaticComponentAttr, (op, _ref3) => {
-    let [, name, value, namespace] = _ref3;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.StaticComponentAttr, (op, [, name, value, namespace]) => {
     op(_vm.Op.StaticComponentAttr, inflateAttrName(name), value, namespace ?? null);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.DynamicAttr, (op, _ref4) => {
-    let [, name, value, namespace] = _ref4;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.DynamicAttr, (op, [, name, value, namespace]) => {
     expr(op, value);
     op(_vm.Op.DynamicAttr, inflateAttrName(name), false, namespace ?? null);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.TrustingDynamicAttr, (op, _ref5) => {
-    let [, name, value, namespace] = _ref5;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.TrustingDynamicAttr, (op, [, name, value, namespace]) => {
     expr(op, value);
     op(_vm.Op.DynamicAttr, inflateAttrName(name), true, namespace ?? null);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.ComponentAttr, (op, _ref6) => {
-    let [, name, value, namespace] = _ref6;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.ComponentAttr, (op, [, name, value, namespace]) => {
     expr(op, value);
     op(_vm.Op.ComponentAttr, inflateAttrName(name), false, namespace ?? null);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.TrustingComponentAttr, (op, _ref7) => {
-    let [, name, value, namespace] = _ref7;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.TrustingComponentAttr, (op, [, name, value, namespace]) => {
     expr(op, value);
     op(_vm.Op.ComponentAttr, inflateAttrName(name), true, namespace ?? null);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.OpenElement, (op, _ref8) => {
-    let [, tag] = _ref8;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.OpenElement, (op, [, tag]) => {
     op(_vm.Op.OpenElement, inflateTagName(tag));
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.OpenElementWithSplat, (op, _ref9) => {
-    let [, tag] = _ref9;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.OpenElementWithSplat, (op, [, tag]) => {
     op(_vm.Op.PutComponentOperations);
     op(_vm.Op.OpenElement, inflateTagName(tag));
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Component, (op, _ref10) => {
-    let [, expr, elementBlock, named, blocks] = _ref10;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Component, (op, [, expr, elementBlock, named, blocks]) => {
     if (isGetFreeComponent(expr)) {
       op(HighLevelResolutionOpcodes.Component, expr, component => {
         InvokeComponent(op, component, elementBlock, null, named, blocks);
@@ -30831,20 +30764,10 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       InvokeDynamicComponent(op, expr, elementBlock, null, named, blocks, true, true);
     }
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Yield, (op, _ref11) => {
-    let [, to, params] = _ref11;
-    return YieldBlock(op, to, params);
-  });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.AttrSplat, (op, _ref12) => {
-    let [, to] = _ref12;
-    return YieldBlock(op, to, null);
-  });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Debugger, (op, _ref13) => {
-    let [, debugInfo] = _ref13;
-    return op(_vm.Op.Debugger, debugSymbolsOperand(), debugInfo);
-  });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Append, (op, _ref14) => {
-    let [, value] = _ref14;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, params));
+  STATEMENTS.add(_wireFormat.SexpOpcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null));
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Debugger, (op, [, debugInfo]) => op(_vm.Op.Debugger, debugSymbolsOperand(), debugInfo));
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Append, (op, [, value]) => {
     // Special case for static values
     if (!Array.isArray(value)) {
       op(_vm.Op.Text, value === null || value === undefined ? '' : String(value));
@@ -30911,8 +30834,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       op(_vm.MachineOp.PopFrame);
     }
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.TrustingAppend, (op, _ref15) => {
-    let [, value] = _ref15;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.TrustingAppend, (op, [, value]) => {
     if (!Array.isArray(value)) {
       op(_vm.Op.Text, value === null || value === undefined ? '' : String(value));
     } else {
@@ -30922,8 +30844,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       op(_vm.MachineOp.PopFrame);
     }
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Block, (op, _ref16) => {
-    let [, expr, positional, named, blocks] = _ref16;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Block, (op, [, expr, positional, named, blocks]) => {
     if (isGetFreeComponent(expr)) {
       op(HighLevelResolutionOpcodes.Component, expr, component => {
         InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
@@ -30932,8 +30853,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
     }
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.InElement, (op, _ref17) => {
-    let [, block, guid, destination, insertBefore] = _ref17;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.InElement, (op, [, block, guid, destination, insertBefore]) => {
     ReplayableIf(op, () => {
       expr(op, guid);
       if (insertBefore === undefined) {
@@ -30950,51 +30870,44 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       op(_vm.Op.PopRemoteElement);
     });
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.If, (op, _ref18) => {
-    let [, condition, block, inverse] = _ref18;
-    return ReplayableIf(op, () => {
-      expr(op, condition);
-      op(_vm.Op.ToBoolean);
-      return 1;
-    }, () => {
-      InvokeStaticBlock(op, block);
-    }, inverse ? () => {
+  STATEMENTS.add(_wireFormat.SexpOpcodes.If, (op, [, condition, block, inverse]) => ReplayableIf(op, () => {
+    expr(op, condition);
+    op(_vm.Op.ToBoolean);
+    return 1;
+  }, () => {
+    InvokeStaticBlock(op, block);
+  }, inverse ? () => {
+    InvokeStaticBlock(op, inverse);
+  } : undefined));
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Each, (op, [, value, key, block, inverse]) => Replayable(op, () => {
+    if (key) {
+      expr(op, key);
+    } else {
+      PushPrimitiveReference(op, null);
+    }
+    expr(op, value);
+    return 2;
+  }, () => {
+    op(_vm.Op.EnterList, labelOperand('BODY'), labelOperand('ELSE'));
+    op(_vm.MachineOp.PushFrame);
+    op(_vm.Op.Dup, _vm.$fp, 1);
+    op(_vm.MachineOp.ReturnTo, labelOperand('ITER'));
+    op(HighLevelBuilderOpcodes.Label, 'ITER');
+    op(_vm.Op.Iterate, labelOperand('BREAK'));
+    op(HighLevelBuilderOpcodes.Label, 'BODY');
+    InvokeStaticBlockWithStack(op, block, 2);
+    op(_vm.Op.Pop, 2);
+    op(_vm.MachineOp.Jump, labelOperand('FINALLY'));
+    op(HighLevelBuilderOpcodes.Label, 'BREAK');
+    op(_vm.MachineOp.PopFrame);
+    op(_vm.Op.ExitList);
+    op(_vm.MachineOp.Jump, labelOperand('FINALLY'));
+    op(HighLevelBuilderOpcodes.Label, 'ELSE');
+    if (inverse) {
       InvokeStaticBlock(op, inverse);
-    } : undefined);
-  });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Each, (op, _ref19) => {
-    let [, value, key, block, inverse] = _ref19;
-    return Replayable(op, () => {
-      if (key) {
-        expr(op, key);
-      } else {
-        PushPrimitiveReference(op, null);
-      }
-      expr(op, value);
-      return 2;
-    }, () => {
-      op(_vm.Op.EnterList, labelOperand('BODY'), labelOperand('ELSE'));
-      op(_vm.MachineOp.PushFrame);
-      op(_vm.Op.Dup, _vm.$fp, 1);
-      op(_vm.MachineOp.ReturnTo, labelOperand('ITER'));
-      op(HighLevelBuilderOpcodes.Label, 'ITER');
-      op(_vm.Op.Iterate, labelOperand('BREAK'));
-      op(HighLevelBuilderOpcodes.Label, 'BODY');
-      InvokeStaticBlockWithStack(op, block, 2);
-      op(_vm.Op.Pop, 2);
-      op(_vm.MachineOp.Jump, labelOperand('FINALLY'));
-      op(HighLevelBuilderOpcodes.Label, 'BREAK');
-      op(_vm.MachineOp.PopFrame);
-      op(_vm.Op.ExitList);
-      op(_vm.MachineOp.Jump, labelOperand('FINALLY'));
-      op(HighLevelBuilderOpcodes.Label, 'ELSE');
-      if (inverse) {
-        InvokeStaticBlock(op, inverse);
-      }
-    });
-  });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.With, (op, _ref20) => {
-    let [, value, block, inverse] = _ref20;
+    }
+  }));
+  STATEMENTS.add(_wireFormat.SexpOpcodes.With, (op, [, value, block, inverse]) => {
     ReplayableIf(op, () => {
       expr(op, value);
       op(_vm.Op.Dup, _vm.$sp, 0);
@@ -31008,13 +30921,11 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       }
     });
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.Let, (op, _ref21) => {
-    let [, positional, block] = _ref21;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.Let, (op, [, positional, block]) => {
     let count = CompilePositional(op, positional);
     InvokeStaticBlockWithStack(op, block, count);
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.WithDynamicVars, (op, _ref22) => {
-    let [, named, block] = _ref22;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.WithDynamicVars, (op, [, named, block]) => {
     if (named) {
       let [names, expressions] = named;
       CompilePositional(op, expressions);
@@ -31025,8 +30936,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
       InvokeStaticBlock(op, block);
     }
   });
-  STATEMENTS.add(_wireFormat.SexpOpcodes.InvokeComponent, (op, _ref23) => {
-    let [, expr, positional, named, blocks] = _ref23;
+  STATEMENTS.add(_wireFormat.SexpOpcodes.InvokeComponent, (op, [, expr, positional, named, blocks]) => {
     if (isGetFreeComponent(expr)) {
       op(HighLevelResolutionOpcodes.Component, expr, component => {
         InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
@@ -31044,9 +30954,10 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
   class CompilableTemplateImpl {
     constructor(statements, meta,
     // Part of CompilableTemplate
-    symbolTable) {
+    symbolTable,
+    // Used for debugging
+    moduleName = 'plain block') {
       this.compiled = null;
-      let moduleName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'plain block';
       this.statements = statements;
       this.meta = meta;
       this.symbolTable = symbolTable;
@@ -31086,10 +30997,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
         resolver
       }
     } = context;
-    function pushOp() {
-      for (var _len = arguments.length, op = new Array(_len), _key = 0; _key < _len; _key++) {
-        op[_key] = arguments[_key];
-      }
+    function pushOp(...op) {
       encodeOp(encoder, constants, resolver, meta, op);
     }
     for (const statement of statements) {
@@ -31169,10 +31077,7 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
           resolver
         }
       } = context;
-      function pushOp() {
-        for (var _len = arguments.length, op = new Array(_len), _key = 0; _key < _len; _key++) {
-          op[_key] = arguments[_key];
-        }
+      function pushOp(...op) {
         encodeOp(encoder, constants, resolver, m, op);
       }
       WrappedComponent(pushOp, this.layout, this.attrsBlockNumber);
@@ -31198,14 +31103,13 @@ define("@glimmer/opcode-compiler", ["exports", "@glimmer/util", "@glimmer/debug"
    * that handles lazy parsing the template and to create per env singletons
    * of the template.
    */
-  function templateFactory(_ref) {
-    let {
-      id: templateId,
-      moduleName,
-      block,
-      scope,
-      isStrictMode
-    } = _ref;
+  function templateFactory({
+    id: templateId,
+    moduleName,
+    block,
+    scope,
+    isStrictMode
+  }) {
     // TODO(template-refactors): This should be removed in the near future, as it
     // appears that id is unused. It is currently kept for backwards compat reasons.
     let id = templateId || `client-${clientId++}`;
@@ -31405,8 +31309,9 @@ define("@glimmer/program", ["exports", "@glimmer/manager", "@glimmer/opcode-comp
       this.modifierDefinitionCache = new WeakMap();
       this.componentDefinitionCache = new WeakMap();
     }
-    helper(definitionState) {
-      let isOptional = arguments.length > 2 ? arguments[2] : undefined;
+    helper(definitionState,
+    // TODO: Add a way to expose resolved name for debugging
+    _resolvedName = null, isOptional) {
       let handle = this.helperDefinitionCache.get(definitionState);
       if (handle === undefined) {
         let managerOrHelper = (0, _manager.getInternalHelperManager)(definitionState, isOptional);
@@ -31422,9 +31327,7 @@ define("@glimmer/program", ["exports", "@glimmer/manager", "@glimmer/opcode-comp
       }
       return handle;
     }
-    modifier(definitionState) {
-      let resolvedName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      let isOptional = arguments.length > 2 ? arguments[2] : undefined;
+    modifier(definitionState, resolvedName = null, isOptional) {
       let handle = this.modifierDefinitionCache.get(definitionState);
       if (handle === undefined) {
         let manager = (0, _manager.getInternalModifierManager)(definitionState, isOptional);
@@ -31713,8 +31616,7 @@ define("@glimmer/program", ["exports", "@glimmer/manager", "@glimmer/opcode-comp
       }
       this.offset = this.offset - compactedSize;
     }
-    capture() {
-      let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.offset;
+    capture(offset = this.offset) {
       // Only called in eager mode
       let buffer = slice(this.heap, 0, offset).buffer;
       return {
@@ -31835,9 +31737,7 @@ define("@glimmer/reference", ["exports", "@glimmer/global-context", "@glimmer/ut
     }
     return ref;
   }
-  function createComputeRef(compute) {
-    let update = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    let debugLabel = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'unknown';
+  function createComputeRef(compute, update = null, debugLabel = 'unknown') {
     const ref = new ReferenceImpl(COMPUTE);
     ref.compute = compute;
     ref.update = update;
@@ -32150,7 +32050,7 @@ define("@glimmer/reference", ["exports", "@glimmer/global-context", "@glimmer/ut
     }
   }
 });
-define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "@glimmer/util", "@glimmer/vm", "@glimmer/destroyable", "@glimmer/global-context", "@glimmer/validator", "@glimmer/manager", "@glimmer/program", "@glimmer/owner"], function (_exports, _debug, _reference, _util, _vm2, _destroyable, _globalContext, _validator, _manager, _program, _owner2) {
+define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "@glimmer/util", "@glimmer/vm", "@glimmer/destroyable", "@glimmer/global-context", "@glimmer/manager", "@glimmer/validator", "@glimmer/program", "@glimmer/owner"], function (_exports, _debug, _reference, _util, _vm2, _destroyable, _globalContext, _manager, _validator, _program, _owner2) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -32226,24 +32126,14 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   }
   _exports.DynamicScopeImpl = DynamicScopeImpl;
   class PartialScopeImpl {
-    static root(self) {
-      let size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      let owner = arguments.length > 2 ? arguments[2] : undefined;
-      let refs = new Array(size + 1);
-      for (let i = 0; i <= size; i++) {
-        refs[i] = _reference.UNDEFINED_REFERENCE;
-      }
+    static root(self, size = 0, owner) {
+      let refs = new Array(size + 1).fill(_reference.UNDEFINED_REFERENCE);
       return new PartialScopeImpl(refs, owner, null, null, null).init({
         self
       });
     }
-    static sized() {
-      let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-      let owner = arguments.length > 1 ? arguments[1] : undefined;
-      let refs = new Array(size + 1);
-      for (let i = 0; i <= size; i++) {
-        refs[i] = _reference.UNDEFINED_REFERENCE;
-      }
+    static sized(size = 0, owner) {
+      let refs = new Array(size + 1).fill(_reference.UNDEFINED_REFERENCE);
       return new PartialScopeImpl(refs, owner, null, null, null);
     }
     constructor(
@@ -32259,10 +32149,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       this.evalScope = evalScope;
       this.partialMap = partialMap;
     }
-    init(_ref) {
-      let {
-        self
-      } = _ref;
+    init({
+      self
+    }) {
       this.slots[0] = self;
       return this;
     }
@@ -32358,21 +32247,6 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
   }
   _exports.ConcreteBounds = ConcreteBounds;
-  class SingleNodeBounds {
-    constructor(parentNode, node) {
-      this.parentNode = parentNode;
-      this.node = node;
-    }
-    parentElement() {
-      return this.parentNode;
-    }
-    firstNode() {
-      return this.node;
-    }
-    lastNode() {
-      return this.node;
-    }
-  }
   function move(bounds, reference) {
     let parent = bounds.parentElement();
     let first = bounds.firstNode();
@@ -32526,46 +32400,49 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   function requiresSanitization(tagName, attribute) {
     return checkURI(tagName, attribute) || checkDataURI(tagName, attribute);
   }
-  let protocolForUrl;
-  if (typeof URL === 'object' && URL !== null &&
-  // this is super annoying, TS thinks that URL **must** be a function so `URL.parse` check
-  // thinks it is `never` without this `as unknown as any`
-  typeof URL.parse === 'function') {
-    // In Ember-land the `fastboot` package sets the `URL` global to `require('url')`
-    // ultimately, this should be changed (so that we can either rely on the natural `URL` global
-    // that exists) but for now we have to detect the specific `FastBoot` case first
-    //
-    // a future version of `fastboot` will detect if this legacy URL setup is required (by
-    // inspecting Ember version) and if new enough, it will avoid shadowing the `URL` global
-    // constructor with `require('url')`.
-    let nodeURL = URL;
-    protocolForUrl = url => {
-      let protocol = null;
-      if (typeof url === 'string') {
-        protocol = nodeURL.parse(url).protocol;
-      }
-      return protocol === null ? ':' : protocol;
-    };
-  } else if (typeof URL === 'function') {
-    protocolForUrl = _url => {
-      try {
-        let url = new URL(_url);
-        return url.protocol;
-      } catch (error) {
-        // any non-fully qualified url string will trigger an error (because there is no
-        // baseURI that we can provide; in that case we **know** that the protocol is
-        // "safe" because it isn't specifically one of the `badProtocols` listed above
-        // (and those protocols can never be the default baseURI)
-        return ':';
-      }
-    };
-  } else {
-    // fallback for IE11 support
-    let parsingNode = document.createElement('a');
-    protocolForUrl = url => {
-      parsingNode.href = url;
-      return parsingNode.protocol;
-    };
+  function findProtocolForURL() {
+    if (typeof URL === 'object' && URL !== null &&
+    // this is super annoying, TS thinks that URL **must** be a function so `URL.parse` check
+    // thinks it is `never` without this `as unknown as any`
+    typeof URL.parse === 'function') {
+      // In Ember-land the `fastboot` package sets the `URL` global to `require('url')`
+      // ultimately, this should be changed (so that we can either rely on the natural `URL` global
+      // that exists) but for now we have to detect the specific `FastBoot` case first
+      //
+      // a future version of `fastboot` will detect if this legacy URL setup is required (by
+      // inspecting Ember version) and if new enough, it will avoid shadowing the `URL` global
+      // constructor with `require('url')`.
+      let nodeURL = URL;
+      return url => {
+        let protocol = null;
+        if (typeof url === 'string') {
+          protocol = nodeURL.parse(url).protocol;
+        }
+        return protocol === null ? ':' : protocol;
+      };
+    } else if (typeof URL === 'function') {
+      return _url => {
+        try {
+          let url = new URL(_url);
+          return url.protocol;
+        } catch (error) {
+          // any non-fully qualified url string will trigger an error (because there is no
+          // baseURI that we can provide; in that case we **know** that the protocol is
+          // "safe" because it isn't specifically one of the `badProtocols` listed above
+          // (and those protocols can never be the default baseURI)
+          return ':';
+        }
+      };
+    } else {
+      throw new Error(`@glimmer/runtime needs a valid "globalThis.URL"`);
+    }
+  }
+  let _protocolForUrlImplementation;
+  function protocolForUrl(url) {
+    if (!_protocolForUrlImplementation) {
+      _protocolForUrlImplementation = findProtocolForURL();
+    }
+    return _protocolForUrlImplementation(url);
   }
   function sanitizeAttributeValue(element, attribute, value) {
     let tagName = null;
@@ -32592,8 +32469,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     return str;
   }
-  function dynamicAttribute(element, attr, namespace) {
-    let isTrusting = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  function dynamicAttribute(element, attr, namespace, isTrusting = false) {
     const {
       tagName,
       namespaceURI
@@ -32876,8 +32752,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     pushBlockList(list) {
       return this.pushLiveBlock(new LiveBlockList(this.element, list));
     }
-    pushLiveBlock(block) {
-      let isRemote = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    pushLiveBlock(block, isRemote = false) {
       let current = this.blockStack.current;
       if (current !== null) {
         if (!isRemote) {
@@ -32940,8 +32815,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       this.popBlock();
       this.popElement();
     }
-    pushElement(element) {
-      let nextSibling = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    pushElement(element, nextSibling = null) {
       this[CURSOR_STACK].push(new CursorImpl(element, nextSibling));
     }
     pushModifiers(modifiers) {
@@ -32989,7 +32863,8 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
         this.dom.insertBefore(this.element, fragment, this.nextSibling);
         return ret;
       } else {
-        return new SingleNodeBounds(this.element, this.__appendComment(''));
+        const comment = this.__appendComment('');
+        return new ConcreteBounds(this.element, comment, comment);
       }
     }
     __appendHTML(html) {
@@ -33010,7 +32885,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     appendDynamicNode(value) {
       let node = this.__appendNode(value);
-      let bounds = new SingleNodeBounds(this.element, node);
+      let bounds = new ConcreteBounds(this.element, node, node);
       this.didAppendBounds(bounds);
     }
     trustedContent(value) {
@@ -33180,10 +33055,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   }
   class AppendOpcodes {
     constructor() {
-      this.evaluateOpcode = (0, _util.fillNulls)(_vm2.Op.Size).slice();
+      this.evaluateOpcode = new Array(_vm2.Op.Size).fill(null);
     }
-    add(name, evaluate) {
-      let kind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'syscall';
+    add(name, evaluate, kind = 'syscall') {
       this.evaluateOpcode[name] = {
         syscall: kind !== 'machine',
         evaluate
@@ -33232,13 +33106,12 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   }
   class CurriedValue {
     /** @internal */
-    constructor(type, inner, owner, args) {
+    constructor(type, inner, owner, args, resolved = false) {
       this[TYPE] = void 0;
       this[INNER] = void 0;
       this[OWNER] = void 0;
       this[ARGS] = void 0;
       this[RESOLVED] = void 0;
-      let resolved = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
       CURRIED_VALUES.add(this);
       this[TYPE] = type;
       this[INNER] = inner;
@@ -33292,8 +33165,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       named
     };
   }
-  function curry(type, spec, owner, args) {
-    let resolved = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  function curry(type, spec, owner, args, resolved = false) {
     return new CurriedValue(type, spec, owner, args, resolved);
   }
   function createCurryRef(type, inner, owner, args, resolver, isStrict) {
@@ -33357,22 +33229,19 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   APPEND_OPCODES.add(_vm2.Op.PopScope, vm => vm.popScope());
   APPEND_OPCODES.add(_vm2.Op.PushDynamicScope, vm => vm.pushDynamicScope());
   APPEND_OPCODES.add(_vm2.Op.PopDynamicScope, vm => vm.popDynamicScope());
-  APPEND_OPCODES.add(_vm2.Op.Constant, (vm, _ref) => {
-    let {
-      op1: other
-    } = _ref;
+  APPEND_OPCODES.add(_vm2.Op.Constant, (vm, {
+    op1: other
+  }) => {
     vm.stack.push(vm[CONSTANTS].getValue((0, _util.decodeHandle)(other)));
   });
-  APPEND_OPCODES.add(_vm2.Op.ConstantReference, (vm, _ref2) => {
-    let {
-      op1: other
-    } = _ref2;
+  APPEND_OPCODES.add(_vm2.Op.ConstantReference, (vm, {
+    op1: other
+  }) => {
     vm.stack.push((0, _reference.createConstRef)(vm[CONSTANTS].getValue((0, _util.decodeHandle)(other)), false));
   });
-  APPEND_OPCODES.add(_vm2.Op.Primitive, (vm, _ref3) => {
-    let {
-      op1: primitive
-    } = _ref3;
+  APPEND_OPCODES.add(_vm2.Op.Primitive, (vm, {
+    op1: primitive
+  }) => {
     let stack = vm.stack;
     if ((0, _util.isHandle)(primitive)) {
       // it is a handle which does not already exist on the stack
@@ -33400,52 +33269,45 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     stack.push(ref);
   });
-  APPEND_OPCODES.add(_vm2.Op.Dup, (vm, _ref4) => {
-    let {
-      op1: register,
-      op2: offset
-    } = _ref4;
+  APPEND_OPCODES.add(_vm2.Op.Dup, (vm, {
+    op1: register,
+    op2: offset
+  }) => {
     let position = (0, _debug.check)(vm.fetchValue(register), _debug.CheckNumber) - offset;
     vm.stack.dup(position);
   });
-  APPEND_OPCODES.add(_vm2.Op.Pop, (vm, _ref5) => {
-    let {
-      op1: count
-    } = _ref5;
+  APPEND_OPCODES.add(_vm2.Op.Pop, (vm, {
+    op1: count
+  }) => {
     vm.stack.pop(count);
   });
-  APPEND_OPCODES.add(_vm2.Op.Load, (vm, _ref6) => {
-    let {
-      op1: register
-    } = _ref6;
+  APPEND_OPCODES.add(_vm2.Op.Load, (vm, {
+    op1: register
+  }) => {
     vm.load(register);
   });
-  APPEND_OPCODES.add(_vm2.Op.Fetch, (vm, _ref7) => {
-    let {
-      op1: register
-    } = _ref7;
+  APPEND_OPCODES.add(_vm2.Op.Fetch, (vm, {
+    op1: register
+  }) => {
     vm.fetch(register);
   });
-  APPEND_OPCODES.add(_vm2.Op.BindDynamicScope, (vm, _ref8) => {
-    let {
-      op1: _names
-    } = _ref8;
+  APPEND_OPCODES.add(_vm2.Op.BindDynamicScope, (vm, {
+    op1: _names
+  }) => {
     let names = vm[CONSTANTS].getArray(_names);
     vm.bindDynamicScope(names);
   });
-  APPEND_OPCODES.add(_vm2.Op.Enter, (vm, _ref9) => {
-    let {
-      op1: args
-    } = _ref9;
+  APPEND_OPCODES.add(_vm2.Op.Enter, (vm, {
+    op1: args
+  }) => {
     vm.enter(args);
   });
   APPEND_OPCODES.add(_vm2.Op.Exit, vm => {
     vm.exit();
   });
-  APPEND_OPCODES.add(_vm2.Op.PushSymbolTable, (vm, _ref10) => {
-    let {
-      op1: _table
-    } = _ref10;
+  APPEND_OPCODES.add(_vm2.Op.PushSymbolTable, (vm, {
+    op1: _table
+  }) => {
     let stack = vm.stack;
     stack.push(vm[CONSTANTS].getValue(_table));
   });
@@ -33494,10 +33356,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     vm.pushScope(invokingScope);
     vm.call(handle);
   });
-  APPEND_OPCODES.add(_vm2.Op.JumpIf, (vm, _ref11) => {
-    let {
-      op1: target
-    } = _ref11;
+  APPEND_OPCODES.add(_vm2.Op.JumpIf, (vm, {
+    op1: target
+  }) => {
     let reference = (0, _debug.check)(vm.stack.pop(), CheckReference);
     let value = Boolean((0, _reference.valueForRef)(reference));
     if ((0, _reference.isConstRef)(reference)) {
@@ -33511,10 +33372,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       vm.updateWith(new Assert(reference));
     }
   });
-  APPEND_OPCODES.add(_vm2.Op.JumpUnless, (vm, _ref12) => {
-    let {
-      op1: target
-    } = _ref12;
+  APPEND_OPCODES.add(_vm2.Op.JumpUnless, (vm, {
+    op1: target
+  }) => {
     let reference = (0, _debug.check)(vm.stack.pop(), CheckReference);
     let value = Boolean((0, _reference.valueForRef)(reference));
     if ((0, _reference.isConstRef)(reference)) {
@@ -33528,11 +33388,10 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       vm.updateWith(new Assert(reference));
     }
   });
-  APPEND_OPCODES.add(_vm2.Op.JumpEq, (vm, _ref13) => {
-    let {
-      op1: target,
-      op2: comparison
-    } = _ref13;
+  APPEND_OPCODES.add(_vm2.Op.JumpEq, (vm, {
+    op1: target,
+    op2: comparison
+  }) => {
     let other = (0, _debug.check)(vm.stack.peek(), _debug.CheckNumber);
     if (other === comparison) {
       vm.goto(target);
@@ -33631,22 +33490,19 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       this.target.didModify(tag);
     }
   }
-  APPEND_OPCODES.add(_vm2.Op.Text, (vm, _ref) => {
-    let {
-      op1: text
-    } = _ref;
+  APPEND_OPCODES.add(_vm2.Op.Text, (vm, {
+    op1: text
+  }) => {
     vm.elements().appendText(vm[CONSTANTS].getValue(text));
   });
-  APPEND_OPCODES.add(_vm2.Op.Comment, (vm, _ref2) => {
-    let {
-      op1: text
-    } = _ref2;
+  APPEND_OPCODES.add(_vm2.Op.Comment, (vm, {
+    op1: text
+  }) => {
     vm.elements().appendComment(vm[CONSTANTS].getValue(text));
   });
-  APPEND_OPCODES.add(_vm2.Op.OpenElement, (vm, _ref3) => {
-    let {
-      op1: tag
-    } = _ref3;
+  APPEND_OPCODES.add(_vm2.Op.OpenElement, (vm, {
+    op1: tag
+  }) => {
     vm.elements().openElement(vm[CONSTANTS].getValue(tag));
   });
   APPEND_OPCODES.add(_vm2.Op.OpenDynamicElement, vm => {
@@ -33683,24 +33539,19 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   });
   APPEND_OPCODES.add(_vm2.Op.CloseElement, vm => {
     let modifiers = vm.elements().closeElement();
-    if (modifiers) {
+    if (modifiers !== null) {
       modifiers.forEach(modifier => {
         vm.env.scheduleInstallModifier(modifier);
-        let {
-          manager,
-          state
-        } = modifier;
-        let d = manager.getDestroyable(state);
-        if (d) {
+        const d = modifier.manager.getDestroyable(modifier.state);
+        if (d !== null) {
           vm.associateDestroyable(d);
         }
       });
     }
   });
-  APPEND_OPCODES.add(_vm2.Op.Modifier, (vm, _ref4) => {
-    let {
-      op1: handle
-    } = _ref4;
+  APPEND_OPCODES.add(_vm2.Op.Modifier, (vm, {
+    op1: handle
+  }) => {
     if (vm.env.isInteractive === false) {
       return;
     }
@@ -33732,8 +33583,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       return;
     }
     let {
-      stack,
-      [CONSTANTS]: constants
+      stack
     } = vm;
     let ref = (0, _debug.check)(stack.pop(), CheckReference);
     let args = (0, _debug.check)(stack.pop(), CheckArguments).capture();
@@ -33767,14 +33617,19 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
         hostDefinition = value;
         owner = initialOwner;
       }
-      let handle = constants.modifier(hostDefinition, null, true);
-      if (true /* DEBUG */ && handle === null) {
-        throw new Error(`Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${(0, _util.debugToString)(hostDefinition)}`);
+      let manager = (0, _manager.getInternalModifierManager)(hostDefinition, true);
+      if (manager === null) {
+        if (true /* DEBUG */) {
+          throw new Error(`Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${(0, _util.debugToString)(hostDefinition)}`);
+        } else {
+          throw new Error('BUG: modifier manager expected');
+        }
       }
-      let definition = constants.getValue((0, _util.expect)(handle, 'BUG: modifier handle expected'));
-      let {
-        manager
-      } = definition;
+      let definition = {
+        resolvedName: null,
+        manager,
+        state: hostDefinition
+      };
       let state = manager.create(owner, (0, _util.expect)(constructing, 'BUG: ElementModifier could not find the element it applies to'), definition.state, args);
       return {
         manager,
@@ -33865,23 +33720,21 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       }
     }
   }
-  APPEND_OPCODES.add(_vm2.Op.StaticAttr, (vm, _ref5) => {
-    let {
-      op1: _name,
-      op2: _value,
-      op3: _namespace
-    } = _ref5;
+  APPEND_OPCODES.add(_vm2.Op.StaticAttr, (vm, {
+    op1: _name,
+    op2: _value,
+    op3: _namespace
+  }) => {
     let name = vm[CONSTANTS].getValue(_name);
     let value = vm[CONSTANTS].getValue(_value);
     let namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
     vm.elements().setStaticAttribute(name, value, namespace);
   });
-  APPEND_OPCODES.add(_vm2.Op.DynamicAttr, (vm, _ref6) => {
-    let {
-      op1: _name,
-      op2: _trusting,
-      op3: _namespace
-    } = _ref6;
+  APPEND_OPCODES.add(_vm2.Op.DynamicAttr, (vm, {
+    op1: _name,
+    op2: _trusting,
+    op3: _namespace
+  }) => {
     let name = vm[CONSTANTS].getValue(_name);
     let trusting = vm[CONSTANTS].getValue(_trusting);
     let reference = (0, _debug.check)(vm.stack.pop(), CheckReference);
@@ -33921,10 +33774,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
    * component type's ComponentDefinition.
    */
 
-  APPEND_OPCODES.add(_vm2.Op.PushComponentDefinition, (vm, _ref) => {
-    let {
-      op1: handle
-    } = _ref;
+  APPEND_OPCODES.add(_vm2.Op.PushComponentDefinition, (vm, {
+    op1: handle
+  }) => {
     let definition = vm[CONSTANTS].getValue(handle);
     (0, _util.assert)(!!definition, `Missing component for ${handle}`);
     let {
@@ -33942,10 +33794,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     };
     vm.stack.push(instance);
   });
-  APPEND_OPCODES.add(_vm2.Op.ResolveDynamicComponent, (vm, _ref2) => {
-    let {
-      op1: _isStrict
-    } = _ref2;
+  APPEND_OPCODES.add(_vm2.Op.ResolveDynamicComponent, (vm, {
+    op1: _isStrict
+  }) => {
     let stack = vm.stack;
     let component = (0, _debug.check)((0, _reference.valueForRef)((0, _debug.check)(stack.pop(), CheckReference)), (0, _debug.CheckOr)(_debug.CheckString, CheckCurriedComponentDefinition));
     let constants = vm[CONSTANTS];
@@ -34007,12 +33858,11 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       table: null
     });
   });
-  APPEND_OPCODES.add(_vm2.Op.PushArgs, (vm, _ref3) => {
-    let {
-      op1: _names,
-      op2: _blockNames,
-      op3: flags
-    } = _ref3;
+  APPEND_OPCODES.add(_vm2.Op.PushArgs, (vm, {
+    op1: _names,
+    op2: _blockNames,
+    op3: flags
+  }) => {
     let stack = vm.stack;
     let names = vm[CONSTANTS].getArray(_names);
     let positionalCount = flags >> 4;
@@ -34033,10 +33883,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     let capturedArgs = args.capture();
     stack.push(capturedArgs);
   });
-  APPEND_OPCODES.add(_vm2.Op.PrepareArgs, (vm, _ref4) => {
-    let {
-      op1: _state
-    } = _ref4;
+  APPEND_OPCODES.add(_vm2.Op.PrepareArgs, (vm, {
+    op1: _state
+  }) => {
     let stack = vm.stack;
     let instance = vm.fetchValue(_state);
     let args = (0, _debug.check)(stack.pop(), (0, _debug.CheckInstanceof)(VMArgumentsImpl));
@@ -34115,11 +33964,10 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     stack.push(args);
   });
-  APPEND_OPCODES.add(_vm2.Op.CreateComponent, (vm, _ref5) => {
-    let {
-      op1: flags,
-      op2: _state
-    } = _ref5;
+  APPEND_OPCODES.add(_vm2.Op.CreateComponent, (vm, {
+    op1: flags,
+    op2: _state
+  }) => {
     let instance = (0, _debug.check)(vm.fetchValue(_state), CheckComponentInstance);
     let {
       definition,
@@ -34154,10 +34002,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       vm.updateWith(new UpdateComponentOpcode(state, manager, dynamicScope));
     }
   });
-  APPEND_OPCODES.add(_vm2.Op.RegisterComponentDestructor, (vm, _ref6) => {
-    let {
-      op1: _state
-    } = _ref6;
+  APPEND_OPCODES.add(_vm2.Op.RegisterComponentDestructor, (vm, {
+    op1: _state
+  }) => {
     let {
       manager,
       state,
@@ -34169,10 +34016,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     if (d) vm.associateDestroyable(d);
   });
-  APPEND_OPCODES.add(_vm2.Op.BeginComponentTransaction, (vm, _ref7) => {
-    let {
-      op1: _state
-    } = _ref7;
+  APPEND_OPCODES.add(_vm2.Op.BeginComponentTransaction, (vm, {
+    op1: _state
+  }) => {
     let name;
     if (true /* DEBUG */) {
       let {
@@ -34187,24 +34033,22 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   APPEND_OPCODES.add(_vm2.Op.PutComponentOperations, vm => {
     vm.loadValue(_vm2.$t0, new ComponentElementOperations());
   });
-  APPEND_OPCODES.add(_vm2.Op.ComponentAttr, (vm, _ref8) => {
-    let {
-      op1: _name,
-      op2: _trusting,
-      op3: _namespace
-    } = _ref8;
+  APPEND_OPCODES.add(_vm2.Op.ComponentAttr, (vm, {
+    op1: _name,
+    op2: _trusting,
+    op3: _namespace
+  }) => {
     let name = vm[CONSTANTS].getValue(_name);
     let trusting = vm[CONSTANTS].getValue(_trusting);
     let reference = (0, _debug.check)(vm.stack.pop(), CheckReference);
     let namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
     (0, _debug.check)(vm.fetchValue(_vm2.$t0), (0, _debug.CheckInstanceof)(ComponentElementOperations)).setAttribute(name, reference, trusting, namespace);
   });
-  APPEND_OPCODES.add(_vm2.Op.StaticComponentAttr, (vm, _ref9) => {
-    let {
-      op1: _name,
-      op2: _value,
-      op3: _namespace
-    } = _ref9;
+  APPEND_OPCODES.add(_vm2.Op.StaticComponentAttr, (vm, {
+    op1: _name,
+    op2: _value,
+    op3: _namespace
+  }) => {
     let name = vm[CONSTANTS].getValue(_name);
     let value = vm[CONSTANTS].getValue(_value);
     let namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
@@ -34274,15 +34118,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     return createClassListRef(classes);
   }
   function allStringClasses(classes) {
-    for (let i = 0; i < classes.length; i++) {
-      if (typeof classes[i] !== 'string') {
-        return false;
-      }
-    }
-    return true;
+    return classes.every(c => typeof c === 'string');
   }
-  function setDeferredAttr(vm, name, value, namespace) {
-    let trusting = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  function setDeferredAttr(vm, name, value, namespace, trusting = false) {
     if (typeof value === 'string') {
       vm.elements().setStaticAttribute(name, value, namespace);
     } else {
@@ -34292,10 +34130,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       }
     }
   }
-  APPEND_OPCODES.add(_vm2.Op.DidCreateElement, (vm, _ref10) => {
-    let {
-      op1: _state
-    } = _ref10;
+  APPEND_OPCODES.add(_vm2.Op.DidCreateElement, (vm, {
+    op1: _state
+  }) => {
     let {
       definition,
       state
@@ -34306,11 +34143,10 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     let operations = (0, _debug.check)(vm.fetchValue(_vm2.$t0), (0, _debug.CheckInstanceof)(ComponentElementOperations));
     manager.didCreateElement(state, (0, _util.expect)(vm.elements().constructing, `Expected a constructing element in DidCreateOpcode`), operations);
   });
-  APPEND_OPCODES.add(_vm2.Op.GetComponentSelf, (vm, _ref11) => {
-    let {
-      op1: _state,
-      op2: _names
-    } = _ref11;
+  APPEND_OPCODES.add(_vm2.Op.GetComponentSelf, (vm, {
+    op1: _state,
+    op2: _names
+  }) => {
     let instance = (0, _debug.check)(vm.fetchValue(_state), CheckComponentInstance);
     let {
       definition,
@@ -34380,10 +34216,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     vm.stack.push(selfRef);
   });
-  APPEND_OPCODES.add(_vm2.Op.GetComponentTagName, (vm, _ref12) => {
-    let {
-      op1: _state
-    } = _ref12;
+  APPEND_OPCODES.add(_vm2.Op.GetComponentTagName, (vm, {
+    op1: _state
+  }) => {
     let {
       definition,
       state
@@ -34398,10 +34233,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   });
 
   // Dynamic Invocation Only
-  APPEND_OPCODES.add(_vm2.Op.GetComponentLayout, (vm, _ref13) => {
-    let {
-      op1: _state
-    } = _ref13;
+  APPEND_OPCODES.add(_vm2.Op.GetComponentLayout, (vm, {
+    op1: _state
+  }) => {
     let instance = (0, _debug.check)(vm.fetchValue(_state), CheckComponentInstance);
     let {
       manager,
@@ -34431,10 +34265,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     stack.push(compilable.symbolTable);
     stack.push(handle);
   });
-  APPEND_OPCODES.add(_vm2.Op.Main, (vm, _ref14) => {
-    let {
-      op1: register
-    } = _ref14;
+  APPEND_OPCODES.add(_vm2.Op.Main, (vm, {
+    op1: register
+  }) => {
     let definition = (0, _debug.check)(vm.stack.pop(), CheckComponentDefinition);
     let invocation = (0, _debug.check)(vm.stack.pop(), CheckInvocation);
     let {
@@ -34452,10 +34285,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     };
     vm.loadValue(register, state);
   });
-  APPEND_OPCODES.add(_vm2.Op.PopulateLayout, (vm, _ref15) => {
-    let {
-      op1: _state
-    } = _ref15;
+  APPEND_OPCODES.add(_vm2.Op.PopulateLayout, (vm, {
+    op1: _state
+  }) => {
     let {
       stack
     } = vm;
@@ -34467,10 +34299,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     state.handle = handle;
     state.table = table;
   });
-  APPEND_OPCODES.add(_vm2.Op.VirtualRootScope, (vm, _ref16) => {
-    let {
-      op1: _state
-    } = _ref16;
+  APPEND_OPCODES.add(_vm2.Op.VirtualRootScope, (vm, {
+    op1: _state
+  }) => {
     let {
       table,
       manager,
@@ -34497,20 +34328,18 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     vm.pushRootScope(table.symbols.length + 1, owner);
   });
-  APPEND_OPCODES.add(_vm2.Op.SetupForEval, (vm, _ref17) => {
-    let {
-      op1: _state
-    } = _ref17;
+  APPEND_OPCODES.add(_vm2.Op.SetupForEval, (vm, {
+    op1: _state
+  }) => {
     let state = (0, _debug.check)(vm.fetchValue(_state), CheckFinishedComponentInstance);
     if (state.table.hasEval) {
       let lookup = state.lookup = (0, _util.dict)();
       vm.scope().bindEvalScope(lookup);
     }
   });
-  APPEND_OPCODES.add(_vm2.Op.SetNamedVariables, (vm, _ref18) => {
-    let {
-      op1: _state
-    } = _ref18;
+  APPEND_OPCODES.add(_vm2.Op.SetNamedVariables, (vm, {
+    op1: _state
+  }) => {
     let state = (0, _debug.check)(vm.fetchValue(_state), CheckFinishedComponentInstance);
     let scope = vm.scope();
     let args = (0, _debug.check)(vm.stack.peek(), CheckArguments);
@@ -34529,10 +34358,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
     if (state.lookup) state.lookup[symbolName] = block;
   }
-  APPEND_OPCODES.add(_vm2.Op.SetBlocks, (vm, _ref19) => {
-    let {
-      op1: _state
-    } = _ref19;
+  APPEND_OPCODES.add(_vm2.Op.SetBlocks, (vm, {
+    op1: _state
+  }) => {
     let state = (0, _debug.check)(vm.fetchValue(_state), CheckFinishedComponentInstance);
     let {
       blocks
@@ -34543,17 +34371,15 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   });
 
   // Dynamic Invocation Only
-  APPEND_OPCODES.add(_vm2.Op.InvokeComponentLayout, (vm, _ref20) => {
-    let {
-      op1: _state
-    } = _ref20;
+  APPEND_OPCODES.add(_vm2.Op.InvokeComponentLayout, (vm, {
+    op1: _state
+  }) => {
     let state = (0, _debug.check)(vm.fetchValue(_state), CheckFinishedComponentInstance);
     vm.call(state.handle);
   });
-  APPEND_OPCODES.add(_vm2.Op.DidRenderLayout, (vm, _ref21) => {
-    let {
-      op1: _state
-    } = _ref21;
+  APPEND_OPCODES.add(_vm2.Op.DidRenderLayout, (vm, {
+    op1: _state
+  }) => {
     let instance = (0, _debug.check)(vm.fetchValue(_state), CheckComponentInstance);
     let {
       manager,
@@ -34925,8 +34751,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     has(name) {
       return this.names.indexOf(name) !== -1;
     }
-    get(name) {
-      let atNames = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    get(name, atNames = false) {
       let {
         base,
         stack
@@ -35118,11 +34943,11 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   const EMPTY_ARGS = _exports.EMPTY_ARGS = createCapturedArgs(EMPTY_NAMED, EMPTY_POSITIONAL);
   function createConcatRef(partsRefs) {
     return (0, _reference.createComputeRef)(() => {
-      let parts = new Array();
-      for (const [i, ref] of (0, _util.enumerate)(partsRefs)) {
-        let value = (0, _reference.valueForRef)(ref);
+      const parts = [];
+      for (const ref of partsRefs) {
+        const value = (0, _reference.valueForRef)(ref);
         if (value !== null && value !== undefined) {
-          parts[i] = castToString(value);
+          parts.push(castToString(value));
         }
       }
       if (parts.length > 0) {
@@ -35132,16 +34957,17 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     });
   }
   function castToString(value) {
-    if (typeof value.toString !== 'function') {
+    if (typeof value === 'string') {
+      return value;
+    } else if (typeof value.toString !== 'function') {
       return '';
     }
     return String(value);
   }
-  APPEND_OPCODES.add(_vm2.Op.Curry, (vm, _ref) => {
-    let {
-      op1: type,
-      op2: _isStrict
-    } = _ref;
+  APPEND_OPCODES.add(_vm2.Op.Curry, (vm, {
+    op1: type,
+    op2: _isStrict
+  }) => {
     let stack = vm.stack;
     let definition = (0, _debug.check)(stack.pop(), CheckReference);
     let capturedArgs = (0, _debug.check)(stack.pop(), CheckCapturedArguments);
@@ -35172,7 +34998,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
           positional,
           named
         } = resolveCurriedValue(definition);
-        let helper = resolveHelper(vm[CONSTANTS], resolvedDef, ref);
+        let helper = resolveHelper(resolvedDef, ref);
         if (named !== undefined) {
           args.named = (0, _util.assign)({}, ...named, args.named);
         }
@@ -35182,7 +35008,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
         helperRef = helper(args, owner);
         (0, _destroyable.associateDestroyableChild)(helperInstanceRef, helperRef);
       } else if ((0, _util.isObject)(definition)) {
-        let helper = resolveHelper(vm[CONSTANTS], definition, ref);
+        let helper = resolveHelper(definition, ref);
         helperRef = helper(args, initialOwner);
         if ((0, _destroyable._hasDestroyableChildren)(helperRef)) {
           (0, _destroyable.associateDestroyableChild)(helperInstanceRef, helperRef);
@@ -35198,17 +35024,23 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     vm.associateDestroyable(helperInstanceRef);
     vm.loadValue(_vm2.$v0, helperValueRef);
   });
-  function resolveHelper(constants, definition, ref) {
-    let handle = constants.helper(definition, null, true);
-    if (true /* DEBUG */ && handle === null) {
+  function resolveHelper(definition, ref) {
+    let managerOrHelper = (0, _manager.getInternalHelperManager)(definition, true);
+    let helper;
+    if (managerOrHelper === null) {
+      helper = null;
+    } else {
+      helper = typeof managerOrHelper === 'function' ? managerOrHelper : managerOrHelper.getHelper(definition);
+      (0, _util.assert)(managerOrHelper, 'BUG: expected manager or helper');
+    }
+    if (true /* DEBUG */ && helper === null) {
       throw new Error(`Expected a dynamic helper definition, but received an object or function that did not have a helper manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\` or \`(${ref.debugLabel})\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${(0, _util.debugToString)(definition)}`);
     }
-    return constants.getValue(handle);
+    return helper;
   }
-  APPEND_OPCODES.add(_vm2.Op.Helper, (vm, _ref2) => {
-    let {
-      op1: handle
-    } = _ref2;
+  APPEND_OPCODES.add(_vm2.Op.Helper, (vm, {
+    op1: handle
+  }) => {
     let stack = vm.stack;
     let helper = (0, _debug.check)(vm[CONSTANTS].getValue(handle), CheckHelper);
     let args = (0, _debug.check)(stack.pop(), CheckArguments);
@@ -35218,33 +35050,29 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     vm.loadValue(_vm2.$v0, value);
   });
-  APPEND_OPCODES.add(_vm2.Op.GetVariable, (vm, _ref3) => {
-    let {
-      op1: symbol
-    } = _ref3;
+  APPEND_OPCODES.add(_vm2.Op.GetVariable, (vm, {
+    op1: symbol
+  }) => {
     let expr = vm.referenceForSymbol(symbol);
     vm.stack.push(expr);
   });
-  APPEND_OPCODES.add(_vm2.Op.SetVariable, (vm, _ref4) => {
-    let {
-      op1: symbol
-    } = _ref4;
+  APPEND_OPCODES.add(_vm2.Op.SetVariable, (vm, {
+    op1: symbol
+  }) => {
     let expr = (0, _debug.check)(vm.stack.pop(), CheckReference);
     vm.scope().bindSymbol(symbol, expr);
   });
-  APPEND_OPCODES.add(_vm2.Op.SetBlock, (vm, _ref5) => {
-    let {
-      op1: symbol
-    } = _ref5;
+  APPEND_OPCODES.add(_vm2.Op.SetBlock, (vm, {
+    op1: symbol
+  }) => {
     let handle = (0, _debug.check)(vm.stack.pop(), CheckCompilableBlock);
     let scope = (0, _debug.check)(vm.stack.pop(), CheckScope);
     let table = (0, _debug.check)(vm.stack.pop(), _debug.CheckBlockSymbolTable);
     vm.scope().bindBlock(symbol, [handle, scope, table]);
   });
-  APPEND_OPCODES.add(_vm2.Op.ResolveMaybeLocal, (vm, _ref6) => {
-    let {
-      op1: _name
-    } = _ref6;
+  APPEND_OPCODES.add(_vm2.Op.ResolveMaybeLocal, (vm, {
+    op1: _name
+  }) => {
     let name = vm[CONSTANTS].getValue(_name);
     let locals = vm.scope().getPartialMap();
     let ref = locals[name];
@@ -35253,24 +35081,21 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
     vm.stack.push(ref);
   });
-  APPEND_OPCODES.add(_vm2.Op.RootScope, (vm, _ref7) => {
-    let {
-      op1: symbols
-    } = _ref7;
+  APPEND_OPCODES.add(_vm2.Op.RootScope, (vm, {
+    op1: symbols
+  }) => {
     vm.pushRootScope(symbols, vm.getOwner());
   });
-  APPEND_OPCODES.add(_vm2.Op.GetProperty, (vm, _ref8) => {
-    let {
-      op1: _key
-    } = _ref8;
+  APPEND_OPCODES.add(_vm2.Op.GetProperty, (vm, {
+    op1: _key
+  }) => {
     let key = vm[CONSTANTS].getValue(_key);
     let expr = (0, _debug.check)(vm.stack.pop(), CheckReference);
     vm.stack.push((0, _reference.childRefFor)(expr, key));
   });
-  APPEND_OPCODES.add(_vm2.Op.GetBlock, (vm, _ref9) => {
-    let {
-      op1: _block
-    } = _ref9;
+  APPEND_OPCODES.add(_vm2.Op.GetBlock, (vm, {
+    op1: _block
+  }) => {
     let {
       stack
     } = vm;
@@ -35318,10 +35143,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     let hasBlockParams = table && table.parameters.length;
     vm.stack.push(hasBlockParams ? _reference.TRUE_REFERENCE : _reference.FALSE_REFERENCE);
   });
-  APPEND_OPCODES.add(_vm2.Op.Concat, (vm, _ref10) => {
-    let {
-      op1: count
-    } = _ref10;
+  APPEND_OPCODES.add(_vm2.Op.Concat, (vm, {
+    op1: count
+  }) => {
     let out = new Array(count);
     for (let i = count; i > 0; i--) {
       let offset = i - 1;
@@ -35517,21 +35341,19 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       return tail.reduce((r, part) => (0, _reference.childRefFor)(r, part), ref);
     }
   }
-  APPEND_OPCODES.add(_vm2.Op.Debugger, (vm, _ref) => {
-    let {
-      op1: _symbols,
-      op2: _debugInfo
-    } = _ref;
+  APPEND_OPCODES.add(_vm2.Op.Debugger, (vm, {
+    op1: _symbols,
+    op2: _debugInfo
+  }) => {
     let symbols = vm[CONSTANTS].getArray(_symbols);
     let debugInfo = vm[CONSTANTS].getArray((0, _util.decodeHandle)(_debugInfo));
     let inspector = new ScopeInspector(vm.scope(), symbols, debugInfo);
     callback((0, _reference.valueForRef)(vm.getSelf()), path => (0, _reference.valueForRef)(inspector.get(path)));
   });
-  APPEND_OPCODES.add(_vm2.Op.EnterList, (vm, _ref) => {
-    let {
-      op1: relativeStart,
-      op2: elseTarget
-    } = _ref;
+  APPEND_OPCODES.add(_vm2.Op.EnterList, (vm, {
+    op1: relativeStart,
+    op2: elseTarget
+  }) => {
     let stack = vm.stack;
     let listRef = (0, _debug.check)(stack.pop(), CheckReference);
     let keyRef = (0, _debug.check)(stack.pop(), CheckReference);
@@ -35551,10 +35373,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   APPEND_OPCODES.add(_vm2.Op.ExitList, vm => {
     vm.exitList();
   });
-  APPEND_OPCODES.add(_vm2.Op.Iterate, (vm, _ref2) => {
-    let {
-      op1: breaks
-    } = _ref2;
+  APPEND_OPCODES.add(_vm2.Op.Iterate, (vm, {
+    op1: breaks
+  }) => {
     let stack = vm.stack;
     let iterator = (0, _debug.check)(stack.peek(), CheckIterator);
     let item = iterator.next();
@@ -35583,10 +35404,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     getCapabilities() {
       return CAPABILITIES;
     }
-    getDebugName(_ref) {
-      let {
-        name
-      } = _ref;
+    getDebugName({
+      name
+    }) {
       return name;
     }
     getSelf() {
@@ -35601,9 +35421,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
 
   // This is only exported for types, don't use this class directly
   class TemplateOnlyComponentDefinition {
-    constructor() {
-      let moduleName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '@glimmer/component/template-only';
-      let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '(unknown template-only component)';
+    constructor(moduleName = '@glimmer/component/template-only', name = '(unknown template-only component)') {
       this.moduleName = moduleName;
       this.name = name;
     }
@@ -35874,8 +35692,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     createElementNS(namespace, tag) {
       return this.document.createElementNS(namespace, tag);
     }
-    setAttribute(element, name, value) {
-      let namespace = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    setAttribute(element, name, value, namespace = null) {
       if (namespace) {
         element.setAttributeNS(namespace, name, value);
       } else {
@@ -36065,10 +35882,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
         children
       };
     }
-    captureTemplate(_ref) {
-      let {
-        template
-      } = _ref;
+    captureTemplate({
+      template
+    }) {
       return template || null;
     }
     captureBounds(node) {
@@ -36268,10 +36084,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
      @public
    */
 
-  const array = _exports.array = internalHelper(_ref => {
-    let {
-      positional
-    } = _ref;
+  const array = _exports.array = internalHelper(({
+    positional
+  }) => {
     return (0, _reference.createComputeRef)(() => reifyPositional(positional), null, 'array');
   });
   const isEmpty$1 = value => {
@@ -36304,10 +36119,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     @public
     @method concat
   */
-  const concat = _exports.concat = internalHelper(_ref => {
-    let {
-      positional
-    } = _ref;
+  const concat = _exports.concat = internalHelper(({
+    positional
+  }) => {
     return (0, _reference.createComputeRef)(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
   });
   const context = (0, _util.buildUntouchableThis)('`fn` helper');
@@ -36376,18 +36190,14 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     @method fn
     @public
   */
-  const fn = _exports.fn = internalHelper(_ref => {
-    let {
-      positional
-    } = _ref;
+  const fn = _exports.fn = internalHelper(({
+    positional
+  }) => {
     let callbackRef = (0, _debug.check)(positional[0], assertCallbackIsFn);
     return (0, _reference.createComputeRef)(() => {
-      return function () {
+      return (...invocationArgs) => {
         let [fn, ...args] = reifyPositional(positional);
         if (true /* DEBUG */) assertCallbackIsFn(callbackRef);
-        for (var _len = arguments.length, invocationArgs = new Array(_len), _key = 0; _key < _len; _key++) {
-          invocationArgs[_key] = arguments[_key];
-        }
         if ((0, _reference.isInvokableRef)(callbackRef)) {
           let value = args.length > 0 ? args[0] : invocationArgs[0];
           return (0, _reference.updateRef)(callbackRef, value);
@@ -36480,10 +36290,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     @public
     @method get
    */
-  const get = _exports.get = internalHelper(_ref => {
-    let {
-      positional
-    } = _ref;
+  const get = _exports.get = internalHelper(({
+    positional
+  }) => {
     let sourceRef = positional[0] ?? _reference.UNDEFINED_REFERENCE;
     let pathRef = positional[1] ?? _reference.UNDEFINED_REFERENCE;
     return (0, _reference.createComputeRef)(() => {
@@ -36549,10 +36358,9 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
      @return {Object} Hash
      @public
    */
-  const hash = _exports.hash = internalHelper(_ref => {
-    let {
-      named
-    } = _ref;
+  const hash = _exports.hash = internalHelper(({
+    named
+  }) => {
     let ref = (0, _reference.createComputeRef)(() => {
       let hash = reifyNamed(named);
       if (true /* DEBUG */) {
@@ -36575,9 +36383,8 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     return (0, _validator.getValue)(true /* DEBUG */ ? ARGS_CACHES.get(proxy) : proxy.argsCache);
   }
   class SimpleArgsProxy {
-    constructor(context) {
+    constructor(context, computeArgs = () => EMPTY_ARGS) {
       this.argsCache = void 0;
-      let computeArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => EMPTY_ARGS;
       let argsCache = (0, _validator.createCache)(() => computeArgs(context));
       if (true /* DEBUG */) {
         ARGS_CACHES.set(this, argsCache);
@@ -36632,40 +36439,6 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     return cache;
   }
   const untouchableContext = (0, _util.buildUntouchableThis)('`on` modifier');
-
-  /*
-    Internet Explorer 11 does not support `once` and also does not support
-    passing `eventOptions`. In some situations it then throws a weird script
-    error, like:
-  
-    ```
-    Could not complete the operation due to error 80020101
-    ```
-  
-    This flag determines, whether `{ once: true }` and thus also event options in
-    general are supported.
-  */
-  const SUPPORTS_EVENT_OPTIONS = (() => {
-    try {
-      const div = document.createElement('div');
-      let counter = 0;
-      div.addEventListener('click', () => counter++, {
-        once: true
-      });
-      let event;
-      if (typeof Event === 'function') {
-        event = new Event('click');
-      } else {
-        event = document.createEvent('Event');
-        event.initEvent('click', true, true);
-      }
-      div.dispatchEvent(event);
-      div.dispatchEvent(event);
-      return counter === 1;
-    } catch (error) {
-      return false;
-    }
-  })();
   class OnModifierState {
     constructor(element, args) {
       this.tag = (0, _validator.createUpdatableTag)();
@@ -36700,11 +36473,11 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
         this.capture = capture;
         this.shouldUpdate = true;
       }
-      let options;
+
       // we want to handle both `true` and `false` because both have a meaning:
       // https://bugs.chromium.org/p/chromium/issues/detail?id=770208
       if (once !== undefined || passive !== undefined || capture !== undefined) {
-        options = this.options = {
+        this.options = {
           once,
           passive,
           capture
@@ -36729,19 +36502,16 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       if (true /* DEBUG */ && args.positional.length !== 2) {
         throw new Error(`You can only pass two positional arguments (event name and callback) to the \`on\` modifier, but you provided ${args.positional.length}. Consider using the \`fn\` helper to provide additional arguments to the \`on\` callback.`);
       }
-      let needsCustomCallback = SUPPORTS_EVENT_OPTIONS === false && once /* needs manual once implementation */ || true /* DEBUG */ && passive; /* needs passive enforcement */
+      let needsCustomCallback = true /* DEBUG */ && passive; /* needs passive enforcement */
 
       if (this.shouldUpdate) {
         if (needsCustomCallback) {
-          let callback = this.callback = function (event) {
+          this.callback = function (event) {
             if (true /* DEBUG */ && passive) {
               event.preventDefault = () => {
                 throw new Error(`You marked this listener as 'passive', meaning that you must not call 'event.preventDefault()': \n\n${userProvidedCallback.name ?? `{anonymous function}`}`);
               };
             }
-            if (!SUPPORTS_EVENT_OPTIONS && once) {
-              removeEventListener(this, eventName, callback, options);
-            }
             return userProvidedCallback.call(untouchableContext, event);
           };
         } else if (true /* DEBUG */) {
@@ -36757,45 +36527,11 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
   let removes = 0;
   function removeEventListener(element, eventName, callback, options) {
     removes++;
-    if (SUPPORTS_EVENT_OPTIONS) {
-      // when options are supported, use them across the board
-      element.removeEventListener(eventName, callback, options);
-    } else if (options !== undefined && options.capture) {
-      // used only in the following case:
-      //
-      // `{ once: true | false, passive: true | false, capture: true }
-      //
-      // `once` is handled via a custom callback that removes after first
-      // invocation so we only care about capture here as a boolean
-      element.removeEventListener(eventName, callback, true);
-    } else {
-      // used only in the following cases:
-      //
-      // * where there is no options
-      // * `{ once: true | false, passive: true | false, capture: false }
-      element.removeEventListener(eventName, callback);
-    }
+    element.removeEventListener(eventName, callback, options);
   }
   function addEventListener(element, eventName, callback, options) {
     adds++;
-    if (SUPPORTS_EVENT_OPTIONS) {
-      // when options are supported, use them across the board
-      element.addEventListener(eventName, callback, options);
-    } else if (options !== undefined && options.capture) {
-      // used only in the following case:
-      //
-      // `{ once: true | false, passive: true | false, capture: true }
-      //
-      // `once` is handled via a custom callback that removes after first
-      // invocation so we only care about capture here as a boolean
-      element.addEventListener(eventName, callback, true);
-    } else {
-      // used only in the following cases:
-      //
-      // * where there is no options
-      // * `{ once: true | false, passive: true | false, capture: false }
-      element.addEventListener(eventName, callback);
-    }
+    element.addEventListener(eventName, callback, options);
   }
 
   /**
@@ -36885,9 +36621,6 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     @public
   */
   class OnModifierManager {
-    constructor() {
-      this.SUPPORTS_EVENT_OPTIONS = SUPPORTS_EVENT_OPTIONS;
-    }
     getDebugName() {
       return 'on';
     }
@@ -37073,14 +36806,13 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     }
   }
   class UpdatingVM {
-    constructor(env, _ref) {
+    constructor(env, {
+      alwaysRevalidate = false
+    }) {
       this.env = void 0;
       this.dom = void 0;
       this.alwaysRevalidate = void 0;
       this.frameStack = new _util.Stack();
-      let {
-        alwaysRevalidate = false
-      } = _ref;
       this.env = env;
       this.dom = env.getDOM();
       this.alwaysRevalidate = alwaysRevalidate;
@@ -37414,12 +37146,11 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       (0, _destroyable.associateDestroyableChild)(this, drop);
       (0, _destroyable.registerDestructor)(this, () => clear(this.bounds));
     }
-    rerender() {
-      let {
-        alwaysRevalidate = false
-      } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-        alwaysRevalidate: false
-      };
+    rerender({
+      alwaysRevalidate = false
+    } = {
+      alwaysRevalidate: false
+    }) {
       let {
         env,
         updating
@@ -37447,39 +37178,32 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       return new this(snapshot.slice(), initializeRegistersWithSP(snapshot.length - 1));
     }
     // fp -> sp
-    constructor() {
+    constructor(stack = [], registers) {
       this[REGISTERS] = void 0;
-      let stack = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      let registers = arguments.length > 1 ? arguments[1] : undefined;
       this.stack = stack;
       this[REGISTERS] = registers;
     }
     push(value) {
       this.stack[++this[REGISTERS][_vm2.$sp]] = value;
     }
-    dup() {
-      let position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this[REGISTERS][_vm2.$sp];
+    dup(position = this[REGISTERS][_vm2.$sp]) {
       this.stack[++this[REGISTERS][_vm2.$sp]] = this.stack[position];
     }
     copy(from, to) {
       this.stack[to] = this.stack[from];
     }
-    pop() {
-      let n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+    pop(n = 1) {
       let top = this.stack[this[REGISTERS][_vm2.$sp]];
       this[REGISTERS][_vm2.$sp] -= n;
       return top;
     }
-    peek() {
-      let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    peek(offset = 0) {
       return this.stack[this[REGISTERS][_vm2.$sp] - offset];
     }
-    get(offset) {
-      let base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[REGISTERS][_vm2.$fp];
+    get(offset, base = this[REGISTERS][_vm2.$fp]) {
       return this.stack[base + offset];
     }
-    set(value, offset) {
-      let base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this[REGISTERS][_vm2.$fp];
+    set(value, offset, base = this[REGISTERS][_vm2.$fp]) {
       this.stack[base + offset] = value;
     }
     slice(start, end) {
@@ -37617,7 +37341,12 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
      * End of migrated.
      */
 
-    constructor(runtime, _ref, elementStack, context) {
+    constructor(runtime, {
+      pc,
+      scope,
+      dynamicScope,
+      stack
+    }, elementStack, context) {
       this[STACKS] = new Stacks();
       this[HEAP] = void 0;
       this.destructor = void 0;
@@ -37631,12 +37360,6 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       this.t1 = null;
       this.v0 = null;
       this.resume = void 0;
-      let {
-        pc,
-        scope,
-        dynamicScope,
-        stack
-      } = _ref;
       this.runtime = runtime;
       this.elementStack = elementStack;
       this.context = context;
@@ -37666,28 +37389,26 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       this.destructor = {};
       this[DESTROYABLE_STACK].push(this.destructor);
     }
-    static initial(runtime, context, _ref2) {
-      let {
-        handle,
-        self,
-        dynamicScope,
-        treeBuilder,
-        numSymbols,
-        owner
-      } = _ref2;
+    static initial(runtime, context, {
+      handle,
+      self,
+      dynamicScope,
+      treeBuilder,
+      numSymbols,
+      owner
+    }) {
       let scope = PartialScopeImpl.root(self, numSymbols, owner);
       let state = vmState(runtime.program.heap.getaddr(handle), scope, dynamicScope);
       let vm = initVM(context)(runtime, state, treeBuilder);
       vm.pushUpdating();
       return vm;
     }
-    static empty(runtime, _ref3, context) {
-      let {
-        handle,
-        treeBuilder,
-        dynamicScope,
-        owner
-      } = _ref3;
+    static empty(runtime, {
+      handle,
+      treeBuilder,
+      dynamicScope,
+      owner
+    }, context) {
       let vm = initVM(context)(runtime, vmState(runtime.program.heap.getaddr(handle), PartialScopeImpl.root(_reference.UNDEFINED_REFERENCE, 0, owner), dynamicScope), treeBuilder);
       vm.pushUpdating();
       return vm;
@@ -37702,8 +37423,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     get env() {
       return this.runtime.env;
     }
-    captureState(args) {
-      let pc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[INNER_VM].fetchRegister(_vm2.$pc);
+    captureState(args, pc = this[INNER_VM].fetchRegister(_vm2.$pc)) {
       return {
         pc,
         scope: this.scope(),
@@ -37711,8 +37431,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
         stack: this.stack.capture(args)
       };
     }
-    capture(args) {
-      let pc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[INNER_VM].fetchRegister(_vm2.$pc);
+    capture(args, pc = this[INNER_VM].fetchRegister(_vm2.$pc)) {
       return new ResumableVMStateImpl(this.captureState(args, pc), this.resume);
     }
     beginCacheGroup(name) {
@@ -37737,12 +37456,11 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       let tryOpcode = new TryOpcode(state, this.runtime, block, updating);
       this.didEnter(tryOpcode);
     }
-    enterItem(_ref4) {
-      let {
-        key,
-        value,
-        memo
-      } = _ref4;
+    enterItem({
+      key,
+      value,
+      memo
+    }) {
       let {
         stack
       } = this;
@@ -37783,8 +37501,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       this.exit();
       this[STACKS].list.pop();
     }
-    pushUpdating() {
-      let list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    pushUpdating(list = []) {
       this[STACKS].updating.push(list);
     }
     popUpdating() {
@@ -37947,8 +37664,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     inTransaction(env, () => result = iterator.sync());
     return result;
   }
-  function renderMain(runtime, context, owner, self, treeBuilder, layout) {
-    let dynamicScope = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new DynamicScopeImpl();
+  function renderMain(runtime, context, owner, self, treeBuilder, layout, dynamicScope = new DynamicScopeImpl()) {
     let handle = (0, _util.unwrapHandle)(layout.compile(context));
     let numSymbols = layout.symbolTable.symbols.length;
     let vm = VM.initial(runtime, context, {
@@ -37967,10 +37683,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     const argList = Object.keys(args).map(key => [key, args[key]]);
     const blockNames = ['main', 'else', 'attrs'];
     // Prefix argument names with `@` symbol
-    const argNames = argList.map(_ref => {
-      let [name] = _ref;
-      return `@${name}`;
-    });
+    const argNames = argList.map(([name]) => `@${name}`);
     let reified = vm[CONSTANTS].component(definition, owner);
     vm.pushFrame();
 
@@ -37981,8 +37694,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     vm.stack.push(null);
 
     // For each argument, push its backing reference on to the stack
-    argList.forEach(_ref2 => {
-      let [, reference] = _ref2;
+    argList.forEach(([, reference]) => {
       vm.stack.push(reference);
     });
 
@@ -38002,9 +37714,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
     vm.stack.push(reified);
     return new TemplateIteratorImpl(vm);
   }
-  function renderComponent(runtime, treeBuilder, context, owner, definition) {
-    let args = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
-    let dynamicScope = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new DynamicScopeImpl();
+  function renderComponent(runtime, treeBuilder, context, owner, definition, args = {}, dynamicScope = new DynamicScopeImpl()) {
     let vm = VM.empty(runtime, {
       treeBuilder,
       handle: context.stdlib.main,
@@ -38103,8 +37813,7 @@ define("@glimmer/runtime", ["exports", "@glimmer/debug", "@glimmer/reference", "
       currentCursor.candidate = candidate;
       currentCursor.nextSibling = null;
     }
-    pushElement(element) {
-      let nextSibling = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    pushElement(element, nextSibling = null) {
       const cursor = new RehydratingCursor(element, nextSibling, this.blockDepth || 0);
 
       /**
@@ -38544,7 +38253,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;
@@ -38628,19 +38336,13 @@ 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 = 'unreachable') {
     return new Error(message);
   }
   function exhausted(value) {
     throw new Error(`Exhausted ${String(value)}`);
   }
-  const tuple = function () {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return args;
-  };
+  const tuple = (...args) => args;
   _exports.tuple = tuple;
   function isPresent(value) {
     return value !== null && value !== undefined;
@@ -38667,14 +38369,12 @@ 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 = `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 = `unexpected empty list`) {
     assertPresentArray(list, message);
     return list;
   }
@@ -38704,10 +38404,9 @@ define("@glimmer/util", ["exports"], function (_exports) {
     return typeof u === 'function' || typeof u === 'object' && u !== null;
   }
   class StackImpl {
-    constructor() {
+    constructor(values = []) {
       this.stack = void 0;
       this.current = null;
-      let values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       this.stack = values;
     }
     get size() {
@@ -38867,10 +38566,7 @@ define("@glimmer/util", ["exports"], function (_exports) {
   function isNonPrimitiveHandle(value) {
     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];
-    }
+  function constants(...values) {
     return [false, true, null, undefined, ...values];
   }
   function isSmallInt(value) {
@@ -38958,13 +38654,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);
   }
@@ -39048,11 +38737,8 @@ define("@glimmer/util", ["exports"], function (_exports) {
         return node instanceof Element && node.tagName.toLowerCase() === check;
     }
   }
-  function strip(strings) {
+  function strip(strings, ...args) {
     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 (const [i, string] of enumerate(strings)) {
       let dynamic = args[i] !== undefined ? String(args[i]) : '';
       out += `${string}${dynamic}`;
@@ -39143,8 +38829,7 @@ 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 = 'unexpected unreachable branch') {
     LOGGER.log('unreachable', value);
     LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`);
     throw new Error(`code reached unreachable`);
@@ -39186,7 +38871,6 @@ define("@glimmer/validator", ["exports", "@glimmer/global-context", "@glimmer/ut
     return input;
   }
   function getGlobal() {
-    // eslint-disable-next-line n/no-unsupported-features/es-builtins
     if (typeof globalThis !== 'undefined') return indexable(globalThis);
     if (typeof self !== 'undefined') return indexable(self);
     if (typeof window !== 'undefined') return indexable(window);
@@ -39280,8 +38964,7 @@ define("@glimmer/validator", ["exports", "@glimmer/global-context", "@glimmer/ut
       }
     };
 
-    let nthIndex = function (str, pattern, n) {
-      let startingPos = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+    let nthIndex = (str, pattern, n, startingPos = -1) => {
       let i = startingPos;
       while (n-- > 0 && i++ < str.length) {
         i = str.indexOf(pattern, i);
@@ -39306,9 +38989,7 @@ define("@glimmer/validator", ["exports", "@glimmer/global-context", "@glimmer/ut
         }
         current = current.parent;
       }
-
-      // TODO: Use String.prototype.repeat here once we can drop support for IE11
-      return trackingStack.map((label, index) => Array(2 * index + 1).join(' ') + label).join('\n');
+      return trackingStack.map((label, index) => ' '.repeat(2 * index) + label).join('\n');
     };
     debug.markTagAsConsumed = _tag => {
       if (!CONSUMED_TAGS || CONSUMED_TAGS.has(_tag)) return;
@@ -39461,18 +39142,18 @@ define("@glimmer/validator", ["exports", "@glimmer/global-context", "@glimmer/ut
           } = this;
           if (subtag !== null) {
             if (Array.isArray(subtag)) {
-              for (const tag of subtag) {
-                let value = tag[COMPUTE]();
-                revision = Math.max(value, revision);
-              }
+              revision = subtag.reduce((prev, currentTag) => {
+                let current = currentTag[COMPUTE]();
+                return current > prev ? current : prev;
+              }, revision);
             } else {
               let subtagValue = subtag[COMPUTE]();
               if (subtagValue === this.subtagBufferCache) {
-                revision = Math.max(revision, this.lastValue);
+                revision = revision > this.lastValue ? revision : this.lastValue;
               } else {
                 // Clear the temporary buffer cache
                 this.subtagBufferCache = null;
-                revision = Math.max(revision, subtagValue);
+                revision = revision > subtagValue ? revision : subtagValue;
               }
             }
           }
@@ -39666,9 +39347,7 @@ define("@glimmer/validator", ["exports", "@glimmer/global-context", "@glimmer/ut
       } else if (tags.size === 1) {
         return this.last;
       } else {
-        let tagsArr = [];
-        tags.forEach(tag => tagsArr.push(tag));
-        return combine(tagsArr);
+        return combine(Array.from(this.tags));
       }
     }
   }
@@ -43520,7 +43199,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("route-recognizer", ["exports"], function (_exports) {
   "use strict";