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

package/dist/dependencies/@glimmer/runtime.js

@@ -1,13 +1,13 @@
 import { check, CheckPrimitive, CheckNumber, CheckOption, CheckHandle, CheckBlockSymbolTable, CheckInstanceof, CheckString, CheckElement, CheckMaybe, CheckNode, CheckOr, CheckProgramSymbolTable, CheckInterface, CheckFunction, wrap, CheckArray, CheckDict, CheckUnknown, CheckObject, CheckSafeString, CheckDocumentFragment, recordStackSize } from '@glimmer/debug';
 import { createConstRef, createPrimitiveRef, valueForRef, isConstRef, createComputeRef, UNDEFINED_REFERENCE, createDebugAliasRef, childRefFor, TRUE_REFERENCE, FALSE_REFERENCE, createIteratorRef, NULL_REFERENCE, REFERENCE, isInvokableRef, updateRef, createIteratorItemRef } from '@glimmer/reference';
-import { decodeHandle, isHandle, decodeImmediate, assert, expect, unwrap, isObject, assign, debugToString, EMPTY_STRING_ARRAY, dict, unwrapTemplate, enumerate, emptyArray, castToSimple, buildUntouchableThis, NS_SVG, castToBrowser, Stack, clearElement, INSERT_AFTER_BEGIN, INSERT_BEFORE_END, isDict, unwrapHandle, reverse, COMMENT_NODE, fillNulls, INSERT_BEFORE_BEGIN } from '@glimmer/util';
+import { decodeHandle, isHandle, decodeImmediate, assert, expect, unwrap, isObject, assign, debugToString, EMPTY_STRING_ARRAY, dict, unwrapTemplate, enumerate, emptyArray, castToSimple, buildUntouchableThis, NS_SVG, castToBrowser, Stack, clearElement, INSERT_AFTER_BEGIN, INSERT_BEFORE_END, isDict, unwrapHandle, reverse, COMMENT_NODE, INSERT_BEFORE_BEGIN } from '@glimmer/util';
 import { Op, $t0, CurriedTypes, $t1, InternalComponentCapabilities, $sp, $v0, ContentType, CurriedType, $pc, isLowLevelRegister, $s1, $s0, $fp, $ra, MachineOp } from '@glimmer/vm';
 import { destroy, associateDestroyableChild, registerDestructor, _hasDestroyableChildren, isDestroying, isDestroyed, destroyChildren } from '@glimmer/destroyable';
 export { destroy, isDestroyed, isDestroying, registerDestructor } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
 import { toBool, warnIfStyleNotTrusted, getPath, setPath, assertGlobalContextWasSet, deprecate } from '@glimmer/global-context';
+import { getInternalModifierManager, managerHasCapability, getInternalHelperManager, setInternalComponentManager, setInternalModifierManager, hasInternalComponentManager, hasInternalHelperManager, setInternalHelperManager, hasValue, hasDestroyable } from '@glimmer/manager';
 import { consumeTag, valueForTag, validateTag, CURRENT_TAG, COMPUTE, CONSTANT_TAG, createCache, debug, resetTracking, beginTrackFrame, endTrackFrame, track, updateTag, createUpdatableTag, INITIAL, getValue } from '@glimmer/validator';
-import { managerHasCapability, setInternalComponentManager, setInternalModifierManager, hasInternalComponentManager, hasInternalHelperManager, setInternalHelperManager, getInternalHelperManager, hasValue, hasDestroyable } from '@glimmer/manager';
 import { RuntimeProgramImpl } from '@glimmer/program';
 import { getOwner } from '@glimmer/owner';
 
@@ -31,24 +31,14 @@ class 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] = UNDEFINED_REFERENCE;
-    }
+  static root(self, size = 0, owner) {
+    let refs = new Array(size + 1).fill(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] = UNDEFINED_REFERENCE;
-    }
+  static sized(size = 0, owner) {
+    let refs = new Array(size + 1).fill(UNDEFINED_REFERENCE);
     return new PartialScopeImpl(refs, owner, null, null, null);
   }
   constructor(
@@ -64,10 +54,9 @@ class PartialScopeImpl {
     this.evalScope = evalScope;
     this.partialMap = partialMap;
   }
-  init(_ref) {
-    let {
-      self
-    } = _ref;
+  init({
+    self
+  }) {
     this.slots[0] = self;
     return this;
   }
@@ -162,21 +151,6 @@ class ConcreteBounds {
     return this.last;
   }
 }
-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();
@@ -332,46 +306,49 @@ function checkDataURI(tagName, attribute) {
 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;
@@ -399,8 +376,7 @@ function sanitizeAttributeValue(element, attribute, value) {
   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
@@ -682,8 +658,7 @@ class NewElementBuilder {
   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) {
@@ -746,8 +721,7 @@ class NewElementBuilder {
     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) {
@@ -795,7 +769,8 @@ class NewElementBuilder {
       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) {
@@ -816,7 +791,7 @@ class NewElementBuilder {
   }
   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) {
@@ -983,9 +958,8 @@ function clientBuilder(env, cursor) {
 }
 
 class AppendOpcodes {
-  evaluateOpcode = fillNulls(Op.Size).slice();
-  add(name, evaluate) {
-    let kind = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'syscall';
+  evaluateOpcode = new Array(Op.Size).fill(null);
+  add(name, evaluate, kind = 'syscall') {
     this.evaluateOpcode[name] = {
       syscall: kind !== 'machine',
       evaluate
@@ -1042,8 +1016,7 @@ class CurriedValue {
   [RESOLVED];
 
   /** @internal */
-  constructor(type, inner, owner, args) {
-    let resolved = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  constructor(type, inner, owner, args, resolved = false) {
     CURRIED_VALUES.add(this);
     this[TYPE] = type;
     this[INNER] = inner;
@@ -1096,8 +1069,7 @@ function resolveCurriedValue(curriedValue) {
     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);
 }
 
@@ -1166,22 +1138,19 @@ APPEND_OPCODES.add(Op.ChildScope, vm => vm.pushChildScope());
 APPEND_OPCODES.add(Op.PopScope, vm => vm.popScope());
 APPEND_OPCODES.add(Op.PushDynamicScope, vm => vm.pushDynamicScope());
 APPEND_OPCODES.add(Op.PopDynamicScope, vm => vm.popDynamicScope());
-APPEND_OPCODES.add(Op.Constant, (vm, _ref) => {
-  let {
-    op1: other
-  } = _ref;
+APPEND_OPCODES.add(Op.Constant, (vm, {
+  op1: other
+}) => {
   vm.stack.push(vm[CONSTANTS].getValue(decodeHandle(other)));
 });
-APPEND_OPCODES.add(Op.ConstantReference, (vm, _ref2) => {
-  let {
-    op1: other
-  } = _ref2;
+APPEND_OPCODES.add(Op.ConstantReference, (vm, {
+  op1: other
+}) => {
   vm.stack.push(createConstRef(vm[CONSTANTS].getValue(decodeHandle(other)), false));
 });
-APPEND_OPCODES.add(Op.Primitive, (vm, _ref3) => {
-  let {
-    op1: primitive
-  } = _ref3;
+APPEND_OPCODES.add(Op.Primitive, (vm, {
+  op1: primitive
+}) => {
   let stack = vm.stack;
   if (isHandle(primitive)) {
     // it is a handle which does not already exist on the stack
@@ -1209,52 +1178,45 @@ APPEND_OPCODES.add(Op.PrimitiveReference, vm => {
   }
   stack.push(ref);
 });
-APPEND_OPCODES.add(Op.Dup, (vm, _ref4) => {
-  let {
-    op1: register,
-    op2: offset
-  } = _ref4;
+APPEND_OPCODES.add(Op.Dup, (vm, {
+  op1: register,
+  op2: offset
+}) => {
   let position = check(vm.fetchValue(register), CheckNumber) - offset;
   vm.stack.dup(position);
 });
-APPEND_OPCODES.add(Op.Pop, (vm, _ref5) => {
-  let {
-    op1: count
-  } = _ref5;
+APPEND_OPCODES.add(Op.Pop, (vm, {
+  op1: count
+}) => {
   vm.stack.pop(count);
 });
-APPEND_OPCODES.add(Op.Load, (vm, _ref6) => {
-  let {
-    op1: register
-  } = _ref6;
+APPEND_OPCODES.add(Op.Load, (vm, {
+  op1: register
+}) => {
   vm.load(register);
 });
-APPEND_OPCODES.add(Op.Fetch, (vm, _ref7) => {
-  let {
-    op1: register
-  } = _ref7;
+APPEND_OPCODES.add(Op.Fetch, (vm, {
+  op1: register
+}) => {
   vm.fetch(register);
 });
-APPEND_OPCODES.add(Op.BindDynamicScope, (vm, _ref8) => {
-  let {
-    op1: _names
-  } = _ref8;
+APPEND_OPCODES.add(Op.BindDynamicScope, (vm, {
+  op1: _names
+}) => {
   let names = vm[CONSTANTS].getArray(_names);
   vm.bindDynamicScope(names);
 });
-APPEND_OPCODES.add(Op.Enter, (vm, _ref9) => {
-  let {
-    op1: args
-  } = _ref9;
+APPEND_OPCODES.add(Op.Enter, (vm, {
+  op1: args
+}) => {
   vm.enter(args);
 });
 APPEND_OPCODES.add(Op.Exit, vm => {
   vm.exit();
 });
-APPEND_OPCODES.add(Op.PushSymbolTable, (vm, _ref10) => {
-  let {
-    op1: _table
-  } = _ref10;
+APPEND_OPCODES.add(Op.PushSymbolTable, (vm, {
+  op1: _table
+}) => {
   let stack = vm.stack;
   stack.push(vm[CONSTANTS].getValue(_table));
 });
@@ -1303,10 +1265,9 @@ APPEND_OPCODES.add(Op.InvokeYield, vm => {
   vm.pushScope(invokingScope);
   vm.call(handle);
 });
-APPEND_OPCODES.add(Op.JumpIf, (vm, _ref11) => {
-  let {
-    op1: target
-  } = _ref11;
+APPEND_OPCODES.add(Op.JumpIf, (vm, {
+  op1: target
+}) => {
   let reference = check(vm.stack.pop(), CheckReference);
   let value = Boolean(valueForRef(reference));
   if (isConstRef(reference)) {
@@ -1320,10 +1281,9 @@ APPEND_OPCODES.add(Op.JumpIf, (vm, _ref11) => {
     vm.updateWith(new Assert(reference));
   }
 });
-APPEND_OPCODES.add(Op.JumpUnless, (vm, _ref12) => {
-  let {
-    op1: target
-  } = _ref12;
+APPEND_OPCODES.add(Op.JumpUnless, (vm, {
+  op1: target
+}) => {
   let reference = check(vm.stack.pop(), CheckReference);
   let value = Boolean(valueForRef(reference));
   if (isConstRef(reference)) {
@@ -1337,11 +1297,10 @@ APPEND_OPCODES.add(Op.JumpUnless, (vm, _ref12) => {
     vm.updateWith(new Assert(reference));
   }
 });
-APPEND_OPCODES.add(Op.JumpEq, (vm, _ref13) => {
-  let {
-    op1: target,
-    op2: comparison
-  } = _ref13;
+APPEND_OPCODES.add(Op.JumpEq, (vm, {
+  op1: target,
+  op2: comparison
+}) => {
   let other = check(vm.stack.peek(), CheckNumber);
   if (other === comparison) {
     vm.goto(target);
@@ -1439,22 +1398,19 @@ class EndTrackFrameOpcode {
   }
 }
 
-APPEND_OPCODES.add(Op.Text, (vm, _ref) => {
-  let {
-    op1: text
-  } = _ref;
+APPEND_OPCODES.add(Op.Text, (vm, {
+  op1: text
+}) => {
   vm.elements().appendText(vm[CONSTANTS].getValue(text));
 });
-APPEND_OPCODES.add(Op.Comment, (vm, _ref2) => {
-  let {
-    op1: text
-  } = _ref2;
+APPEND_OPCODES.add(Op.Comment, (vm, {
+  op1: text
+}) => {
   vm.elements().appendComment(vm[CONSTANTS].getValue(text));
 });
-APPEND_OPCODES.add(Op.OpenElement, (vm, _ref3) => {
-  let {
-    op1: tag
-  } = _ref3;
+APPEND_OPCODES.add(Op.OpenElement, (vm, {
+  op1: tag
+}) => {
   vm.elements().openElement(vm[CONSTANTS].getValue(tag));
 });
 APPEND_OPCODES.add(Op.OpenDynamicElement, vm => {
@@ -1491,24 +1447,19 @@ APPEND_OPCODES.add(Op.FlushElement, vm => {
 });
 APPEND_OPCODES.add(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(Op.Modifier, (vm, _ref4) => {
-  let {
-    op1: handle
-  } = _ref4;
+APPEND_OPCODES.add(Op.Modifier, (vm, {
+  op1: handle
+}) => {
   if (vm.env.isInteractive === false) {
     return;
   }
@@ -1540,8 +1491,7 @@ APPEND_OPCODES.add(Op.DynamicModifier, vm => {
     return;
   }
   let {
-    stack,
-    [CONSTANTS]: constants
+    stack
   } = vm;
   let ref = check(stack.pop(), CheckReference);
   let args = check(stack.pop(), CheckArguments).capture();
@@ -1575,14 +1525,19 @@ APPEND_OPCODES.add(Op.DynamicModifier, vm => {
       hostDefinition = value;
       owner = initialOwner;
     }
-    let handle = constants.modifier(hostDefinition, null, true);
-    if (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: ${debugToString(hostDefinition)}`);
+    let manager = getInternalModifierManager(hostDefinition, true);
+    if (manager === null) {
+      if (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: ${debugToString(hostDefinition)}`);
+      } else {
+        throw new Error('BUG: modifier manager expected');
+      }
     }
-    let definition = constants.getValue(expect(handle, 'BUG: modifier handle expected'));
-    let {
-      manager
-    } = definition;
+    let definition = {
+      resolvedName: null,
+      manager,
+      state: hostDefinition
+    };
     let state = manager.create(owner, expect(constructing, 'BUG: ElementModifier could not find the element it applies to'), definition.state, args);
     return {
       manager,
@@ -1673,23 +1628,21 @@ class UpdateDynamicModifierOpcode {
     }
   }
 }
-APPEND_OPCODES.add(Op.StaticAttr, (vm, _ref5) => {
-  let {
-    op1: _name,
-    op2: _value,
-    op3: _namespace
-  } = _ref5;
+APPEND_OPCODES.add(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(Op.DynamicAttr, (vm, _ref6) => {
-  let {
-    op1: _name,
-    op2: _trusting,
-    op3: _namespace
-  } = _ref6;
+APPEND_OPCODES.add(Op.DynamicAttr, (vm, {
+  op1: _name,
+  op2: _trusting,
+  op3: _namespace
+}) => {
   let name = vm[CONSTANTS].getValue(_name);
   let trusting = vm[CONSTANTS].getValue(_trusting);
   let reference = check(vm.stack.pop(), CheckReference);
@@ -1729,10 +1682,9 @@ class UpdateDynamicAttributeOpcode {
  * component type's ComponentDefinition.
  */
 
-APPEND_OPCODES.add(Op.PushComponentDefinition, (vm, _ref) => {
-  let {
-    op1: handle
-  } = _ref;
+APPEND_OPCODES.add(Op.PushComponentDefinition, (vm, {
+  op1: handle
+}) => {
   let definition = vm[CONSTANTS].getValue(handle);
   assert(!!definition, `Missing component for ${handle}`);
   let {
@@ -1750,10 +1702,9 @@ APPEND_OPCODES.add(Op.PushComponentDefinition, (vm, _ref) => {
   };
   vm.stack.push(instance);
 });
-APPEND_OPCODES.add(Op.ResolveDynamicComponent, (vm, _ref2) => {
-  let {
-    op1: _isStrict
-  } = _ref2;
+APPEND_OPCODES.add(Op.ResolveDynamicComponent, (vm, {
+  op1: _isStrict
+}) => {
   let stack = vm.stack;
   let component = check(valueForRef(check(stack.pop(), CheckReference)), CheckOr(CheckString, CheckCurriedComponentDefinition));
   let constants = vm[CONSTANTS];
@@ -1815,12 +1766,11 @@ APPEND_OPCODES.add(Op.PushDynamicComponentInstance, vm => {
     table: null
   });
 });
-APPEND_OPCODES.add(Op.PushArgs, (vm, _ref3) => {
-  let {
-    op1: _names,
-    op2: _blockNames,
-    op3: flags
-  } = _ref3;
+APPEND_OPCODES.add(Op.PushArgs, (vm, {
+  op1: _names,
+  op2: _blockNames,
+  op3: flags
+}) => {
   let stack = vm.stack;
   let names = vm[CONSTANTS].getArray(_names);
   let positionalCount = flags >> 4;
@@ -1841,10 +1791,9 @@ APPEND_OPCODES.add(Op.CaptureArgs, vm => {
   let capturedArgs = args.capture();
   stack.push(capturedArgs);
 });
-APPEND_OPCODES.add(Op.PrepareArgs, (vm, _ref4) => {
-  let {
-    op1: _state
-  } = _ref4;
+APPEND_OPCODES.add(Op.PrepareArgs, (vm, {
+  op1: _state
+}) => {
   let stack = vm.stack;
   let instance = vm.fetchValue(_state);
   let args = check(stack.pop(), CheckInstanceof(VMArgumentsImpl));
@@ -1923,11 +1872,10 @@ APPEND_OPCODES.add(Op.PrepareArgs, (vm, _ref4) => {
   }
   stack.push(args);
 });
-APPEND_OPCODES.add(Op.CreateComponent, (vm, _ref5) => {
-  let {
-    op1: flags,
-    op2: _state
-  } = _ref5;
+APPEND_OPCODES.add(Op.CreateComponent, (vm, {
+  op1: flags,
+  op2: _state
+}) => {
   let instance = check(vm.fetchValue(_state), CheckComponentInstance);
   let {
     definition,
@@ -1962,10 +1910,9 @@ APPEND_OPCODES.add(Op.CreateComponent, (vm, _ref5) => {
     vm.updateWith(new UpdateComponentOpcode(state, manager, dynamicScope));
   }
 });
-APPEND_OPCODES.add(Op.RegisterComponentDestructor, (vm, _ref6) => {
-  let {
-    op1: _state
-  } = _ref6;
+APPEND_OPCODES.add(Op.RegisterComponentDestructor, (vm, {
+  op1: _state
+}) => {
   let {
     manager,
     state,
@@ -1977,10 +1924,9 @@ APPEND_OPCODES.add(Op.RegisterComponentDestructor, (vm, _ref6) => {
   }
   if (d) vm.associateDestroyable(d);
 });
-APPEND_OPCODES.add(Op.BeginComponentTransaction, (vm, _ref7) => {
-  let {
-    op1: _state
-  } = _ref7;
+APPEND_OPCODES.add(Op.BeginComponentTransaction, (vm, {
+  op1: _state
+}) => {
   let name;
   if (DEBUG) {
     let {
@@ -1995,24 +1941,22 @@ APPEND_OPCODES.add(Op.BeginComponentTransaction, (vm, _ref7) => {
 APPEND_OPCODES.add(Op.PutComponentOperations, vm => {
   vm.loadValue($t0, new ComponentElementOperations());
 });
-APPEND_OPCODES.add(Op.ComponentAttr, (vm, _ref8) => {
-  let {
-    op1: _name,
-    op2: _trusting,
-    op3: _namespace
-  } = _ref8;
+APPEND_OPCODES.add(Op.ComponentAttr, (vm, {
+  op1: _name,
+  op2: _trusting,
+  op3: _namespace
+}) => {
   let name = vm[CONSTANTS].getValue(_name);
   let trusting = vm[CONSTANTS].getValue(_trusting);
   let reference = check(vm.stack.pop(), CheckReference);
   let namespace = _namespace ? vm[CONSTANTS].getValue(_namespace) : null;
   check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations)).setAttribute(name, reference, trusting, namespace);
 });
-APPEND_OPCODES.add(Op.StaticComponentAttr, (vm, _ref9) => {
-  let {
-    op1: _name,
-    op2: _value,
-    op3: _namespace
-  } = _ref9;
+APPEND_OPCODES.add(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;
@@ -2080,15 +2024,9 @@ function mergeClasses(classes) {
   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 {
@@ -2098,10 +2036,9 @@ function setDeferredAttr(vm, name, value, namespace) {
     }
   }
 }
-APPEND_OPCODES.add(Op.DidCreateElement, (vm, _ref10) => {
-  let {
-    op1: _state
-  } = _ref10;
+APPEND_OPCODES.add(Op.DidCreateElement, (vm, {
+  op1: _state
+}) => {
   let {
     definition,
     state
@@ -2112,11 +2049,10 @@ APPEND_OPCODES.add(Op.DidCreateElement, (vm, _ref10) => {
   let operations = check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations));
   manager.didCreateElement(state, expect(vm.elements().constructing, `Expected a constructing element in DidCreateOpcode`), operations);
 });
-APPEND_OPCODES.add(Op.GetComponentSelf, (vm, _ref11) => {
-  let {
-    op1: _state,
-    op2: _names
-  } = _ref11;
+APPEND_OPCODES.add(Op.GetComponentSelf, (vm, {
+  op1: _state,
+  op2: _names
+}) => {
   let instance = check(vm.fetchValue(_state), CheckComponentInstance);
   let {
     definition,
@@ -2186,10 +2122,9 @@ APPEND_OPCODES.add(Op.GetComponentSelf, (vm, _ref11) => {
   }
   vm.stack.push(selfRef);
 });
-APPEND_OPCODES.add(Op.GetComponentTagName, (vm, _ref12) => {
-  let {
-    op1: _state
-  } = _ref12;
+APPEND_OPCODES.add(Op.GetComponentTagName, (vm, {
+  op1: _state
+}) => {
   let {
     definition,
     state
@@ -2204,10 +2139,9 @@ APPEND_OPCODES.add(Op.GetComponentTagName, (vm, _ref12) => {
 });
 
 // Dynamic Invocation Only
-APPEND_OPCODES.add(Op.GetComponentLayout, (vm, _ref13) => {
-  let {
-    op1: _state
-  } = _ref13;
+APPEND_OPCODES.add(Op.GetComponentLayout, (vm, {
+  op1: _state
+}) => {
   let instance = check(vm.fetchValue(_state), CheckComponentInstance);
   let {
     manager,
@@ -2237,10 +2171,9 @@ APPEND_OPCODES.add(Op.GetComponentLayout, (vm, _ref13) => {
   stack.push(compilable.symbolTable);
   stack.push(handle);
 });
-APPEND_OPCODES.add(Op.Main, (vm, _ref14) => {
-  let {
-    op1: register
-  } = _ref14;
+APPEND_OPCODES.add(Op.Main, (vm, {
+  op1: register
+}) => {
   let definition = check(vm.stack.pop(), CheckComponentDefinition);
   let invocation = check(vm.stack.pop(), CheckInvocation);
   let {
@@ -2258,10 +2191,9 @@ APPEND_OPCODES.add(Op.Main, (vm, _ref14) => {
   };
   vm.loadValue(register, state);
 });
-APPEND_OPCODES.add(Op.PopulateLayout, (vm, _ref15) => {
-  let {
-    op1: _state
-  } = _ref15;
+APPEND_OPCODES.add(Op.PopulateLayout, (vm, {
+  op1: _state
+}) => {
   let {
     stack
   } = vm;
@@ -2273,10 +2205,9 @@ APPEND_OPCODES.add(Op.PopulateLayout, (vm, _ref15) => {
   state.handle = handle;
   state.table = table;
 });
-APPEND_OPCODES.add(Op.VirtualRootScope, (vm, _ref16) => {
-  let {
-    op1: _state
-  } = _ref16;
+APPEND_OPCODES.add(Op.VirtualRootScope, (vm, {
+  op1: _state
+}) => {
   let {
     table,
     manager,
@@ -2303,20 +2234,18 @@ APPEND_OPCODES.add(Op.VirtualRootScope, (vm, _ref16) => {
   }
   vm.pushRootScope(table.symbols.length + 1, owner);
 });
-APPEND_OPCODES.add(Op.SetupForEval, (vm, _ref17) => {
-  let {
-    op1: _state
-  } = _ref17;
+APPEND_OPCODES.add(Op.SetupForEval, (vm, {
+  op1: _state
+}) => {
   let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
   if (state.table.hasEval) {
     let lookup = state.lookup = dict();
     vm.scope().bindEvalScope(lookup);
   }
 });
-APPEND_OPCODES.add(Op.SetNamedVariables, (vm, _ref18) => {
-  let {
-    op1: _state
-  } = _ref18;
+APPEND_OPCODES.add(Op.SetNamedVariables, (vm, {
+  op1: _state
+}) => {
   let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
   let scope = vm.scope();
   let args = check(vm.stack.peek(), CheckArguments);
@@ -2335,10 +2264,9 @@ function bindBlock(symbolName, blockName, state, blocks, vm) {
   if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
   if (state.lookup) state.lookup[symbolName] = block;
 }
-APPEND_OPCODES.add(Op.SetBlocks, (vm, _ref19) => {
-  let {
-    op1: _state
-  } = _ref19;
+APPEND_OPCODES.add(Op.SetBlocks, (vm, {
+  op1: _state
+}) => {
   let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
   let {
     blocks
@@ -2349,17 +2277,15 @@ APPEND_OPCODES.add(Op.SetBlocks, (vm, _ref19) => {
 });
 
 // Dynamic Invocation Only
-APPEND_OPCODES.add(Op.InvokeComponentLayout, (vm, _ref20) => {
-  let {
-    op1: _state
-  } = _ref20;
+APPEND_OPCODES.add(Op.InvokeComponentLayout, (vm, {
+  op1: _state
+}) => {
   let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
   vm.call(state.handle);
 });
-APPEND_OPCODES.add(Op.DidRenderLayout, (vm, _ref21) => {
-  let {
-    op1: _state
-  } = _ref21;
+APPEND_OPCODES.add(Op.DidRenderLayout, (vm, {
+  op1: _state
+}) => {
   let instance = check(vm.fetchValue(_state), CheckComponentInstance);
   let {
     manager,
@@ -2726,8 +2652,7 @@ class NamedArgumentsImpl {
   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
@@ -2918,11 +2843,11 @@ const EMPTY_ARGS = createCapturedArgs(EMPTY_NAMED, EMPTY_POSITIONAL);
 
 function createConcatRef(partsRefs) {
   return createComputeRef(() => {
-    let parts = new Array();
-    for (const [i, ref] of enumerate(partsRefs)) {
-      let value = valueForRef(ref);
+    const parts = [];
+    for (const ref of partsRefs) {
+      const value = valueForRef(ref);
       if (value !== null && value !== undefined) {
-        parts[i] = castToString(value);
+        parts.push(castToString(value));
       }
     }
     if (parts.length > 0) {
@@ -2932,17 +2857,18 @@ function createConcatRef(partsRefs) {
   });
 }
 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(Op.Curry, (vm, _ref) => {
-  let {
-    op1: type,
-    op2: _isStrict
-  } = _ref;
+APPEND_OPCODES.add(Op.Curry, (vm, {
+  op1: type,
+  op2: _isStrict
+}) => {
   let stack = vm.stack;
   let definition = check(stack.pop(), CheckReference);
   let capturedArgs = check(stack.pop(), CheckCapturedArguments);
@@ -2973,7 +2899,7 @@ APPEND_OPCODES.add(Op.DynamicHelper, vm => {
         positional,
         named
       } = resolveCurriedValue(definition);
-      let helper = resolveHelper(vm[CONSTANTS], resolvedDef, ref);
+      let helper = resolveHelper(resolvedDef, ref);
       if (named !== undefined) {
         args.named = assign({}, ...named, args.named);
       }
@@ -2983,7 +2909,7 @@ APPEND_OPCODES.add(Op.DynamicHelper, vm => {
       helperRef = helper(args, owner);
       associateDestroyableChild(helperInstanceRef, helperRef);
     } else if (isObject(definition)) {
-      let helper = resolveHelper(vm[CONSTANTS], definition, ref);
+      let helper = resolveHelper(definition, ref);
       helperRef = helper(args, initialOwner);
       if (_hasDestroyableChildren(helperRef)) {
         associateDestroyableChild(helperInstanceRef, helperRef);
@@ -2999,17 +2925,23 @@ APPEND_OPCODES.add(Op.DynamicHelper, vm => {
   vm.associateDestroyable(helperInstanceRef);
   vm.loadValue($v0, helperValueRef);
 });
-function resolveHelper(constants, definition, ref) {
-  let handle = constants.helper(definition, null, true);
-  if (DEBUG && handle === null) {
+function resolveHelper(definition, ref) {
+  let managerOrHelper = getInternalHelperManager(definition, true);
+  let helper;
+  if (managerOrHelper === null) {
+    helper = null;
+  } else {
+    helper = typeof managerOrHelper === 'function' ? managerOrHelper : managerOrHelper.getHelper(definition);
+    assert(managerOrHelper, 'BUG: expected manager or helper');
+  }
+  if (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: ${debugToString(definition)}`);
   }
-  return constants.getValue(handle);
+  return helper;
 }
-APPEND_OPCODES.add(Op.Helper, (vm, _ref2) => {
-  let {
-    op1: handle
-  } = _ref2;
+APPEND_OPCODES.add(Op.Helper, (vm, {
+  op1: handle
+}) => {
   let stack = vm.stack;
   let helper = check(vm[CONSTANTS].getValue(handle), CheckHelper);
   let args = check(stack.pop(), CheckArguments);
@@ -3019,33 +2951,29 @@ APPEND_OPCODES.add(Op.Helper, (vm, _ref2) => {
   }
   vm.loadValue($v0, value);
 });
-APPEND_OPCODES.add(Op.GetVariable, (vm, _ref3) => {
-  let {
-    op1: symbol
-  } = _ref3;
+APPEND_OPCODES.add(Op.GetVariable, (vm, {
+  op1: symbol
+}) => {
   let expr = vm.referenceForSymbol(symbol);
   vm.stack.push(expr);
 });
-APPEND_OPCODES.add(Op.SetVariable, (vm, _ref4) => {
-  let {
-    op1: symbol
-  } = _ref4;
+APPEND_OPCODES.add(Op.SetVariable, (vm, {
+  op1: symbol
+}) => {
   let expr = check(vm.stack.pop(), CheckReference);
   vm.scope().bindSymbol(symbol, expr);
 });
-APPEND_OPCODES.add(Op.SetBlock, (vm, _ref5) => {
-  let {
-    op1: symbol
-  } = _ref5;
+APPEND_OPCODES.add(Op.SetBlock, (vm, {
+  op1: symbol
+}) => {
   let handle = check(vm.stack.pop(), CheckCompilableBlock);
   let scope = check(vm.stack.pop(), CheckScope);
   let table = check(vm.stack.pop(), CheckBlockSymbolTable);
   vm.scope().bindBlock(symbol, [handle, scope, table]);
 });
-APPEND_OPCODES.add(Op.ResolveMaybeLocal, (vm, _ref6) => {
-  let {
-    op1: _name
-  } = _ref6;
+APPEND_OPCODES.add(Op.ResolveMaybeLocal, (vm, {
+  op1: _name
+}) => {
   let name = vm[CONSTANTS].getValue(_name);
   let locals = vm.scope().getPartialMap();
   let ref = locals[name];
@@ -3054,24 +2982,21 @@ APPEND_OPCODES.add(Op.ResolveMaybeLocal, (vm, _ref6) => {
   }
   vm.stack.push(ref);
 });
-APPEND_OPCODES.add(Op.RootScope, (vm, _ref7) => {
-  let {
-    op1: symbols
-  } = _ref7;
+APPEND_OPCODES.add(Op.RootScope, (vm, {
+  op1: symbols
+}) => {
   vm.pushRootScope(symbols, vm.getOwner());
 });
-APPEND_OPCODES.add(Op.GetProperty, (vm, _ref8) => {
-  let {
-    op1: _key
-  } = _ref8;
+APPEND_OPCODES.add(Op.GetProperty, (vm, {
+  op1: _key
+}) => {
   let key = vm[CONSTANTS].getValue(_key);
   let expr = check(vm.stack.pop(), CheckReference);
   vm.stack.push(childRefFor(expr, key));
 });
-APPEND_OPCODES.add(Op.GetBlock, (vm, _ref9) => {
-  let {
-    op1: _block
-  } = _ref9;
+APPEND_OPCODES.add(Op.GetBlock, (vm, {
+  op1: _block
+}) => {
   let {
     stack
   } = vm;
@@ -3119,10 +3044,9 @@ APPEND_OPCODES.add(Op.HasBlockParams, vm => {
   let hasBlockParams = table && table.parameters.length;
   vm.stack.push(hasBlockParams ? TRUE_REFERENCE : FALSE_REFERENCE);
 });
-APPEND_OPCODES.add(Op.Concat, (vm, _ref10) => {
-  let {
-    op1: count
-  } = _ref10;
+APPEND_OPCODES.add(Op.Concat, (vm, {
+  op1: count
+}) => {
   let out = new Array(count);
   for (let i = count; i > 0; i--) {
     let offset = i - 1;
@@ -3321,22 +3245,20 @@ class ScopeInspector {
     return tail.reduce((r, part) => childRefFor(r, part), ref);
   }
 }
-APPEND_OPCODES.add(Op.Debugger, (vm, _ref) => {
-  let {
-    op1: _symbols,
-    op2: _debugInfo
-  } = _ref;
+APPEND_OPCODES.add(Op.Debugger, (vm, {
+  op1: _symbols,
+  op2: _debugInfo
+}) => {
   let symbols = vm[CONSTANTS].getArray(_symbols);
   let debugInfo = vm[CONSTANTS].getArray(decodeHandle(_debugInfo));
   let inspector = new ScopeInspector(vm.scope(), symbols, debugInfo);
   callback(valueForRef(vm.getSelf()), path => valueForRef(inspector.get(path)));
 });
 
-APPEND_OPCODES.add(Op.EnterList, (vm, _ref) => {
-  let {
-    op1: relativeStart,
-    op2: elseTarget
-  } = _ref;
+APPEND_OPCODES.add(Op.EnterList, (vm, {
+  op1: relativeStart,
+  op2: elseTarget
+}) => {
   let stack = vm.stack;
   let listRef = check(stack.pop(), CheckReference);
   let keyRef = check(stack.pop(), CheckReference);
@@ -3356,10 +3278,9 @@ APPEND_OPCODES.add(Op.EnterList, (vm, _ref) => {
 APPEND_OPCODES.add(Op.ExitList, vm => {
   vm.exitList();
 });
-APPEND_OPCODES.add(Op.Iterate, (vm, _ref2) => {
-  let {
-    op1: breaks
-  } = _ref2;
+APPEND_OPCODES.add(Op.Iterate, (vm, {
+  op1: breaks
+}) => {
   let stack = vm.stack;
   let iterator = check(stack.peek(), CheckIterator);
   let item = iterator.next();
@@ -3389,10 +3310,9 @@ class TemplateOnlyComponentManager {
   getCapabilities() {
     return CAPABILITIES;
   }
-  getDebugName(_ref) {
-    let {
-      name
-    } = _ref;
+  getDebugName({
+    name
+  }) {
     return name;
   }
   getSelf() {
@@ -3406,9 +3326,7 @@ const TEMPLATE_ONLY_COMPONENT_MANAGER = new TemplateOnlyComponentManager();
 
 // 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;
   }
@@ -3679,8 +3597,7 @@ class TreeConstruction extends DOMOperations {
   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 {
@@ -3869,10 +3786,9 @@ class DebugRenderTreeImpl {
       children
     };
   }
-  captureTemplate(_ref) {
-    let {
-      template
-    } = _ref;
+  captureTemplate({
+    template
+  }) {
     return template || null;
   }
   captureBounds(node) {
@@ -4072,10 +3988,9 @@ function internalHelper(helper) {
    @public
  */
 
-const array = internalHelper(_ref => {
-  let {
-    positional
-  } = _ref;
+const array = internalHelper(({
+  positional
+}) => {
   return createComputeRef(() => reifyPositional(positional), null, 'array');
 });
 
@@ -4109,10 +4024,9 @@ const normalizeTextValue = value => {
   @public
   @method concat
 */
-const concat = internalHelper(_ref => {
-  let {
-    positional
-  } = _ref;
+const concat = internalHelper(({
+  positional
+}) => {
   return createComputeRef(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
 });
 
@@ -4182,18 +4096,14 @@ const context = buildUntouchableThis('`fn` helper');
   @method fn
   @public
 */
-const fn = internalHelper(_ref => {
-  let {
-    positional
-  } = _ref;
+const fn = internalHelper(({
+  positional
+}) => {
   let callbackRef = check(positional[0], assertCallbackIsFn);
   return createComputeRef(() => {
-    return function () {
+    return (...invocationArgs) => {
       let [fn, ...args] = reifyPositional(positional);
       if (DEBUG) assertCallbackIsFn(callbackRef);
-      for (var _len = arguments.length, invocationArgs = new Array(_len), _key = 0; _key < _len; _key++) {
-        invocationArgs[_key] = arguments[_key];
-      }
       if (isInvokableRef(callbackRef)) {
         let value = args.length > 0 ? args[0] : invocationArgs[0];
         return updateRef(callbackRef, value);
@@ -4286,10 +4196,9 @@ function assertCallbackIsFn(callbackRef) {
   @public
   @method get
  */
-const get = internalHelper(_ref => {
-  let {
-    positional
-  } = _ref;
+const get = internalHelper(({
+  positional
+}) => {
   let sourceRef = positional[0] ?? UNDEFINED_REFERENCE;
   let pathRef = positional[1] ?? UNDEFINED_REFERENCE;
   return createComputeRef(() => {
@@ -4356,10 +4265,9 @@ if (DEBUG) {
    @return {Object} Hash
    @public
  */
-const hash = internalHelper(_ref => {
-  let {
-    named
-  } = _ref;
+const hash = internalHelper(({
+  named
+}) => {
   let ref = createComputeRef(() => {
     let hash = reifyNamed(named);
     if (DEBUG) {
@@ -4384,8 +4292,7 @@ function getArgs(proxy) {
 }
 class SimpleArgsProxy {
   argsCache;
-  constructor(context) {
-    let computeArgs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => EMPTY_ARGS;
+  constructor(context, computeArgs = () => EMPTY_ARGS) {
     let argsCache = createCache(() => computeArgs(context));
     if (DEBUG) {
       ARGS_CACHES.set(this, argsCache);
@@ -4441,40 +4348,6 @@ function invokeHelper(context, definition, computeArgs) {
 }
 
 const untouchableContext = 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 {
   tag = createUpdatableTag();
   element;
@@ -4509,11 +4382,11 @@ class OnModifierState {
       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
@@ -4538,19 +4411,16 @@ class OnModifierState {
     if (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 */ || DEBUG && passive; /* needs passive enforcement */
+    let needsCustomCallback = DEBUG && passive; /* needs passive enforcement */
 
     if (this.shouldUpdate) {
       if (needsCustomCallback) {
-        let callback = this.callback = function (event) {
+        this.callback = function (event) {
           if (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 (DEBUG) {
@@ -4566,45 +4436,11 @@ let adds = 0;
 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);
 }
 
 /**
@@ -4694,7 +4530,6 @@ function addEventListener(element, eventName, callback, options) {
   @public
 */
 class OnModifierManager {
-  SUPPORTS_EVENT_OPTIONS = SUPPORTS_EVENT_OPTIONS;
   getDebugName() {
     return 'on';
   }
@@ -4886,10 +4721,9 @@ class UpdatingVM {
   dom;
   alwaysRevalidate;
   frameStack = new Stack();
-  constructor(env, _ref) {
-    let {
-      alwaysRevalidate = false
-    } = _ref;
+  constructor(env, {
+    alwaysRevalidate = false
+  }) {
     this.env = env;
     this.dom = env.getDOM();
     this.alwaysRevalidate = alwaysRevalidate;
@@ -5220,12 +5054,11 @@ class RenderResultImpl {
     associateDestroyableChild(this, drop);
     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
@@ -5256,38 +5089,31 @@ class EvaluationStackImpl {
   [REGISTERS];
 
   // fp -> sp
-  constructor() {
-    let stack = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    let registers = arguments.length > 1 ? arguments[1] : undefined;
+  constructor(stack = [], registers) {
     this.stack = stack;
     this[REGISTERS] = registers;
   }
   push(value) {
     this.stack[++this[REGISTERS][$sp]] = value;
   }
-  dup() {
-    let position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this[REGISTERS][$sp];
+  dup(position = this[REGISTERS][$sp]) {
     this.stack[++this[REGISTERS][$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][$sp]];
     this[REGISTERS][$sp] -= n;
     return top;
   }
-  peek() {
-    let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  peek(offset = 0) {
     return this.stack[this[REGISTERS][$sp] - offset];
   }
-  get(offset) {
-    let base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[REGISTERS][$fp];
+  get(offset, base = this[REGISTERS][$fp]) {
     return this.stack[base + offset];
   }
-  set(value, offset) {
-    let base = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this[REGISTERS][$fp];
+  set(value, offset, base = this[REGISTERS][$fp]) {
     this.stack[base + offset] = value;
   }
   slice(start, end) {
@@ -5436,13 +5262,12 @@ class VM {
    * End of migrated.
    */
 
-  constructor(runtime, _ref, elementStack, context) {
-    let {
-      pc,
-      scope,
-      dynamicScope,
-      stack
-    } = _ref;
+  constructor(runtime, {
+    pc,
+    scope,
+    dynamicScope,
+    stack
+  }, elementStack, context) {
     this.runtime = runtime;
     this.elementStack = elementStack;
     this.context = context;
@@ -5472,28 +5297,26 @@ class VM {
     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(UNDEFINED_REFERENCE, 0, owner), dynamicScope), treeBuilder);
     vm.pushUpdating();
     return vm;
@@ -5509,8 +5332,7 @@ class VM {
   get env() {
     return this.runtime.env;
   }
-  captureState(args) {
-    let pc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[INNER_VM].fetchRegister($pc);
+  captureState(args, pc = this[INNER_VM].fetchRegister($pc)) {
     return {
       pc,
       scope: this.scope(),
@@ -5518,8 +5340,7 @@ class VM {
       stack: this.stack.capture(args)
     };
   }
-  capture(args) {
-    let pc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this[INNER_VM].fetchRegister($pc);
+  capture(args, pc = this[INNER_VM].fetchRegister($pc)) {
     return new ResumableVMStateImpl(this.captureState(args, pc), this.resume);
   }
   beginCacheGroup(name) {
@@ -5544,12 +5365,11 @@ class VM {
     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;
@@ -5590,8 +5410,7 @@ class VM {
     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() {
@@ -5754,8 +5573,7 @@ function renderSync(env, iterator) {
   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 = unwrapHandle(layout.compile(context));
   let numSymbols = layout.symbolTable.symbols.length;
   let vm = VM.initial(runtime, context, {
@@ -5774,10 +5592,7 @@ function renderInvocation(vm, context, owner, definition, args) {
   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();
 
@@ -5788,8 +5603,7 @@ function renderInvocation(vm, context, owner, definition, args) {
   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);
   });
 
@@ -5809,9 +5623,7 @@ function renderInvocation(vm, context, owner, definition, args) {
   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,
@@ -5911,8 +5723,7 @@ class RehydrateBuilder extends NewElementBuilder {
     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);
 
     /**