ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/shared-chunks/on-CrTl7JQU.js

@@ -0,0 +1,3329 @@
+import { r as VM_SYSCALL_SIZE, C as CURRIED_COMPONENT, s as VM_CHILD_SCOPE_OP, t as VM_POP_SCOPE_OP, u as VM_PUSH_DYNAMIC_SCOPE_OP, v as VM_POP_DYNAMIC_SCOPE_OP, w as VM_CONSTANT_OP, x as decodeHandle, y as VM_CONSTANT_REFERENCE_OP, z as VM_PRIMITIVE_OP, A as isHandle, B as decodeImmediate, D as VM_PRIMITIVE_REFERENCE_OP, E as VM_DUP_OP, F as VM_POP_OP, G as VM_LOAD_OP, H as VM_FETCH_OP, I as VM_BIND_DYNAMIC_SCOPE_OP, J as VM_ENTER_OP, K as VM_EXIT_OP, L as VM_PUSH_SYMBOL_TABLE_OP, M as VM_PUSH_BLOCK_SCOPE_OP, N as VM_COMPILE_BLOCK_OP, O as VM_INVOKE_YIELD_OP, P as VM_JUMP_IF_OP, Q as VM_JUMP_UNLESS_OP, R as VM_JUMP_EQ_OP, b as VM_ASSERT_SAME_OP, S as VM_TO_BOOLEAN_OP, T as VM_TEXT_OP, U as VM_COMMENT_OP, W as VM_OPEN_ELEMENT_OP, X as VM_OPEN_DYNAMIC_ELEMENT_OP, Y as VM_PUSH_REMOTE_ELEMENT_OP, Z as VM_POP_REMOTE_ELEMENT_OP, _ as VM_FLUSH_ELEMENT_OP, $ as VM_CLOSE_ELEMENT_OP, a0 as VM_MODIFIER_OP, a1 as VM_DYNAMIC_MODIFIER_OP, a2 as VM_STATIC_ATTR_OP, a3 as VM_DYNAMIC_ATTR_OP, a4 as CURRIED_MODIFIER, a5 as VM_PUSH_COMPONENT_DEFINITION_OP, a6 as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_RESOLVE_CURRIED_COMPONENT_OP, g as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, a7 as VM_PUSH_ARGS_OP, a8 as VM_PUSH_EMPTY_ARGS_OP, a9 as VM_CAPTURE_ARGS_OP, aa as VM_PREPARE_ARGS_OP, ab as VM_CREATE_COMPONENT_OP, ac as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, ad as VM_BEGIN_COMPONENT_TRANSACTION_OP, ae as VM_PUT_COMPONENT_OPERATIONS_OP, af as VM_COMPONENT_ATTR_OP, ag as VM_STATIC_COMPONENT_ATTR_OP, ah as VM_DID_CREATE_ELEMENT_OP, ai as VM_GET_COMPONENT_SELF_OP, aj as VM_GET_COMPONENT_TAG_NAME_OP, ak as VM_GET_COMPONENT_LAYOUT_OP, V as VM_MAIN_OP, al as VM_POPULATE_LAYOUT_OP, am as VM_VIRTUAL_ROOT_SCOPE_OP, an as VM_SET_NAMED_VARIABLES_OP, ao as VM_SET_BLOCKS_OP, ap as VM_INVOKE_COMPONENT_LAYOUT_OP, aq as VM_DID_RENDER_LAYOUT_OP, ar as VM_COMMIT_COMPONENT_TRANSACTION_OP, as as VM_CURRY_OP, at as VM_DYNAMIC_HELPER_OP, au as CURRIED_HELPER, av as VM_HELPER_OP, aw as VM_GET_VARIABLE_OP, ax as VM_SET_VARIABLE_OP, ay as VM_SET_BLOCK_OP, az as VM_ROOT_SCOPE_OP, aA as VM_GET_PROPERTY_OP, aB as VM_GET_BLOCK_OP, aC as VM_SPREAD_BLOCK_OP, aD as VM_HAS_BLOCK_OP, aE as VM_HAS_BLOCK_PARAMS_OP, aF as VM_CONCAT_OP, aG as VM_IF_INLINE_OP, aH as VM_NOT_OP, aI as VM_GET_DYNAMIC_VAR_OP, aJ as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, aK as VM_DYNAMIC_CONTENT_TYPE_OP, d as VM_APPEND_HTML_OP, h as VM_APPEND_SAFE_HTML_OP, e as VM_APPEND_TEXT_OP, i as VM_APPEND_DOCUMENT_FRAGMENT_OP, j as VM_APPEND_NODE_OP, aL as VM_DEBUGGER_OP, aM as VM_ENTER_LIST_OP, aN as VM_EXIT_LIST_OP, aO as VM_ITERATE_OP } from './fragment-EpVz5Xuc.js';
+import { u as unwrap, c as isIndexable$1, e as expect, S as StackImpl, d as dict, i as isDict } from './collections-GpG8lT2g.js';
+import { a as assign } from './object-utils-AijlD-JH.js';
+import { toBool, setPath, getPath } from '../@glimmer/global-context/index.js';
+import { CONSTANT_TAG, INITIAL, validateTag, consumeTag, valueForTag, beginTrackFrame, endTrackFrame, CURRENT_TAG, createUpdatableTag } from '../@glimmer/validator/index.js';
+import { c as createComputeRef, v as valueForRef, a as createConstRef, d as createPrimitiveRef, i as isConstRef, U as UNDEFINED_REFERENCE, N as NULL_REFERENCE, T as TRUE_REFERENCE, F as FALSE_REFERENCE, R as REFERENCE, b as childRefFor, e as isInvokableRef, u as updateRef } from './reference-BNqcwZWH.js';
+import { e as $v0, f as $t1, g as $t0, a as $pc, b as $ra, c as $fp, d as $sp, h as $s1, $ as $s0 } from './registers-ylirb0dq.js';
+import { registerDestructor, destroy, associateDestroyableChild, _hasDestroyableChildren } from '../@glimmer/destroyable/index.js';
+import { d as getInternalModifierManager, g as getInternalHelperManager, b as hasInternalComponentManager, f as hasInternalHelperManager, s as setInternalComponentManager, i as setInternalHelperManager, j as setInternalModifierManager } from './api-Co-k4HVs.js';
+import { m as managerHasCapability } from './capabilities-DGmQ_mz4.js';
+import { ContentType } from '../@glimmer/vm/index.js';
+import { createIteratorRef } from '../@glimmer/reference/index.js';
+import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
+import { b as EMPTY_STRING_ARRAY, e as enumerate, c as emptyArray } from './array-utils-CZQxrdD3.js';
+import { a as assert } from './assert-CUCJBR2C.js';
+import { a as unwrapTemplate } from './constants-b-2IVErl.js';
+import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+function buildUntouchableThis(source) {
+  let context = null;
+  return context;
+}
+
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const NS_MATHML = 'http://www.w3.org/1998/Math/MathML';
+const NS_SVG = 'http://www.w3.org/2000/svg';
+const INSERT_BEFORE_BEGIN = 'beforebegin';
+const INSERT_BEFORE_END = 'beforeend';
+
+function CheckInstanceof(Class) {
+}
+const CheckRegister = new class {
+  validate(value) {
+    switch (value) {
+      case $s0:
+      case $s1:
+      case $sp:
+      case $fp:
+      case $ra:
+      case $pc:
+      case $t0:
+      case $t1:
+      case $v0:
+        return true;
+      default:
+        return false;
+    }
+  }
+  expected() {
+    return `Register`;
+  }
+}();
+
+/*@__NO_SIDE_EFFECTS__*/
+
+function check(value, checker, message) {
+  {
+    return value;
+  }
+}
+
+class AppendOpcodes {
+  // This code is intentionally putting unsafe `null`s into the array that it
+  // will intentionally overwrite before anyone can see them.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  evaluateOpcode = new Array(VM_SYSCALL_SIZE).fill(null);
+  constructor() {
+  }
+  add(name, evaluate, kind = 'syscall') {
+    this.evaluateOpcode[name] = {
+      syscall: kind !== 'machine',
+      evaluate
+    };
+  }
+  evaluate(vm, opcode, type) {
+    let operation = unwrap(this.evaluateOpcode[type]);
+    if (operation.syscall) {
+      assert(!opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`);
+      operation.evaluate(vm, opcode);
+    } else {
+      assert(opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`);
+      operation.evaluate(vm.lowlevel, opcode);
+    }
+  }
+}
+function externs(vm) {
+  return undefined;
+}
+const APPEND_OPCODES = new AppendOpcodes();
+
+const TYPE = Symbol('TYPE');
+const INNER = Symbol('INNER');
+const OWNER = Symbol('OWNER');
+const ARGS = Symbol('ARGS');
+const RESOLVED = Symbol('RESOLVED');
+const CURRIED_VALUES = new WeakSet();
+function isCurriedValue(value) {
+  return CURRIED_VALUES.has(value);
+}
+function isCurriedType(value, type) {
+  return isCurriedValue(value) && value[TYPE] === type;
+}
+class CurriedValue {
+  [TYPE];
+  [INNER];
+  [OWNER];
+  [ARGS];
+  [RESOLVED];
+
+  /** @internal */
+  constructor(type, inner, owner, args, resolved = false) {
+    CURRIED_VALUES.add(this);
+    this[TYPE] = type;
+    this[INNER] = inner;
+    this[OWNER] = owner;
+    this[ARGS] = args;
+    this[RESOLVED] = resolved;
+  }
+}
+function resolveCurriedValue(curriedValue) {
+  let currentWrapper = curriedValue;
+  let positional;
+  let named;
+  let definition, owner, resolved;
+  while (true) {
+    let {
+      [ARGS]: curriedArgs,
+      [INNER]: inner
+    } = currentWrapper;
+    if (curriedArgs !== null) {
+      let {
+        named: curriedNamed,
+        positional: curriedPositional
+      } = curriedArgs;
+      if (curriedPositional.length > 0) {
+        positional = positional === undefined ? curriedPositional : curriedPositional.concat(positional);
+      }
+      if (named === undefined) {
+        named = [];
+      }
+      named.unshift(curriedNamed);
+    }
+    if (!isCurriedValue(inner)) {
+      // Save off the owner that this helper was curried with. Later on,
+      // we'll fetch the value of this register and set it as the owner on the
+      // new root scope.
+      definition = inner;
+      owner = currentWrapper[OWNER];
+      resolved = currentWrapper[RESOLVED];
+      break;
+    }
+    currentWrapper = inner;
+  }
+  return {
+    definition,
+    owner,
+    resolved,
+    positional,
+    named
+  };
+}
+function curry(type, spec, owner, args, resolved = false) {
+  return new CurriedValue(type, spec, owner, args, resolved);
+}
+
+function createCurryRef(type, inner, owner, args, resolver, isStrict) {
+  let lastValue, curriedDefinition;
+  return createComputeRef(() => {
+    let value = valueForRef(inner);
+    if (value === lastValue) {
+      return curriedDefinition;
+    }
+    if (isCurriedType(value, type)) {
+      curriedDefinition = args ? curry(type, value, owner, args) : args;
+    } else if (type === CURRIED_COMPONENT && typeof value === 'string' && value) {
+      curriedDefinition = curry(type, value, owner, args);
+    } else if (isIndexable$1(value)) {
+      curriedDefinition = curry(type, value, owner, args);
+    } else {
+      curriedDefinition = null;
+    }
+    lastValue = value;
+    return curriedDefinition;
+  });
+}
+
+class CursorImpl {
+  constructor(element, nextSibling) {
+    this.element = element;
+    this.nextSibling = nextSibling;
+    setLocalDebugType('cursor', this);
+  }
+}
+class ConcreteBounds {
+  constructor(parentNode, first, last) {
+    this.parentNode = parentNode;
+    this.first = first;
+    this.last = last;
+  }
+  parentElement() {
+    return this.parentNode;
+  }
+  firstNode() {
+    return this.first;
+  }
+  lastNode() {
+    return this.last;
+  }
+}
+function move(bounds, reference) {
+  let parent = bounds.parentElement();
+  let first = bounds.firstNode();
+  let last = bounds.lastNode();
+  let current = first;
+  while (true) {
+    let next = current.nextSibling;
+    parent.insertBefore(current, reference);
+    if (current === last) {
+      return next;
+    }
+    current = expect(next);
+  }
+}
+function clear(bounds) {
+  let parent = bounds.parentElement();
+  let first = bounds.firstNode();
+  let last = bounds.lastNode();
+  let current = first;
+  while (true) {
+    let next = current.nextSibling;
+    parent.removeChild(current);
+    if (current === last) {
+      return next;
+    }
+    current = expect(next);
+  }
+}
+
+/** @internal */
+function hasCustomDebugRenderTreeLifecycle(manager) {
+  return 'getDebugCustomRenderTree' in manager;
+}
+
+function resolveComponent(resolver, constants, name, owner) {
+  let definition = resolver?.lookupComponent?.(name, expect(owner)) ?? null;
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+  return constants.resolvedComponent(definition, name);
+}
+
+let GUID = 0;
+class Ref {
+  id = GUID++;
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  get() {
+    return this.value;
+  }
+  release() {
+    this.value = null;
+  }
+  toString() {
+    let label = `Ref ${this.id}`;
+    if (this.value === null) {
+      return `${label} (released)`;
+    } else {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        return `${label}: ${this.value}`;
+      } catch {
+        return label;
+      }
+    }
+  }
+}
+class DebugRenderTreeImpl {
+  stack = new StackImpl();
+  refs = new WeakMap();
+  roots = new Set();
+  nodes = new WeakMap();
+  begin() {
+    this.reset();
+  }
+  create(state, node) {
+    let internalNode = assign({}, node, {
+      bounds: null,
+      refs: new Set()
+    });
+    this.nodes.set(state, internalNode);
+    this.appendChild(internalNode, state);
+    this.enter(state);
+  }
+  update(state) {
+    this.enter(state);
+  }
+  didRender(state, bounds) {
+    this.nodeFor(state).bounds = bounds;
+    this.exit();
+  }
+  willDestroy(state) {
+    expect(this.refs.get(state)).release();
+  }
+  commit() {
+    this.reset();
+  }
+  capture() {
+    return this.captureRefs(this.roots);
+  }
+  reset() {
+    if (this.stack.size !== 0) {
+      // We probably encountered an error during the rendering loop. This will
+      // likely trigger undefined behavior and memory leaks as the error left
+      // things in an inconsistent state. It is recommended that the user
+      // refresh the page.
+
+      // TODO: We could warn here? But this happens all the time in our tests?
+
+      // Clean up the root reference to prevent errors from happening if we
+      // attempt to capture the render tree (Ember Inspector may do this)
+      let root = expect(this.stack.toArray()[0]);
+      let ref = this.refs.get(root);
+      if (ref !== undefined) {
+        this.roots.delete(ref);
+      }
+      while (!this.stack.isEmpty()) {
+        this.stack.pop();
+      }
+    }
+  }
+  enter(state) {
+    this.stack.push(state);
+  }
+  exit() {
+    this.stack.pop();
+  }
+  nodeFor(state) {
+    return expect(this.nodes.get(state));
+  }
+  appendChild(node, state) {
+    let parent = this.stack.current;
+    let ref = new Ref(state);
+    this.refs.set(state, ref);
+    if (parent) {
+      let parentNode = this.nodeFor(parent);
+      parentNode.refs.add(ref);
+      node.parent = parentNode;
+    } else {
+      this.roots.add(ref);
+    }
+  }
+  captureRefs(refs) {
+    let captured = [];
+    refs.forEach(ref => {
+      let state = ref.get();
+      if (state) {
+        captured.push(this.captureNode(`render-node:${ref.id}`, state));
+      } else {
+        refs.delete(ref);
+      }
+    });
+    return captured;
+  }
+  captureNode(id, state) {
+    let node = this.nodeFor(state);
+    let {
+      type,
+      name,
+      args,
+      instance,
+      refs
+    } = node;
+    let template = this.captureTemplate(node);
+    let bounds = this.captureBounds(node);
+    let children = this.captureRefs(refs);
+    return {
+      id,
+      type,
+      name,
+      args: reifyArgsDebug(args),
+      instance,
+      template,
+      bounds,
+      children
+    };
+  }
+  captureTemplate({
+    template
+  }) {
+    return template || null;
+  }
+  captureBounds(node) {
+    let bounds = expect(node.bounds);
+    let parentElement = bounds.parentElement();
+    let firstNode = bounds.firstNode();
+    let lastNode = bounds.lastNode();
+    return {
+      parentElement,
+      firstNode,
+      lastNode
+    };
+  }
+}
+function getDebugName(definition, manager = definition.manager) {
+  return definition.resolvedName ?? definition.debugName ?? manager.getDebugName(definition.state);
+}
+
+function normalizeStringValue(value) {
+  if (isEmpty$1(value)) {
+    return '';
+  }
+  return String(value);
+}
+function shouldCoerce(value) {
+  return isString(value) || isEmpty$1(value) || typeof value === 'boolean' || typeof value === 'number';
+}
+function isEmpty$1(value) {
+  return value === null || value === undefined || typeof value.toString !== 'function';
+}
+function isIndexable(value) {
+  return value !== null && typeof value === 'object';
+}
+function isSafeString(value) {
+  return isIndexable(value) && typeof value['toHTML'] === 'function';
+}
+function isNode(value) {
+  return isIndexable(value) && typeof value['nodeType'] === 'number';
+}
+function isFragment(value) {
+  return isIndexable(value) && value['nodeType'] === 11;
+}
+function isString(value) {
+  return typeof value === 'string';
+}
+
+function createClassListRef(list) {
+  return createComputeRef(() => {
+    let ret = [];
+    for (const ref of list) {
+      let value = normalizeStringValue(typeof ref === 'string' ? ref : valueForRef(ref));
+      if (value) ret.push(value);
+    }
+    return ret.length === 0 ? null : ret.join(' ');
+  });
+}
+
+APPEND_OPCODES.add(VM_CHILD_SCOPE_OP, vm => vm.pushChildScope());
+APPEND_OPCODES.add(VM_POP_SCOPE_OP, vm => vm.popScope());
+APPEND_OPCODES.add(VM_PUSH_DYNAMIC_SCOPE_OP, vm => vm.pushDynamicScope());
+APPEND_OPCODES.add(VM_POP_DYNAMIC_SCOPE_OP, vm => vm.popDynamicScope());
+APPEND_OPCODES.add(VM_CONSTANT_OP, (vm, {
+  op1: other
+}) => {
+  vm.stack.push(vm.constants.getValue(decodeHandle(other)));
+});
+APPEND_OPCODES.add(VM_CONSTANT_REFERENCE_OP, (vm, {
+  op1: other
+}) => {
+  vm.stack.push(createConstRef(vm.constants.getValue(decodeHandle(other))));
+});
+APPEND_OPCODES.add(VM_PRIMITIVE_OP, (vm, {
+  op1: primitive
+}) => {
+  let stack = vm.stack;
+  if (isHandle(primitive)) {
+    // it is a handle which does not already exist on the stack
+    let value = vm.constants.getValue(decodeHandle(primitive));
+    stack.push(value);
+  } else {
+    // is already an encoded immediate or primitive handle
+    stack.push(decodeImmediate(primitive));
+  }
+});
+APPEND_OPCODES.add(VM_PRIMITIVE_REFERENCE_OP, vm => {
+  let stack = vm.stack;
+  let value = check(stack.pop());
+  let ref;
+  if (value === undefined) {
+    ref = UNDEFINED_REFERENCE;
+  } else if (value === null) {
+    ref = NULL_REFERENCE;
+  } else if (value === true) {
+    ref = TRUE_REFERENCE;
+  } else if (value === false) {
+    ref = FALSE_REFERENCE;
+  } else {
+    ref = createPrimitiveRef(value);
+  }
+  stack.push(ref);
+});
+APPEND_OPCODES.add(VM_DUP_OP, (vm, {
+  op1: register,
+  op2: offset
+}) => {
+  let position = check(vm.fetchValue(check(register, CheckRegister))) - offset;
+  vm.stack.dup(position);
+});
+APPEND_OPCODES.add(VM_POP_OP, (vm, {
+  op1: count
+}) => {
+  vm.stack.pop(count);
+});
+APPEND_OPCODES.add(VM_LOAD_OP, (vm, {
+  op1: register
+}) => {
+  vm.load(check(register));
+});
+APPEND_OPCODES.add(VM_FETCH_OP, (vm, {
+  op1: register
+}) => {
+  vm.fetch(check(register));
+});
+APPEND_OPCODES.add(VM_BIND_DYNAMIC_SCOPE_OP, (vm, {
+  op1: _names
+}) => {
+  let names = vm.constants.getArray(_names);
+  vm.bindDynamicScope(names);
+});
+APPEND_OPCODES.add(VM_ENTER_OP, (vm, {
+  op1: args
+}) => {
+  vm.enter(args);
+});
+APPEND_OPCODES.add(VM_EXIT_OP, vm => {
+  vm.exit();
+});
+APPEND_OPCODES.add(VM_PUSH_SYMBOL_TABLE_OP, (vm, {
+  op1: _table
+}) => {
+  let stack = vm.stack;
+  stack.push(vm.constants.getValue(_table));
+});
+APPEND_OPCODES.add(VM_PUSH_BLOCK_SCOPE_OP, vm => {
+  let stack = vm.stack;
+  stack.push(vm.scope());
+});
+APPEND_OPCODES.add(VM_COMPILE_BLOCK_OP, vm => {
+  let stack = vm.stack;
+  let block = stack.pop();
+  if (block) {
+    stack.push(vm.compile(block));
+  } else {
+    stack.push(null);
+  }
+});
+APPEND_OPCODES.add(VM_INVOKE_YIELD_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let handle = check(stack.pop());
+  let scope = check(stack.pop());
+  let table = check(stack.pop());
+  let args = check(stack.pop());
+  if (table === null || handle === null) {
+    // To balance the pop{Frame,Scope}
+    vm.lowlevel.pushFrame();
+    vm.pushScope(scope ?? vm.scope());
+    return;
+  }
+  let invokingScope = expect(scope);
+
+  // If necessary, create a child scope
+  {
+    let locals = table.parameters;
+    let localsCount = locals.length;
+    if (localsCount > 0) {
+      invokingScope = invokingScope.child();
+      for (let i = 0; i < localsCount; i++) {
+        invokingScope.bindSymbol(unwrap(locals[i]), args.at(i));
+      }
+    }
+  }
+  vm.lowlevel.pushFrame();
+  vm.pushScope(invokingScope);
+  vm.call(handle);
+});
+APPEND_OPCODES.add(VM_JUMP_IF_OP, (vm, {
+  op1: target
+}) => {
+  let reference = check(vm.stack.pop());
+  let value = Boolean(valueForRef(reference));
+  if (isConstRef(reference)) {
+    if (value) {
+      vm.lowlevel.goto(target);
+    }
+  } else {
+    if (value) {
+      vm.lowlevel.goto(target);
+    }
+    vm.updateWith(new Assert(reference));
+  }
+});
+APPEND_OPCODES.add(VM_JUMP_UNLESS_OP, (vm, {
+  op1: target
+}) => {
+  let reference = check(vm.stack.pop());
+  let value = Boolean(valueForRef(reference));
+  if (isConstRef(reference)) {
+    if (!value) {
+      vm.lowlevel.goto(target);
+    }
+  } else {
+    if (!value) {
+      vm.lowlevel.goto(target);
+    }
+    vm.updateWith(new Assert(reference));
+  }
+});
+APPEND_OPCODES.add(VM_JUMP_EQ_OP, (vm, {
+  op1: target,
+  op2: comparison
+}) => {
+  let other = check(vm.stack.peek());
+  if (other === comparison) {
+    vm.lowlevel.goto(target);
+  }
+});
+APPEND_OPCODES.add(VM_ASSERT_SAME_OP, vm => {
+  let reference = check(vm.stack.peek());
+  if (!isConstRef(reference)) {
+    vm.updateWith(new Assert(reference));
+  }
+});
+APPEND_OPCODES.add(VM_TO_BOOLEAN_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let valueRef = check(stack.pop());
+  stack.push(createComputeRef(() => toBool(valueForRef(valueRef))));
+});
+class Assert {
+  last;
+  constructor(ref) {
+    this.ref = ref;
+    this.last = valueForRef(ref);
+  }
+  evaluate(vm) {
+    let {
+      last,
+      ref
+    } = this;
+    let current = valueForRef(ref);
+    if (last !== current) {
+      vm.throw();
+    }
+  }
+}
+class AssertFilter {
+  last;
+  constructor(ref, filter) {
+    this.ref = ref;
+    this.filter = filter;
+    this.last = filter(valueForRef(ref));
+  }
+  evaluate(vm) {
+    let {
+      last,
+      ref,
+      filter
+    } = this;
+    let current = filter(valueForRef(ref));
+    if (last !== current) {
+      vm.throw();
+    }
+  }
+}
+class JumpIfNotModifiedOpcode {
+  tag = CONSTANT_TAG;
+  lastRevision = INITIAL;
+  target;
+  finalize(tag, target) {
+    this.target = target;
+    this.didModify(tag);
+  }
+  evaluate(vm) {
+    let {
+      tag,
+      target,
+      lastRevision
+    } = this;
+    if (!vm.alwaysRevalidate && validateTag(tag, lastRevision)) {
+      consumeTag(tag);
+      vm.goto(expect(target));
+    }
+  }
+  didModify(tag) {
+    this.tag = tag;
+    this.lastRevision = valueForTag(this.tag);
+    consumeTag(tag);
+  }
+}
+class BeginTrackFrameOpcode {
+  constructor(debugLabel) {
+    this.debugLabel = debugLabel;
+  }
+  evaluate() {
+    beginTrackFrame(this.debugLabel);
+  }
+}
+class EndTrackFrameOpcode {
+  constructor(target) {
+    this.target = target;
+  }
+  evaluate() {
+    let tag = endTrackFrame();
+    this.target.didModify(tag);
+  }
+}
+
+APPEND_OPCODES.add(VM_TEXT_OP, (vm, {
+  op1: text
+}) => {
+  vm.tree().appendText(vm.constants.getValue(text));
+});
+APPEND_OPCODES.add(VM_COMMENT_OP, (vm, {
+  op1: text
+}) => {
+  vm.tree().appendComment(vm.constants.getValue(text));
+});
+APPEND_OPCODES.add(VM_OPEN_ELEMENT_OP, (vm, {
+  op1: tag
+}) => {
+  vm.tree().openElement(vm.constants.getValue(tag));
+});
+APPEND_OPCODES.add(VM_OPEN_DYNAMIC_ELEMENT_OP, vm => {
+  let tagName = check(valueForRef(check(vm.stack.pop(), CheckReference)));
+  vm.tree().openElement(tagName);
+});
+APPEND_OPCODES.add(VM_PUSH_REMOTE_ELEMENT_OP, vm => {
+  let elementRef = check(vm.stack.pop());
+  let insertBeforeRef = check(vm.stack.pop());
+  let guidRef = check(vm.stack.pop());
+  let element = check(valueForRef(elementRef));
+  let insertBefore = check(valueForRef(insertBeforeRef));
+  let guid = valueForRef(guidRef);
+  if (!isConstRef(elementRef)) {
+    vm.updateWith(new Assert(elementRef));
+  }
+  if (insertBefore !== undefined && !isConstRef(insertBeforeRef)) {
+    vm.updateWith(new Assert(insertBeforeRef));
+  }
+  let block = vm.tree().pushRemoteElement(element, guid, insertBefore);
+  vm.associateDestroyable(block);
+  if (vm.env.debugRenderTree !== undefined) {
+    // Note that there is nothing to update – when the args for an
+    // {{#in-element}} changes it gets torn down and a new one is
+    // re-created/rendered in its place (see the `Assert`s above)
+    let args = createCapturedArgs(insertBefore === undefined ? {} : {
+      insertBefore: insertBeforeRef
+    }, [elementRef]);
+    vm.env.debugRenderTree.create(block, {
+      type: 'keyword',
+      name: 'in-element',
+      args,
+      instance: null
+    });
+    registerDestructor(block, () => {
+      vm.env.debugRenderTree?.willDestroy(block);
+    });
+  }
+});
+APPEND_OPCODES.add(VM_POP_REMOTE_ELEMENT_OP, vm => {
+  let bounds = vm.tree().popRemoteElement();
+  if (vm.env.debugRenderTree !== undefined) {
+    // The RemoteBlock is also its bounds
+    vm.env.debugRenderTree.didRender(bounds, bounds);
+  }
+});
+APPEND_OPCODES.add(VM_FLUSH_ELEMENT_OP, vm => {
+  let operations = check(vm.fetchValue($t0));
+  let modifiers = null;
+  if (operations) {
+    modifiers = operations.flush(vm);
+    vm.loadValue($t0, null);
+  }
+  vm.tree().flushElement(modifiers);
+});
+APPEND_OPCODES.add(VM_CLOSE_ELEMENT_OP, vm => {
+  let modifiers = vm.tree().closeElement();
+  if (modifiers !== null) {
+    modifiers.forEach(modifier => {
+      vm.env.scheduleInstallModifier(modifier);
+      const d = modifier.manager.getDestroyable(modifier.state);
+      if (d !== null) {
+        vm.associateDestroyable(d);
+      }
+    });
+  }
+});
+APPEND_OPCODES.add(VM_MODIFIER_OP, (vm, {
+  op1: handle
+}) => {
+  let args = check(vm.stack.pop());
+  if (!vm.env.isInteractive) {
+    return;
+  }
+  let owner = vm.getOwner();
+  let definition = vm.constants.getValue(handle);
+  let {
+    manager
+  } = definition;
+  let {
+    constructing
+  } = vm.tree();
+  let capturedArgs = args.capture();
+  let state = manager.create(owner, expect(constructing), definition.state, capturedArgs);
+  let instance = {
+    manager,
+    state,
+    definition
+  };
+  let operations = expect(check(vm.fetchValue($t0)));
+  operations.addModifier(vm, instance, capturedArgs);
+  let tag = manager.getTag(state);
+  if (tag !== null) {
+    consumeTag(tag);
+    return vm.updateWith(new UpdateModifierOpcode(tag, instance));
+  }
+});
+APPEND_OPCODES.add(VM_DYNAMIC_MODIFIER_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let ref = check(stack.pop());
+  let args = check(stack.pop());
+  if (!vm.env.isInteractive) {
+    return;
+  }
+  let capturedArgs = args.capture();
+  let {
+    positional: outerPositional,
+    named: outerNamed
+  } = capturedArgs;
+  let {
+    constructing
+  } = vm.tree();
+  let initialOwner = vm.getOwner();
+  let instanceRef = createComputeRef(() => {
+    let value = valueForRef(ref);
+    let owner;
+    if (!isIndexable$1(value)) {
+      return;
+    }
+    let hostDefinition;
+    if (isCurriedType(value, CURRIED_MODIFIER)) {
+      let {
+        definition: resolvedDefinition,
+        owner: curriedOwner,
+        positional,
+        named
+      } = resolveCurriedValue(value);
+      hostDefinition = resolvedDefinition;
+      owner = curriedOwner;
+      if (positional !== undefined) {
+        capturedArgs.positional = positional.concat(outerPositional);
+      }
+      if (named !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        capturedArgs.named = Object.assign({}, ...named, outerNamed);
+      }
+    } else {
+      hostDefinition = value;
+      owner = initialOwner;
+    }
+    let manager = getInternalModifierManager(hostDefinition);
+    if (manager === null) {
+      {
+        throw new Error('BUG: modifier manager expected');
+      }
+    }
+    let definition = {
+      resolvedName: null,
+      manager,
+      state: hostDefinition
+    };
+    let state = manager.create(owner, expect(constructing), definition.state, capturedArgs);
+    return {
+      manager,
+      state,
+      definition
+    };
+  });
+  let instance = valueForRef(instanceRef);
+  let tag = null;
+  if (instance !== undefined) {
+    let operations = expect(check(vm.fetchValue($t0)));
+    operations.addModifier(vm, instance, capturedArgs);
+    tag = instance.manager.getTag(instance.state);
+    if (tag !== null) {
+      consumeTag(tag);
+    }
+  }
+  if (!isConstRef(ref) || tag) {
+    return vm.updateWith(new UpdateDynamicModifierOpcode(tag, instance, instanceRef));
+  }
+});
+class UpdateModifierOpcode {
+  lastUpdated;
+  constructor(tag, modifier) {
+    this.tag = tag;
+    this.modifier = modifier;
+    this.lastUpdated = valueForTag(tag);
+  }
+  evaluate(vm) {
+    let {
+      modifier,
+      tag,
+      lastUpdated
+    } = this;
+    consumeTag(tag);
+    if (!validateTag(tag, lastUpdated)) {
+      vm.env.scheduleUpdateModifier(modifier);
+      this.lastUpdated = valueForTag(tag);
+    }
+  }
+}
+class UpdateDynamicModifierOpcode {
+  lastUpdated;
+  constructor(tag, instance, instanceRef) {
+    this.tag = tag;
+    this.instance = instance;
+    this.instanceRef = instanceRef;
+    this.lastUpdated = valueForTag(tag ?? CURRENT_TAG);
+  }
+  evaluate(vm) {
+    let {
+      tag,
+      lastUpdated,
+      instance,
+      instanceRef
+    } = this;
+    let newInstance = valueForRef(instanceRef);
+    if (newInstance !== instance) {
+      if (instance !== undefined) {
+        let destroyable = instance.manager.getDestroyable(instance.state);
+        if (destroyable !== null) {
+          destroy(destroyable);
+        }
+      }
+      if (newInstance !== undefined) {
+        let {
+          manager,
+          state
+        } = newInstance;
+        let destroyable = manager.getDestroyable(state);
+        if (destroyable !== null) {
+          associateDestroyableChild(this, destroyable);
+        }
+        tag = manager.getTag(state);
+        if (tag !== null) {
+          this.lastUpdated = valueForTag(tag);
+        }
+        this.tag = tag;
+        vm.env.scheduleInstallModifier(newInstance);
+      }
+      this.instance = newInstance;
+    } else if (tag !== null && !validateTag(tag, lastUpdated)) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      vm.env.scheduleUpdateModifier(instance);
+      this.lastUpdated = valueForTag(tag);
+    }
+    if (tag !== null) {
+      consumeTag(tag);
+    }
+  }
+}
+APPEND_OPCODES.add(VM_STATIC_ATTR_OP, (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.tree().setStaticAttribute(name, value, namespace);
+});
+APPEND_OPCODES.add(VM_DYNAMIC_ATTR_OP, (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());
+  let value = valueForRef(reference);
+  let namespace = _namespace ? vm.constants.getValue(_namespace) : null;
+  let attribute = vm.tree().setDynamicAttribute(name, value, trusting, namespace);
+  if (!isConstRef(reference)) {
+    vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute, vm.env));
+  }
+});
+class UpdateDynamicAttributeOpcode {
+  updateRef;
+  constructor(reference, attribute, env) {
+    let initialized = false;
+    this.updateRef = createComputeRef(() => {
+      let value = valueForRef(reference);
+      if (initialized) {
+        attribute.update(value, env);
+      } else {
+        initialized = true;
+      }
+    });
+    valueForRef(this.updateRef);
+  }
+  evaluate() {
+    valueForRef(this.updateRef);
+  }
+}
+
+/**
+ * The VM creates a new ComponentInstance data structure for every component
+ * invocation it encounters.
+ *
+ * Similar to how a ComponentDefinition contains state about all components of a
+ * particular type, a ComponentInstance contains state specific to a particular
+ * instance of a component type. It also contains a pointer back to its
+ * component type's ComponentDefinition.
+ */
+
+APPEND_OPCODES.add(VM_PUSH_COMPONENT_DEFINITION_OP, (vm, {
+  op1: handle
+}) => {
+  let definition = vm.constants.getValue(handle);
+  let {
+    manager,
+    capabilities
+  } = definition;
+  let instance = {
+    definition,
+    manager,
+    capabilities,
+    state: null,
+    handle: null,
+    table: null,
+    lookup: null
+  };
+  vm.stack.push(instance);
+});
+APPEND_OPCODES.add(VM_RESOLVE_DYNAMIC_COMPONENT_OP, (vm, {
+  op1: _isStrict
+}) => {
+  let stack = vm.stack;
+  let ref = check(stack.pop());
+  let component = check(valueForRef(ref));
+  let constants = vm.constants;
+  let owner = vm.getOwner();
+  constants.getValue(_isStrict);
+  vm.loadValue($t1, null); // Clear the temp register
+
+  let definition;
+  if (typeof component === 'string') {
+    let resolvedDefinition = resolveComponent(vm.context.resolver, constants, component, owner);
+    definition = expect(resolvedDefinition);
+  } else if (isCurriedValue(component)) {
+    definition = component;
+  } else {
+    definition = constants.component(component, owner);
+  }
+  stack.push(definition);
+});
+APPEND_OPCODES.add(VM_RESOLVE_CURRIED_COMPONENT_OP, vm => {
+  let stack = vm.stack;
+  let ref = check(stack.pop());
+  let value = valueForRef(ref);
+  let constants = vm.constants;
+  let definition;
+  if (isCurriedValue(value)) {
+    definition = value;
+  } else {
+    definition = constants.component(value, vm.getOwner(), true);
+  }
+  stack.push(definition);
+});
+APPEND_OPCODES.add(VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let definition = stack.pop();
+  let capabilities, manager;
+  if (isCurriedValue(definition)) {
+    manager = capabilities = null;
+  } else {
+    manager = definition.manager;
+    capabilities = definition.capabilities;
+  }
+  stack.push({
+    definition,
+    capabilities,
+    manager,
+    state: null,
+    handle: null,
+    table: null
+  });
+});
+APPEND_OPCODES.add(VM_PUSH_ARGS_OP, (vm, {
+  op1: _names,
+  op2: _blockNames,
+  op3: flags
+}) => {
+  let stack = vm.stack;
+  let names = vm.constants.getArray(_names);
+  let positionalCount = flags >> 4;
+  let atNames = flags & 0b1000;
+  let blockNames = flags & 0b0111 ? vm.constants.getArray(_blockNames) : EMPTY_STRING_ARRAY;
+  vm.args.setup(stack, names, blockNames, positionalCount, !!atNames);
+  stack.push(vm.args);
+});
+APPEND_OPCODES.add(VM_PUSH_EMPTY_ARGS_OP, vm => {
+  let {
+    stack
+  } = vm;
+  stack.push(vm.args.empty(stack));
+});
+APPEND_OPCODES.add(VM_CAPTURE_ARGS_OP, vm => {
+  let stack = vm.stack;
+  let args = check(stack.pop());
+  let capturedArgs = args.capture();
+  stack.push(capturedArgs);
+});
+APPEND_OPCODES.add(VM_PREPARE_ARGS_OP, (vm, {
+  op1: register
+}) => {
+  let stack = vm.stack;
+  let instance = vm.fetchValue(check(register));
+  let args = check(stack.pop());
+  let {
+    definition
+  } = instance;
+  if (isCurriedType(definition, CURRIED_COMPONENT)) {
+    assert(!definition.manager);
+    let constants = vm.constants;
+    let {
+      definition: resolvedDefinition,
+      owner,
+      resolved,
+      positional,
+      named
+    } = resolveCurriedValue(definition);
+    if (resolved) {
+      definition = resolvedDefinition;
+    } else if (typeof resolvedDefinition === 'string') {
+      let resolvedValue = vm.context.resolver?.lookupComponent?.(resolvedDefinition, owner) ?? null;
+      definition = constants.resolvedComponent(expect(resolvedValue), resolvedDefinition);
+    } else {
+      definition = constants.component(resolvedDefinition, owner);
+    }
+    if (named !== undefined) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      args.named.merge(assign({}, ...named));
+    }
+    if (positional !== undefined) {
+      args.realloc(positional.length);
+      args.positional.prepend(positional);
+    }
+    let {
+      manager
+    } = definition;
+    instance.definition = definition;
+    instance.manager = manager;
+    instance.capabilities = definition.capabilities;
+
+    // Save off the owner that this component was curried with. Later on,
+    // we'll fetch the value of this register and set it as the owner on the
+    // new root scope.
+    vm.loadValue($t1, owner);
+  }
+  let {
+    manager,
+    state
+  } = definition;
+  let capabilities = instance.capabilities;
+  if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.prepareArgs)) {
+    stack.push(args);
+    return;
+  }
+  let blocks = args.blocks.values;
+  let blockNames = args.blocks.names;
+  let preparedArgs = manager.prepareArgs(state, args);
+  if (preparedArgs) {
+    args.clear();
+    for (let i = 0; i < blocks.length; i++) {
+      stack.push(blocks[i]);
+    }
+    let {
+      positional,
+      named
+    } = preparedArgs;
+    let positionalCount = positional.length;
+    for (let i = 0; i < positionalCount; i++) {
+      stack.push(positional[i]);
+    }
+    let names = Object.keys(named);
+    for (let i = 0; i < names.length; i++) {
+      stack.push(named[unwrap(names[i])]);
+    }
+    args.setup(stack, names, blockNames, positionalCount, false);
+  }
+  stack.push(args);
+});
+APPEND_OPCODES.add(VM_CREATE_COMPONENT_OP, (vm, {
+  op1: flags
+}) => {
+  let instance = check(vm.fetchValue($s0));
+  let {
+    definition,
+    manager,
+    capabilities
+  } = instance;
+  if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.createInstance)) {
+    // TODO: Closure and Main components are always invoked dynamically, so this
+    // opcode may run even if this capability is not enabled. In the future we
+    // should handle this in a better way.
+    return;
+  }
+  let dynamicScope = null;
+  if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicScope)) {
+    dynamicScope = vm.dynamicScope();
+  }
+  let hasDefaultBlock = flags & 1;
+  let args = null;
+  if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.createArgs)) {
+    args = check(vm.stack.peek());
+  }
+  let self = null;
+  if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.createCaller)) {
+    self = vm.getSelf();
+  }
+  let state = manager.create(vm.getOwner(), definition.state, args, vm.env, dynamicScope, self, !!hasDefaultBlock);
+
+  // We want to reuse the `state` POJO here, because we know that the opcodes
+  // only transition at exactly one place.
+  instance.state = state;
+  if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.updateHook)) {
+    vm.updateWith(new UpdateComponentOpcode(state, manager, dynamicScope));
+  }
+});
+APPEND_OPCODES.add(VM_REGISTER_COMPONENT_DESTRUCTOR_OP, (vm, {
+  op1: register
+}) => {
+  let {
+    manager,
+    state,
+    capabilities
+  } = check(vm.fetchValue(check(register, CheckRegister)));
+  let d = manager.getDestroyable(state);
+  if (d) vm.associateDestroyable(d);
+});
+APPEND_OPCODES.add(VM_BEGIN_COMPONENT_TRANSACTION_OP, (vm, {
+  op1: register
+}) => {
+  let name;
+  vm.beginCacheGroup(name);
+  vm.tree().pushAppendingBlock();
+});
+APPEND_OPCODES.add(VM_PUT_COMPONENT_OPERATIONS_OP, vm => {
+  vm.loadValue($t0, new ComponentElementOperations());
+});
+APPEND_OPCODES.add(VM_COMPONENT_ATTR_OP, (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());
+  let namespace = _namespace ? vm.constants.getValue(_namespace) : null;
+  check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations)).setAttribute(name, reference, trusting, namespace);
+});
+APPEND_OPCODES.add(VM_STATIC_COMPONENT_ATTR_OP, (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;
+  check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations)).setStaticAttribute(name, value, namespace);
+});
+class ComponentElementOperations {
+  attributes = dict();
+  classes = [];
+  modifiers = [];
+  setAttribute(name, value, trusting, namespace) {
+    let deferred = {
+      value,
+      namespace,
+      trusting
+    };
+    if (name === 'class') {
+      this.classes.push(value);
+    }
+    this.attributes[name] = deferred;
+  }
+  setStaticAttribute(name, value, namespace) {
+    let deferred = {
+      value,
+      namespace
+    };
+    if (name === 'class') {
+      this.classes.push(value);
+    }
+    this.attributes[name] = deferred;
+  }
+  addModifier(vm, modifier, capturedArgs) {
+    this.modifiers.push(modifier);
+    if (vm.env.debugRenderTree !== undefined) {
+      const {
+        manager,
+        definition,
+        state
+      } = modifier;
+
+      // TODO: we need a stable object for the debugRenderTree as the key, add support for
+      // the case where the state is a primitive, or if in practice we always have/require
+      // an object, then change the internal types to reflect that
+      if (state === null || typeof state !== 'object' && typeof state !== 'function') {
+        return;
+      }
+      let {
+        element,
+        constructing
+      } = vm.tree();
+      let name = definition.resolvedName ?? manager.getDebugName(definition.state);
+      let instance = manager.getDebugInstance(state);
+      let bounds = new ConcreteBounds(element, constructing, constructing);
+      vm.env.debugRenderTree.create(state, {
+        type: 'modifier',
+        name,
+        args: capturedArgs,
+        instance
+      });
+      vm.env.debugRenderTree.didRender(state, bounds);
+
+      // For tearing down the debugRenderTree
+      vm.associateDestroyable(state);
+      vm.updateWith(new DebugRenderTreeUpdateOpcode(state));
+      vm.updateWith(new DebugRenderTreeDidRenderOpcode(state, bounds));
+      registerDestructor(state, () => {
+        vm.env.debugRenderTree?.willDestroy(state);
+      });
+    }
+  }
+  flush(vm) {
+    let type;
+    let attributes = this.attributes;
+    for (let name in this.attributes) {
+      if (name === 'type') {
+        type = attributes[name];
+        continue;
+      }
+      let attr = unwrap(this.attributes[name]);
+      if (name === 'class') {
+        setDeferredAttr(vm, 'class', mergeClasses(this.classes), attr.namespace, attr.trusting);
+      } else {
+        setDeferredAttr(vm, name, attr.value, attr.namespace, attr.trusting);
+      }
+    }
+    if (type !== undefined) {
+      setDeferredAttr(vm, 'type', type.value, type.namespace, type.trusting);
+    }
+    return this.modifiers;
+  }
+}
+function mergeClasses(classes) {
+  if (classes.length === 0) {
+    return '';
+  }
+  if (classes.length === 1) {
+    return unwrap(classes[0]);
+  }
+  if (allStringClasses(classes)) {
+    return classes.join(' ');
+  }
+  return createClassListRef(classes);
+}
+function allStringClasses(classes) {
+  return classes.every(c => typeof c === 'string');
+}
+function setDeferredAttr(vm, name, value, namespace, trusting = false) {
+  if (typeof value === 'string') {
+    vm.tree().setStaticAttribute(name, value, namespace);
+  } else {
+    let attribute = vm.tree().setDynamicAttribute(name, valueForRef(value), trusting, namespace);
+    if (!isConstRef(value)) {
+      vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute, vm.env));
+    }
+  }
+}
+APPEND_OPCODES.add(VM_DID_CREATE_ELEMENT_OP, (vm, {
+  op1: register
+}) => {
+  let {
+    definition,
+    state
+  } = check(vm.fetchValue(check(register, CheckRegister)));
+  let {
+    manager
+  } = definition;
+  let operations = check(vm.fetchValue($t0));
+  manager.didCreateElement(state, expect(vm.tree().constructing), operations);
+});
+APPEND_OPCODES.add(VM_GET_COMPONENT_SELF_OP, (vm, {
+  op1: register,
+  op2: _names
+}) => {
+  let instance = check(vm.fetchValue(check(register, CheckRegister)));
+  let {
+    definition,
+    state
+  } = instance;
+  let {
+    manager
+  } = definition;
+  let selfRef = manager.getSelf(state);
+  if (vm.env.debugRenderTree !== undefined) {
+    let instance = check(vm.fetchValue(check(register, CheckRegister)));
+    let {
+      definition,
+      manager
+    } = instance;
+    let args;
+    if (vm.stack.peek() === vm.args) {
+      args = vm.args.capture();
+    } else {
+      let names = vm.constants.getArray(_names);
+      vm.args.setup(vm.stack, names, [], 0, true);
+      args = vm.args.capture();
+    }
+    let moduleName;
+    let compilable = definition.compilable;
+    if (compilable === null) {
+      assert(managerHasCapability(manager, instance.capabilities, InternalComponentCapabilities.dynamicLayout));
+      let resolver = vm.context.resolver;
+      compilable = resolver === null ? null : manager.getDynamicLayout(state, resolver);
+      if (compilable !== null) {
+        moduleName = compilable.moduleName;
+      } else {
+        moduleName = '__default__.hbs';
+      }
+    } else {
+      moduleName = compilable.moduleName;
+    }
+
+    // For tearing down the debugRenderTree
+    vm.associateDestroyable(instance);
+    if (hasCustomDebugRenderTreeLifecycle(manager)) {
+      let nodes = manager.getDebugCustomRenderTree(instance.definition.state, instance.state, args, moduleName);
+      nodes.forEach(node => {
+        let {
+          bucket
+        } = node;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+        vm.env.debugRenderTree.create(bucket, node);
+        registerDestructor(instance, () => {
+          vm.env.debugRenderTree?.willDestroy(bucket);
+        });
+        vm.updateWith(new DebugRenderTreeUpdateOpcode(bucket));
+      });
+    } else {
+      let name = getDebugName(definition, manager);
+      vm.env.debugRenderTree.create(instance, {
+        type: 'component',
+        name,
+        args,
+        template: moduleName,
+        instance: valueForRef(selfRef)
+      });
+      registerDestructor(instance, () => {
+        vm.env.debugRenderTree?.willDestroy(instance);
+      });
+      vm.updateWith(new DebugRenderTreeUpdateOpcode(instance));
+    }
+  }
+  vm.stack.push(selfRef);
+});
+APPEND_OPCODES.add(VM_GET_COMPONENT_TAG_NAME_OP, (vm, {
+  op1: register
+}) => {
+  let {
+    definition,
+    state
+  } = check(vm.fetchValue(check(register, CheckRegister)));
+  let {
+    manager
+  } = definition;
+  let tagName = manager.getTagName(state);
+
+  // User provided value from JS, so we don't bother to encode
+  vm.stack.push(tagName);
+});
+
+// Dynamic Invocation Only
+APPEND_OPCODES.add(VM_GET_COMPONENT_LAYOUT_OP, (vm, {
+  op1: register
+}) => {
+  let instance = check(vm.fetchValue(check(register, CheckRegister)));
+  let {
+    manager,
+    definition
+  } = instance;
+  let {
+    stack
+  } = vm;
+  let {
+    compilable
+  } = definition;
+  if (compilable === null) {
+    let {
+      capabilities
+    } = instance;
+    assert(managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout));
+    let resolver = vm.context.resolver;
+    compilable = resolver === null ? null : manager.getDynamicLayout(instance.state, resolver);
+    if (compilable === null) {
+      if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped)) {
+        compilable = unwrapTemplate(vm.constants.defaultTemplate).asWrappedLayout();
+      } else {
+        compilable = unwrapTemplate(vm.constants.defaultTemplate).asLayout();
+      }
+    }
+  }
+  let handle = compilable.compile(vm.context);
+  stack.push(compilable.symbolTable);
+  stack.push(handle);
+});
+APPEND_OPCODES.add(VM_MAIN_OP, (vm, {
+  op1: register
+}) => {
+  let definition = check(vm.stack.pop());
+  let invocation = check(vm.stack.pop());
+  let {
+    manager,
+    capabilities
+  } = definition;
+  let state = {
+    definition,
+    manager,
+    capabilities,
+    state: null,
+    handle: invocation.handle,
+    table: invocation.symbolTable,
+    lookup: null
+  };
+  vm.loadValue(check(register), state);
+});
+APPEND_OPCODES.add(VM_POPULATE_LAYOUT_OP, (vm, {
+  op1: register
+}) => {
+  let {
+    stack
+  } = vm;
+
+  // In import.meta.env.DEV handles could be ErrHandle objects
+  let handle = check(stack.pop());
+  let table = check(stack.pop());
+  let state = check(vm.fetchValue(check(register, CheckRegister)));
+  state.handle = handle;
+  state.table = table;
+});
+APPEND_OPCODES.add(VM_VIRTUAL_ROOT_SCOPE_OP, (vm, {
+  op1: register
+}) => {
+  let {
+    table,
+    manager,
+    capabilities,
+    state
+  } = check(vm.fetchValue(check(register, CheckRegister)));
+  let owner;
+  if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.hasSubOwner)) {
+    owner = manager.getOwner(state);
+    vm.loadValue($t1, null); // Clear the temp register
+  } else {
+    // Check the temp register to see if an owner was resolved from currying
+    owner = vm.fetchValue($t1);
+    if (owner === null) {
+      // If an owner wasn't found, default to using the current owner. This
+      // will happen for normal dynamic component invocation,
+      // e.g. <SomeClassicEmberComponent/>
+      owner = vm.getOwner();
+    } else {
+      // Else the owner was found, so clear the temp register. This will happen
+      // if we are loading a curried component, e.g. <@someCurriedComponent/>
+      vm.loadValue($t1, null);
+    }
+  }
+  vm.pushRootScope(table.symbols.length + 1, owner);
+});
+APPEND_OPCODES.add(VM_SET_NAMED_VARIABLES_OP, (vm, {
+  op1: register
+}) => {
+  let state = check(vm.fetchValue(check(register, CheckRegister)));
+  let scope = vm.scope();
+  let args = check(vm.stack.peek());
+  let callerNames = args.named.atNames;
+  for (let i = callerNames.length - 1; i >= 0; i--) {
+    let atName = unwrap(callerNames[i]);
+    let symbol = state.table.symbols.indexOf(atName);
+    let value = args.named.get(atName, true);
+    if (symbol !== -1) scope.bindSymbol(symbol + 1, value);
+    if (state.lookup) state.lookup[atName] = value;
+  }
+});
+function bindBlock(symbolName, blockName, state, blocks, vm) {
+  let symbol = state.table.symbols.indexOf(symbolName);
+  let block = blocks.get(blockName);
+  if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
+  if (state.lookup) state.lookup[symbolName] = block;
+}
+APPEND_OPCODES.add(VM_SET_BLOCKS_OP, (vm, {
+  op1: register
+}) => {
+  let state = check(vm.fetchValue(check(register, CheckRegister)));
+  let {
+    blocks
+  } = check(vm.stack.peek());
+  for (const [i] of enumerate(blocks.names)) {
+    bindBlock(unwrap(blocks.symbolNames[i]), unwrap(blocks.names[i]), state, blocks, vm);
+  }
+});
+
+// Dynamic Invocation Only
+APPEND_OPCODES.add(VM_INVOKE_COMPONENT_LAYOUT_OP, (vm, {
+  op1: register
+}) => {
+  let state = check(vm.fetchValue(check(register, CheckRegister)));
+  vm.call(state.handle);
+});
+APPEND_OPCODES.add(VM_DID_RENDER_LAYOUT_OP, (vm, {
+  op1: register
+}) => {
+  let instance = check(vm.fetchValue(check(register, CheckRegister)));
+  let {
+    manager,
+    state,
+    capabilities
+  } = instance;
+  let bounds = vm.tree().popBlock();
+  if (vm.env.debugRenderTree !== undefined) {
+    if (hasCustomDebugRenderTreeLifecycle(manager)) {
+      let nodes = manager.getDebugCustomRenderTree(instance.definition.state, state, EMPTY_ARGS);
+      nodes.reverse().forEach(node => {
+        let {
+          bucket
+        } = node;
+
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+        vm.env.debugRenderTree.didRender(bucket, bounds);
+        vm.updateWith(new DebugRenderTreeDidRenderOpcode(bucket, bounds));
+      });
+    } else {
+      vm.env.debugRenderTree.didRender(instance, bounds);
+      vm.updateWith(new DebugRenderTreeDidRenderOpcode(instance, bounds));
+    }
+  }
+  if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.createInstance)) {
+    let mgr = check(manager);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call -- @fixme
+    mgr.didRenderLayout(state, bounds);
+    vm.env.didCreate(instance);
+    vm.updateWith(new DidUpdateLayoutOpcode(instance, bounds));
+  }
+});
+APPEND_OPCODES.add(VM_COMMIT_COMPONENT_TRANSACTION_OP, vm => {
+  vm.commitCacheGroup();
+});
+class UpdateComponentOpcode {
+  constructor(component, manager, dynamicScope) {
+    this.component = component;
+    this.manager = manager;
+    this.dynamicScope = dynamicScope;
+  }
+  evaluate(_vm) {
+    let {
+      component,
+      manager,
+      dynamicScope
+    } = this;
+    manager.update(component, dynamicScope);
+  }
+}
+class DidUpdateLayoutOpcode {
+  constructor(component, bounds) {
+    this.component = component;
+    this.bounds = bounds;
+  }
+  evaluate(vm) {
+    let {
+      component,
+      bounds
+    } = this;
+    let {
+      manager,
+      state
+    } = component;
+    manager.didUpdateLayout(state, bounds);
+    vm.env.didUpdate(component);
+  }
+}
+class DebugRenderTreeUpdateOpcode {
+  constructor(bucket) {
+    this.bucket = bucket;
+  }
+  evaluate(vm) {
+    vm.env.debugRenderTree?.update(this.bucket);
+  }
+}
+class DebugRenderTreeDidRenderOpcode {
+  constructor(bucket, bounds) {
+    this.bucket = bucket;
+    this.bounds = bounds;
+  }
+  evaluate(vm) {
+    vm.env.debugRenderTree?.didRender(this.bucket, this.bounds);
+  }
+}
+
+class ReferenceChecker {
+  validate(value) {
+    return typeof value === 'object' && value !== null && REFERENCE in value;
+  }
+  expected() {
+    return `Reference`;
+  }
+}
+const CheckReference = new ReferenceChecker();
+
+/*
+  The calling convention is:
+
+  * 0-N block arguments at the bottom
+  * 0-N positional arguments next (left-to-right)
+  * 0-N named arguments next
+*/
+
+class VMArgumentsImpl {
+  stack = null;
+  positional = new PositionalArgumentsImpl();
+  named = new NamedArgumentsImpl();
+  blocks = new BlockArgumentsImpl();
+  constructor() {
+    setLocalDebugType('args', this);
+  }
+  empty(stack) {
+    let base = stack.registers[$sp] + 1;
+    this.named.empty(stack, base);
+    this.positional.empty(stack, base);
+    this.blocks.empty(stack, base);
+    return this;
+  }
+  setup(stack, names, blockNames, positionalCount, atNames) {
+    this.stack = stack;
+
+    /*
+           | ... | blocks      | positional  | named |
+           | ... | b0    b1    | p0 p1 p2 p3 | n0 n1 |
+     index | ... | 4/5/6 7/8/9 | 10 11 12 13 | 14 15 |
+                   ^             ^             ^  ^
+                 bbase         pbase       nbase  sp
+    */
+
+    let named = this.named;
+    let namedCount = names.length;
+    let namedBase = stack.registers[$sp] - namedCount + 1;
+    named.setup(stack, namedBase, namedCount, names, atNames);
+    let positional = this.positional;
+    let positionalBase = namedBase - positionalCount;
+    positional.setup(stack, positionalBase, positionalCount);
+    let blocks = this.blocks;
+    let blocksCount = blockNames.length;
+    let blocksBase = positionalBase - blocksCount * 3;
+    blocks.setup(stack, blocksBase, blocksCount, blockNames);
+  }
+  get base() {
+    return this.blocks.base;
+  }
+  get length() {
+    return this.positional.length + this.named.length + this.blocks.length * 3;
+  }
+  at(pos) {
+    return this.positional.at(pos);
+  }
+  realloc(offset) {
+    let {
+      stack
+    } = this;
+    if (offset > 0 && stack !== null) {
+      let {
+        positional,
+        named
+      } = this;
+      let newBase = positional.base + offset;
+      let length = positional.length + named.length;
+      for (let i = length - 1; i >= 0; i--) {
+        stack.copy(i + positional.base, i + newBase);
+      }
+      positional.base += offset;
+      named.base += offset;
+      stack.registers[$sp] += offset;
+    }
+  }
+  capture() {
+    let positional = this.positional.length === 0 ? EMPTY_POSITIONAL : this.positional.capture();
+    let named = this.named.length === 0 ? EMPTY_NAMED : this.named.capture();
+    return {
+      named,
+      positional
+    };
+  }
+  clear() {
+    let {
+      stack,
+      length
+    } = this;
+    if (length > 0 && stack !== null) stack.pop(length);
+  }
+}
+const EMPTY_REFERENCES = emptyArray();
+class PositionalArgumentsImpl {
+  base = 0;
+  length = 0;
+  stack = null;
+  _references = null;
+  constructor() {
+    setLocalDebugType('args:positional', this);
+  }
+  empty(stack, base) {
+    this.stack = stack;
+    this.base = base;
+    this.length = 0;
+    this._references = EMPTY_REFERENCES;
+  }
+  setup(stack, base, length) {
+    this.stack = stack;
+    this.base = base;
+    this.length = length;
+    if (length === 0) {
+      this._references = EMPTY_REFERENCES;
+    } else {
+      this._references = null;
+    }
+  }
+  at(position) {
+    let {
+      base,
+      length,
+      stack
+    } = this;
+    if (position < 0 || position >= length) {
+      return UNDEFINED_REFERENCE;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+    return check(stack.get(position, base));
+  }
+  capture() {
+    return this.references;
+  }
+  prepend(other) {
+    let additions = other.length;
+    if (additions > 0) {
+      let {
+        base,
+        length,
+        stack
+      } = this;
+      this.base = base = base - additions;
+      this.length = length + additions;
+      for (let i = 0; i < additions; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+        stack.set(other[i], i, base);
+      }
+      this._references = null;
+    }
+  }
+  get references() {
+    let references = this._references;
+    if (!references) {
+      let {
+        stack,
+        base,
+        length
+      } = this;
+
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      references = this._references = stack.slice(base, base + length);
+    }
+    return references;
+  }
+}
+class NamedArgumentsImpl {
+  base = 0;
+  length = 0;
+  _references = null;
+  _names = EMPTY_STRING_ARRAY;
+  _atNames = EMPTY_STRING_ARRAY;
+  constructor() {
+    setLocalDebugType('args:named', this);
+  }
+  empty(stack, base) {
+    this.stack = stack;
+    this.base = base;
+    this.length = 0;
+    this._references = EMPTY_REFERENCES;
+    this._names = EMPTY_STRING_ARRAY;
+    this._atNames = EMPTY_STRING_ARRAY;
+  }
+  setup(stack, base, length, names, atNames) {
+    this.stack = stack;
+    this.base = base;
+    this.length = length;
+    if (length === 0) {
+      this._references = EMPTY_REFERENCES;
+      this._names = EMPTY_STRING_ARRAY;
+      this._atNames = EMPTY_STRING_ARRAY;
+    } else {
+      this._references = null;
+      if (atNames) {
+        this._names = null;
+        this._atNames = names;
+      } else {
+        this._names = names;
+        this._atNames = null;
+      }
+    }
+  }
+  get names() {
+    let names = this._names;
+    if (!names) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      names = this._names = this._atNames.map(this.toSyntheticName);
+    }
+    return names;
+  }
+  get atNames() {
+    let atNames = this._atNames;
+    if (!atNames) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      atNames = this._atNames = this._names.map(this.toAtName);
+    }
+    return atNames;
+  }
+  has(name) {
+    return this.names.indexOf(name) !== -1;
+  }
+  get(name, atNames = false) {
+    let {
+      base,
+      stack
+    } = this;
+    let names = atNames ? this.atNames : this.names;
+    let idx = names.indexOf(name);
+    if (idx === -1) {
+      return UNDEFINED_REFERENCE;
+    }
+    let ref = stack.get(idx, base);
+    {
+      return ref;
+    }
+  }
+  capture() {
+    let {
+      names,
+      references
+    } = this;
+    let map = dict();
+    for (const [i, name] of enumerate(names)) {
+      {
+        map[name] = unwrap(references[i]);
+      }
+    }
+    return map;
+  }
+  merge(other) {
+    let keys = Object.keys(other);
+    if (keys.length > 0) {
+      let {
+        names,
+        length,
+        stack
+      } = this;
+      let newNames = names.slice();
+      for (const name of keys) {
+        let idx = newNames.indexOf(name);
+        if (idx === -1) {
+          length = newNames.push(name);
+          stack.push(other[name]);
+        }
+      }
+      this.length = length;
+      this._references = null;
+      this._names = newNames;
+      this._atNames = null;
+    }
+  }
+  get references() {
+    let references = this._references;
+    if (!references) {
+      let {
+        base,
+        length,
+        stack
+      } = this;
+      references = this._references = stack.slice(base, base + length);
+    }
+    return references;
+  }
+  toSyntheticName(name) {
+    return name.slice(1);
+  }
+  toAtName(name) {
+    return `@${name}`;
+  }
+}
+function toSymbolName(name) {
+  return `&${name}`;
+}
+const EMPTY_BLOCK_VALUES = emptyArray();
+class BlockArgumentsImpl {
+  internalValues = null;
+  _symbolNames = null;
+  internalTag = null;
+  names = EMPTY_STRING_ARRAY;
+  length = 0;
+  base = 0;
+  constructor() {
+    setLocalDebugType('args:blocks', this);
+  }
+  empty(stack, base) {
+    this.stack = stack;
+    this.names = EMPTY_STRING_ARRAY;
+    this.base = base;
+    this.length = 0;
+    this._symbolNames = null;
+    this.internalTag = CONSTANT_TAG;
+    this.internalValues = EMPTY_BLOCK_VALUES;
+  }
+  setup(stack, base, length, names) {
+    this.stack = stack;
+    this.names = names;
+    this.base = base;
+    this.length = length;
+    this._symbolNames = null;
+    if (length === 0) {
+      this.internalTag = CONSTANT_TAG;
+      this.internalValues = EMPTY_BLOCK_VALUES;
+    } else {
+      this.internalTag = null;
+      this.internalValues = null;
+    }
+  }
+  get values() {
+    let values = this.internalValues;
+    if (!values) {
+      let {
+        base,
+        length,
+        stack
+      } = this;
+      values = this.internalValues = stack.slice(base, base + length * 3);
+    }
+    return values;
+  }
+  has(name) {
+    return this.names.indexOf(name) !== -1;
+  }
+  get(name) {
+    let idx = this.names.indexOf(name);
+    if (idx === -1) {
+      return null;
+    }
+    let {
+      base,
+      stack
+    } = this;
+    let table = check(stack.get(idx * 3, base));
+    let scope = check(stack.get(idx * 3 + 1, base));
+    let handle = check(stack.get(idx * 3 + 2, base));
+    return handle === null ? null : [handle, scope, table];
+  }
+  capture() {
+    return new CapturedBlockArgumentsImpl(this.names, this.values);
+  }
+  get symbolNames() {
+    let symbolNames = this._symbolNames;
+    if (symbolNames === null) {
+      symbolNames = this._symbolNames = this.names.map(toSymbolName);
+    }
+    return symbolNames;
+  }
+}
+class CapturedBlockArgumentsImpl {
+  length;
+  constructor(names, values) {
+    this.names = names;
+    this.values = values;
+    this.length = names.length;
+  }
+  has(name) {
+    return this.names.indexOf(name) !== -1;
+  }
+  get(name) {
+    let idx = this.names.indexOf(name);
+    if (idx === -1) return null;
+    return [this.values[idx * 3 + 2], this.values[idx * 3 + 1], this.values[idx * 3]];
+  }
+}
+function createCapturedArgs(named, positional) {
+  return {
+    named,
+    positional
+  };
+}
+function reifyNamed(named) {
+  let reified = dict();
+  for (const [key, value] of Object.entries(named)) {
+    reified[key] = valueForRef(value);
+  }
+  return reified;
+}
+function reifyPositional(positional) {
+  return positional.map(valueForRef);
+}
+function reifyArgs(args) {
+  return {
+    named: reifyNamed(args.named),
+    positional: reifyPositional(args.positional)
+  };
+}
+const ARGUMENT_ERROR = Symbol('ARGUMENT_ERROR');
+function isArgumentError(arg) {
+  return arg !== null && typeof arg === 'object' && arg[ARGUMENT_ERROR];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function ArgumentErrorImpl(error) {
+  return {
+    [ARGUMENT_ERROR]: true,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    error
+  };
+}
+function reifyNamedDebug(named) {
+  let reified = dict();
+  for (const [key, value] of Object.entries(named)) {
+    try {
+      reified[key] = valueForRef(value);
+    } catch (e) {
+      reified[key] = ArgumentErrorImpl(e);
+    }
+  }
+  return reified;
+}
+function reifyPositionalDebug(positional) {
+  return positional.map(p => {
+    try {
+      return valueForRef(p);
+    } catch (e) {
+      return ArgumentErrorImpl(e);
+    }
+  });
+}
+function reifyArgsDebug(args) {
+  let named = reifyNamedDebug(args.named);
+  let positional = reifyPositionalDebug(args.positional);
+  return {
+    named,
+    positional
+  };
+}
+const EMPTY_NAMED = Object.freeze(Object.create(null));
+const EMPTY_POSITIONAL = EMPTY_REFERENCES;
+const EMPTY_ARGS = createCapturedArgs(EMPTY_NAMED, EMPTY_POSITIONAL);
+
+function createConcatRef(partsRefs) {
+  return createComputeRef(() => {
+    const parts = [];
+    for (const ref of partsRefs) {
+      const value = valueForRef(ref);
+      if (value !== null && value !== undefined) {
+        parts.push(castToString(value));
+      }
+    }
+    if (parts.length > 0) {
+      return parts.join('');
+    }
+    return null;
+  });
+}
+function castToString(value) {
+  if (typeof value === 'string') {
+    return value;
+  } else if (typeof value.toString !== 'function') {
+    return '';
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+  return String(value);
+}
+
+APPEND_OPCODES.add(VM_CURRY_OP, (vm, {
+  op1: type,
+  op2: _isStrict
+}) => {
+  let stack = vm.stack;
+  let definition = check(stack.pop());
+  let capturedArgs = check(stack.pop());
+  let owner = vm.getOwner();
+  vm.context.resolver;
+  vm.loadValue($v0, createCurryRef(type, definition, owner, capturedArgs));
+});
+APPEND_OPCODES.add(VM_DYNAMIC_HELPER_OP, vm => {
+  let stack = vm.stack;
+  let ref = check(stack.pop());
+  let args = check(stack.pop()).capture();
+  let helperRef;
+  let initialOwner = vm.getOwner();
+  let helperInstanceRef = createComputeRef(() => {
+    if (helperRef !== undefined) {
+      destroy(helperRef);
+    }
+    let definition = valueForRef(ref);
+    if (isCurriedType(definition, CURRIED_HELPER)) {
+      let {
+        definition: resolvedDef,
+        owner,
+        positional,
+        named
+      } = resolveCurriedValue(definition);
+      let helper = resolveHelper(resolvedDef);
+      if (named !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        args.named = assign({}, ...named, args.named);
+      }
+      if (positional !== undefined) {
+        args.positional = positional.concat(args.positional);
+      }
+      helperRef = helper(args, owner);
+      associateDestroyableChild(helperInstanceRef, helperRef);
+    } else if (isIndexable$1(definition)) {
+      let helper = resolveHelper(definition);
+      helperRef = helper(args, initialOwner);
+      if (_hasDestroyableChildren(helperRef)) {
+        associateDestroyableChild(helperInstanceRef, helperRef);
+      }
+    } else {
+      helperRef = UNDEFINED_REFERENCE;
+    }
+  });
+  let helperValueRef = createComputeRef(() => {
+    valueForRef(helperInstanceRef);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+    return valueForRef(helperRef);
+  });
+  vm.associateDestroyable(helperInstanceRef);
+  vm.loadValue($v0, helperValueRef);
+});
+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);
+  }
+  return helper;
+}
+APPEND_OPCODES.add(VM_HELPER_OP, (vm, {
+  op1: handle
+}) => {
+  let stack = vm.stack;
+  let helper = check(vm.constants.getValue(handle));
+  let args = check(stack.pop());
+  let value = helper(args.capture(), vm.getOwner(), vm.dynamicScope());
+  if (_hasDestroyableChildren(value)) {
+    vm.associateDestroyable(value);
+  }
+  vm.loadValue($v0, value);
+});
+APPEND_OPCODES.add(VM_GET_VARIABLE_OP, (vm, {
+  op1: symbol
+}) => {
+  let expr = vm.referenceForSymbol(symbol);
+  vm.stack.push(expr);
+});
+APPEND_OPCODES.add(VM_SET_VARIABLE_OP, (vm, {
+  op1: symbol
+}) => {
+  let expr = check(vm.stack.pop());
+  vm.scope().bindSymbol(symbol, expr);
+});
+APPEND_OPCODES.add(VM_SET_BLOCK_OP, (vm, {
+  op1: symbol
+}) => {
+  let handle = check(vm.stack.pop());
+  let scope = check(vm.stack.pop());
+  let table = check(vm.stack.pop());
+  vm.scope().bindBlock(symbol, [handle, scope, table]);
+});
+APPEND_OPCODES.add(VM_ROOT_SCOPE_OP, (vm, {
+  op1: size
+}) => {
+  vm.pushRootScope(size, vm.getOwner());
+});
+APPEND_OPCODES.add(VM_GET_PROPERTY_OP, (vm, {
+  op1: _key
+}) => {
+  let key = vm.constants.getValue(_key);
+  let expr = check(vm.stack.pop());
+  vm.stack.push(childRefFor(expr, key));
+});
+APPEND_OPCODES.add(VM_GET_BLOCK_OP, (vm, {
+  op1: _block
+}) => {
+  let {
+    stack
+  } = vm;
+  let block = vm.scope().getBlock(_block);
+  stack.push(block);
+});
+APPEND_OPCODES.add(VM_SPREAD_BLOCK_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let block = check(stack.pop());
+  if (block && !isUndefinedReference(block)) {
+    let [handleOrCompilable, scope, table] = block;
+    stack.push(table);
+    stack.push(scope);
+    stack.push(handleOrCompilable);
+  } else {
+    stack.push(null);
+    stack.push(null);
+    stack.push(null);
+  }
+});
+function isUndefinedReference(input) {
+  return input === UNDEFINED_REFERENCE;
+}
+APPEND_OPCODES.add(VM_HAS_BLOCK_OP, vm => {
+  let {
+    stack
+  } = vm;
+  let block = check(stack.pop());
+  if (block && !isUndefinedReference(block)) {
+    stack.push(TRUE_REFERENCE);
+  } else {
+    stack.push(FALSE_REFERENCE);
+  }
+});
+APPEND_OPCODES.add(VM_HAS_BLOCK_PARAMS_OP, vm => {
+  // FIXME(mmun): should only need to push the symbol table
+  vm.stack.pop();
+  vm.stack.pop();
+  let table = check(vm.stack.pop());
+  let hasBlockParams = table && table.parameters.length;
+  vm.stack.push(hasBlockParams ? TRUE_REFERENCE : FALSE_REFERENCE);
+});
+APPEND_OPCODES.add(VM_CONCAT_OP, (vm, {
+  op1: count
+}) => {
+  let out = new Array(count);
+  for (let i = count; i > 0; i--) {
+    let offset = i - 1;
+    out[offset] = check(vm.stack.pop());
+  }
+  vm.stack.push(createConcatRef(out));
+});
+APPEND_OPCODES.add(VM_IF_INLINE_OP, vm => {
+  let condition = check(vm.stack.pop());
+  let truthy = check(vm.stack.pop());
+  let falsy = check(vm.stack.pop());
+  vm.stack.push(createComputeRef(() => {
+    if (toBool(valueForRef(condition))) {
+      return valueForRef(truthy);
+    } else {
+      return valueForRef(falsy);
+    }
+  }));
+});
+APPEND_OPCODES.add(VM_NOT_OP, vm => {
+  let ref = check(vm.stack.pop());
+  vm.stack.push(createComputeRef(() => {
+    return !toBool(valueForRef(ref));
+  }));
+});
+APPEND_OPCODES.add(VM_GET_DYNAMIC_VAR_OP, vm => {
+  let scope = vm.dynamicScope();
+  let stack = vm.stack;
+  let nameRef = check(stack.pop());
+  stack.push(createComputeRef(() => {
+    let name = String(valueForRef(nameRef));
+    return valueForRef(scope.get(name));
+  }));
+});
+APPEND_OPCODES.add(VM_LOG_OP, vm => {
+  let {
+    positional
+  } = check(vm.stack.pop()).capture();
+  vm.loadValue($v0, createComputeRef(() => {
+    // eslint-disable-next-line no-console
+    console.log(...reifyPositional(positional));
+  }));
+});
+
+class DynamicTextContent {
+  constructor(node, reference, lastValue) {
+    this.node = node;
+    this.reference = reference;
+    this.lastValue = lastValue;
+  }
+  evaluate() {
+    let value = valueForRef(this.reference);
+    let {
+      lastValue
+    } = this;
+    if (value === lastValue) return;
+    let normalized;
+    if (isEmpty$1(value)) {
+      normalized = '';
+    } else if (isString(value)) {
+      normalized = value;
+    } else {
+      normalized = String(value);
+    }
+    if (normalized !== lastValue) {
+      let textNode = this.node;
+      textNode.nodeValue = this.lastValue = normalized;
+    }
+  }
+}
+
+function toContentType(value) {
+  if (shouldCoerce(value)) {
+    return ContentType.String;
+  } else if (isCurriedType(value, CURRIED_COMPONENT) || hasInternalComponentManager(value)) {
+    return ContentType.Component;
+  } else if (isCurriedType(value, CURRIED_HELPER) || hasInternalHelperManager(value)) {
+    return ContentType.Helper;
+  } else if (isSafeString(value)) {
+    return ContentType.SafeString;
+  } else if (isFragment(value)) {
+    return ContentType.Fragment;
+  } else if (isNode(value)) {
+    return ContentType.Node;
+  } else {
+    return ContentType.String;
+  }
+}
+function toDynamicContentType(value) {
+  if (!isIndexable$1(value)) {
+    return ContentType.String;
+  }
+  if (isCurriedType(value, CURRIED_COMPONENT) || hasInternalComponentManager(value)) {
+    return ContentType.Component;
+  } else {
+    return ContentType.Helper;
+  }
+}
+APPEND_OPCODES.add(VM_CONTENT_TYPE_OP, vm => {
+  let reference = check(vm.stack.peek());
+  vm.stack.push(toContentType(valueForRef(reference)));
+  if (!isConstRef(reference)) {
+    vm.updateWith(new AssertFilter(reference, toContentType));
+  }
+});
+APPEND_OPCODES.add(VM_DYNAMIC_CONTENT_TYPE_OP, vm => {
+  let reference = check(vm.stack.peek());
+  vm.stack.push(toDynamicContentType(valueForRef(reference)));
+  if (!isConstRef(reference)) {
+    vm.updateWith(new AssertFilter(reference, toDynamicContentType));
+  }
+});
+APPEND_OPCODES.add(VM_APPEND_HTML_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let rawValue = valueForRef(reference);
+  let value = isEmpty$1(rawValue) ? '' : String(rawValue);
+  vm.tree().appendDynamicHTML(value);
+});
+APPEND_OPCODES.add(VM_APPEND_SAFE_HTML_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let rawValue = check(valueForRef(reference)).toHTML();
+  let value = isEmpty$1(rawValue) ? '' : check(rawValue);
+  vm.tree().appendDynamicHTML(value);
+});
+APPEND_OPCODES.add(VM_APPEND_TEXT_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let rawValue = valueForRef(reference);
+  let value = isEmpty$1(rawValue) ? '' : String(rawValue);
+  let node = vm.tree().appendDynamicText(value);
+  if (!isConstRef(reference)) {
+    vm.updateWith(new DynamicTextContent(node, reference, value));
+  }
+});
+APPEND_OPCODES.add(VM_APPEND_DOCUMENT_FRAGMENT_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let value = check(valueForRef(reference));
+  vm.tree().appendDynamicFragment(value);
+});
+APPEND_OPCODES.add(VM_APPEND_NODE_OP, vm => {
+  let reference = check(vm.stack.pop());
+  let value = check(valueForRef(reference));
+  vm.tree().appendDynamicNode(value);
+});
+
+// Allow the contents of `debugCallback` without extra annotations
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+
+function debugCallback(context, get) {
+  // eslint-disable-next-line no-console
+  console.info('Use `context`, and `get(<path>)` to debug this template.');
+
+  // for example...
+  context === get('this');
+
+  // eslint-disable-next-line no-debugger
+  debugger;
+}
+let callback = debugCallback;
+
+// For testing purposes
+function setDebuggerCallback(cb) {
+  callback = cb;
+}
+function resetDebuggerCallback() {
+  callback = debugCallback;
+}
+class ScopeInspector {
+  #symbols;
+  constructor(scope, symbols) {
+    this.scope = scope;
+    this.#symbols = symbols;
+  }
+  get(path) {
+    let {
+      scope
+    } = this;
+    let symbols = this.#symbols;
+    let parts = path.split('.');
+    let [head, ...tail] = path.split('.');
+    let ref;
+    if (head === 'this') {
+      ref = scope.getSelf();
+    } else if (symbols.locals[head]) {
+      ref = unwrap(scope.getSymbol(symbols.locals[head]));
+    } else {
+      ref = this.scope.getSelf();
+      tail = parts;
+    }
+    return tail.reduce((r, part) => childRefFor(r, part), ref);
+  }
+}
+APPEND_OPCODES.add(VM_DEBUGGER_OP, (vm, {
+  op1: _debugInfo
+}) => {
+  let debuggerInfo = vm.constants.getValue(decodeHandle(_debugInfo));
+  let inspector = new ScopeInspector(vm.scope(), debuggerInfo);
+  callback(valueForRef(vm.getSelf()), path => valueForRef(inspector.get(path)));
+});
+
+APPEND_OPCODES.add(VM_ENTER_LIST_OP, (vm, {
+  op1: relativeStart,
+  op2: elseTarget
+}) => {
+  let stack = vm.stack;
+  let listRef = check(stack.pop());
+  let keyRef = check(stack.pop());
+  let keyValue = valueForRef(keyRef);
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
+  let key = keyValue === null ? '@identity' : String(keyValue);
+  let iteratorRef = createIteratorRef(listRef, key);
+  let iterator = valueForRef(iteratorRef);
+  vm.updateWith(new AssertFilter(iteratorRef, iterator => iterator.isEmpty()));
+  if (iterator.isEmpty()) {
+    // TODO: Fix this offset, should be accurate
+    vm.lowlevel.goto(elseTarget + 1);
+  } else {
+    vm.enterList(iteratorRef, relativeStart);
+    vm.stack.push(iterator);
+  }
+});
+APPEND_OPCODES.add(VM_EXIT_LIST_OP, vm => {
+  vm.exitList();
+});
+APPEND_OPCODES.add(VM_ITERATE_OP, (vm, {
+  op1: breaks
+}) => {
+  let stack = vm.stack;
+  let iterator = check(stack.peek());
+  let item = iterator.next();
+  if (item !== null) {
+    vm.registerItem(vm.enterItem(item));
+  } else {
+    vm.lowlevel.goto(breaks);
+  }
+});
+
+const CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: false,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: false,
+  dynamicScope: false,
+  updateHook: false,
+  createInstance: false,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+class TemplateOnlyComponentManager {
+  getCapabilities() {
+    return CAPABILITIES;
+  }
+  getDebugName({
+    name
+  }) {
+    return name;
+  }
+  getSelf() {
+    return NULL_REFERENCE;
+  }
+  getDestroyable() {
+    return null;
+  }
+}
+const TEMPLATE_ONLY_COMPONENT_MANAGER = new TemplateOnlyComponentManager();
+
+// This is only exported for types, don't use this class directly
+class TemplateOnlyComponentDefinition {
+  constructor(moduleName = '@glimmer/component/template-only', name = '(unknown template-only component)') {
+    this.moduleName = moduleName;
+    this.name = name;
+  }
+  toString() {
+    return this.moduleName;
+  }
+}
+setInternalComponentManager(TEMPLATE_ONLY_COMPONENT_MANAGER, TemplateOnlyComponentDefinition.prototype);
+
+/**
+  This utility function is used to declare a given component has no backing class. When the rendering engine detects this it
+  is able to perform a number of optimizations. Templates that are associated with `templateOnly()` will be rendered _as is_
+  without adding a wrapping `<div>` (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)).
+  Specifically, this means that the template will be rendered as "outer HTML".
+
+  In general, this method will be used by build time tooling and would not be directly written in an application. However,
+  at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like
+  to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the
+  `template-only-glimmer-components` optional feature.
+
+  @example
+
+  ```js
+  import { templateOnlyComponent } from '@glimmer/runtime';
+
+  export default templateOnlyComponent();
+  ```
+
+  @public
+  @method templateOnly
+  @param {String} moduleName the module name that the template only component represents, this will be used for debugging purposes
+  @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+*/
+
+function templateOnlyComponent(moduleName, name) {
+  return new TemplateOnlyComponentDefinition(moduleName, name);
+}
+
+// http://www.w3.org/TR/html/syntax.html#html-integration-point
+const SVG_INTEGRATION_POINTS = {
+  foreignObject: 1,
+  desc: 1,
+  title: 1
+};
+
+// http://www.w3.org/TR/html/syntax.html#adjust-svg-attributes
+// TODO: Adjust SVG attributes
+
+// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign
+// TODO: Adjust SVG elements
+
+// http://www.w3.org/TR/html/syntax.html#parsing-main-inforeign
+const BLACKLIST_TABLE = Object.create(null);
+class DOMOperations {
+  // Set by this.setupUselessElement() in constructor
+
+  constructor(document) {
+    this.document = document;
+    this.setupUselessElement();
+  }
+
+  // split into separate method so that NodeDOMTreeConstruction
+  // can override it.
+  setupUselessElement() {
+    this.uselessElement = this.document.createElement('div');
+  }
+  createElement(tag, context) {
+    let isElementInSVGNamespace, isHTMLIntegrationPoint, isElementInMathMlNamespace, ns;
+    if (context) {
+      isElementInSVGNamespace = context.namespaceURI === NS_SVG || tag === 'svg';
+      isElementInMathMlNamespace = context.namespaceURI === NS_MATHML || tag === 'math';
+      isHTMLIntegrationPoint = !!SVG_INTEGRATION_POINTS[context.tagName];
+    } else {
+      isElementInSVGNamespace = tag === 'svg';
+      isElementInMathMlNamespace = tag === 'math';
+      isHTMLIntegrationPoint = false;
+    }
+    if ((isElementInMathMlNamespace || isElementInSVGNamespace) && !isHTMLIntegrationPoint) {
+      // FIXME: This does not properly handle <font> with color, face, or
+      // size attributes, which is also disallowed by the spec. We should fix
+      // this.
+      if (BLACKLIST_TABLE[tag]) {
+        throw new Error(`Cannot create a ${tag} inside an SVG context`);
+      }
+      if (isElementInMathMlNamespace) {
+        ns = NS_MATHML;
+      } else {
+        ns = NS_SVG;
+      }
+      return this.document.createElementNS(ns, tag);
+    } else {
+      return this.document.createElement(tag);
+    }
+  }
+  insertBefore(parent, node, reference) {
+    parent.insertBefore(node, reference);
+  }
+  insertHTMLBefore(parent, nextSibling, html) {
+    if (html === '') {
+      const comment = this.createComment('');
+      parent.insertBefore(comment, nextSibling);
+      return new ConcreteBounds(parent, comment, comment);
+    }
+    const prev = nextSibling ? nextSibling.previousSibling : parent.lastChild;
+    let last;
+    if (nextSibling === null) {
+      parent.insertAdjacentHTML(INSERT_BEFORE_END, html);
+      last = expect(parent.lastChild);
+    } else if (nextSibling instanceof HTMLElement) {
+      nextSibling.insertAdjacentHTML('beforebegin', html);
+      last = expect(nextSibling.previousSibling);
+    } else {
+      // Non-element nodes do not support insertAdjacentHTML, so add an
+      // element and call it on that element. Then remove the element.
+      const {
+        uselessElement
+      } = this;
+      parent.insertBefore(uselessElement, nextSibling);
+      uselessElement.insertAdjacentHTML(INSERT_BEFORE_BEGIN, html);
+      last = expect(uselessElement.previousSibling);
+      parent.removeChild(uselessElement);
+    }
+    const first = expect(prev ? prev.nextSibling : parent.firstChild);
+    return new ConcreteBounds(parent, first, last);
+  }
+  createTextNode(text) {
+    return this.document.createTextNode(text);
+  }
+  createComment(data) {
+    return this.document.createComment(data);
+  }
+}
+
+['b', 'big', 'blockquote', 'body', 'br', 'center', 'code', 'dd', 'div', 'dl', 'dt', 'em', 'embed', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'hr', 'i', 'img', 'li', 'listing', 'main', 'meta', 'nobr', 'ol', 'p', 'pre', 'ruby', 's', 'small', 'span', 'strong', 'strike', 'sub', 'sup', 'table', 'tt', 'u', 'ul', 'var'].forEach(tag => BLACKLIST_TABLE[tag] = 1);
+const WHITESPACE = /[\t\n\v\f\r \xa0\u{1680}\u{180e}\u{2000}-\u{200a}\u{2028}\u{2029}\u{202f}\u{205f}\u{3000}\u{feff}]/u;
+function isWhitespace(string) {
+  return WHITESPACE.test(string);
+}
+class DOMChangesImpl extends DOMOperations {
+  namespace;
+  constructor(document) {
+    super(document);
+    this.document = document;
+    this.namespace = null;
+  }
+  setAttribute(element, name, value) {
+    element.setAttribute(name, value);
+  }
+  removeAttribute(element, name) {
+    element.removeAttribute(name);
+  }
+  insertAfter(element, node, reference) {
+    this.insertBefore(element, node, reference.nextSibling);
+  }
+}
+const DOMChanges = DOMChangesImpl;
+
+function internalHelper(helper) {
+  return setInternalHelperManager(helper, {});
+}
+
+/**
+   Use the `{{array}}` helper to create an array to pass as an option to your
+   components.
+
+   ```handlebars
+   <MyComponent @people={{array
+     'Tom Dale'
+     'Yehuda Katz'
+     this.myOtherPerson}}
+   />
+   ```
+    or
+   ```handlebars
+   {{my-component people=(array
+     'Tom Dale'
+     'Yehuda Katz'
+     this.myOtherPerson)
+   }}
+   ```
+
+   Would result in an object such as:
+
+   ```js
+   ['Tom Dale', 'Yehuda Katz', this.get('myOtherPerson')]
+   ```
+
+   Where the 3rd item in the array is bound to updates of the `myOtherPerson` property.
+
+   @method array
+   @param {Array} options
+   @return {Array} Array
+   @public
+ */
+
+const array = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional), null, 'array');
+});
+
+const isEmpty = value => {
+  return value === null || value === undefined || typeof value.toString !== 'function';
+};
+const normalizeTextValue = value => {
+  if (isEmpty(value)) {
+    return '';
+  }
+  return String(value);
+};
+
+/**
+  Concatenates the given arguments into a string.
+
+  Example:
+
+  ```handlebars
+  {{some-component name=(concat firstName " " lastName)}}
+
+  {{! would pass name="<first name value> <last name value>" to the component}}
+  ```
+
+  or for angle bracket invocation, you actually don't need concat at all.
+
+  ```handlebars
+  <SomeComponent @name="{{firstName}} {{lastName}}" />
+  ```
+
+  @public
+  @method concat
+*/
+const concat = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
+});
+
+const context = buildUntouchableThis();
+
+/**
+  The `fn` helper allows you to ensure a function that you are passing off
+  to another component, helper, or modifier has access to arguments that are
+  available in the template.
+
+  For example, if you have an `each` helper looping over a number of items, you
+  may need to pass a function that expects to receive the item as an argument
+  to a component invoked within the loop. Here's how you could use the `fn`
+  helper to pass both the function and its arguments together:
+
+    ```app/templates/components/items-listing.hbs
+  {{#each @items as |item|}}
+    <DisplayItem @item=item @select={{fn this.handleSelected item}} />
+  {{/each}}
+  ```
+
+  ```app/components/items-list.js
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+
+  export default class ItemsList extends Component {
+    handleSelected = (item) => {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this case the `display-item` component will receive a normal function
+  that it can invoke. When it invokes the function, the `handleSelected`
+  function will receive the `item` and any arguments passed, thanks to the
+  `fn` helper.
+
+  Let's take look at what that means in a couple circumstances:
+
+  - When invoked as `this.args.select()` the `handleSelected` function will
+    receive the `item` from the loop as its first and only argument.
+  - When invoked as `this.args.select('foo')` the `handleSelected` function
+    will receive the `item` from the loop as its first argument and the
+    string `'foo'` as its second argument.
+
+  In the example above, we used an arrow function to ensure that
+  `handleSelected` is properly bound to the `items-list`, but let's explore what
+  happens if we left out the arrow function:
+
+  ```app/components/items-list.js
+  import Component from '@glimmer/component';
+
+  export default class ItemsList extends Component {
+    handleSelected(item) {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this example, when `handleSelected` is invoked inside the `display-item`
+  component, it will **not** have access to the component instance. In other
+  words, it will have no `this` context, so please make sure your functions
+  are bound (via an arrow function or other means) before passing into `fn`!
+
+  See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
+
+  @method fn
+  @public
+*/
+const fn = internalHelper(({
+  positional
+}) => {
+  let callbackRef = check(positional[0]);
+  return createComputeRef(() => {
+    return (...invocationArgs) => {
+      let [fn, ...args] = reifyPositional(positional);
+      if (isInvokableRef(callbackRef)) {
+        let value = args.length > 0 ? args[0] : invocationArgs[0];
+        return void updateRef(callbackRef, value);
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- @fixme
+        return fn.call(context, ...args, ...invocationArgs);
+      }
+    };
+  }, null, 'fn');
+});
+
+/**
+  Dynamically look up a property on an object. The second argument to `{{get}}`
+  should have a string value, although it can be bound.
+
+  For example, these two usages are equivalent:
+
+  ```app/components/developer-detail.js
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  export default class extends Component {
+    @tracked developer = {
+      name: "Sandi Metz",
+      language: "Ruby"
+    }
+  }
+  ```
+
+  ```handlebars
+  {{this.developer.name}}
+  {{get this.developer "name"}}
+  ```
+
+  If there were several facts about a person, the `{{get}}` helper can dynamically
+  pick one:
+
+  ```app/templates/application.hbs
+  <DeveloperDetail @factName="language" />
+  ```
+
+  ```handlebars
+  {{get this.developer @factName}}
+  ```
+
+  For a more complex example, this template would allow the user to switch
+  between showing the user's height and weight with a click:
+
+  ```app/components/developer-detail.js
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  export default class extends Component {
+    @tracked developer = {
+      name: "Sandi Metz",
+      language: "Ruby"
+    }
+
+    @tracked currentFact = 'name'
+
+    showFact = (fact) => {
+      this.currentFact = fact;
+    }
+  }
+  ```
+
+  ```app/components/developer-detail.js
+  {{get this.developer this.currentFact}}
+
+  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
+  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+  ```
+
+  The `{{get}}` helper can also respect mutable values itself. For example:
+
+  ```app/components/developer-detail.js
+  <Input @value={{mut (get this.person this.currentFact)}} />
+
+  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
+  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+  ```
+
+  Would allow the user to swap what fact is being displayed, and also edit
+  that fact via a two-way mutable binding.
+
+  @public
+  @method get
+ */
+const get = internalHelper(({
+  positional
+}) => {
+  let sourceRef = positional[0] ?? UNDEFINED_REFERENCE;
+  let pathRef = positional[1] ?? UNDEFINED_REFERENCE;
+  return createComputeRef(() => {
+    let source = valueForRef(sourceRef);
+    if (isDict(source)) {
+      return getPath(source, String(valueForRef(pathRef)));
+    }
+  }, value => {
+    let source = valueForRef(sourceRef);
+    if (isDict(source)) {
+      return setPath(source, String(valueForRef(pathRef)), value);
+    }
+  }, 'get');
+});
+
+/**
+   Use the `{{hash}}` helper to create a hash to pass as an option to your
+   components. This is specially useful for contextual components where you can
+   just yield a hash:
+
+   ```handlebars
+   {{yield (hash
+      name='Sarah'
+      title=office
+   )}}
+   ```
+
+   Would result in an object such as:
+
+   ```js
+   { name: 'Sarah', title: this.get('office') }
+   ```
+
+   Where the `title` is bound to updates of the `office` property.
+
+   Note that the hash is an empty object with no prototype chain, therefore
+   common methods like `toString` are not available in the resulting hash.
+   If you need to use such a method, you can use the `call` or `apply`
+   approach:
+
+   ```js
+   function toString(obj) {
+     return Object.prototype.toString.apply(obj);
+   }
+   ```
+
+   @method hash
+   @param {Object} options
+   @return {Object} Hash
+   @public
+ */
+const hash = internalHelper(({
+  named
+}) => {
+  let ref = createComputeRef(() => {
+    return reifyNamed(named);
+  }, null, 'hash');
+
+  // Setup the children so that templates can bypass getting the value of
+  // the reference and treat children lazily
+  let children = new Map();
+  for (let name in named) {
+    children.set(name, named[name]);
+  }
+  ref.children = children;
+  return ref;
+});
+
+class OnModifierState {
+  tag = createUpdatableTag();
+  element;
+  args;
+  listener = null;
+  constructor(element, args) {
+    this.element = element;
+    this.args = args;
+    registerDestructor(this, () => {
+      let {
+        element,
+        listener
+      } = this;
+      if (listener) {
+        let {
+          eventName,
+          callback,
+          options
+        } = listener;
+        removeEventListener(element, eventName, callback, options);
+      }
+    });
+  }
+
+  // Update this.listener if needed
+  updateListener() {
+    let {
+      element,
+      args,
+      listener
+    } = this;
+    let arg0 = args.positional[0];
+    let eventName = check(arg0 ? valueForRef(arg0) : undefined);
+    let arg1 = args.positional[1];
+    let userProvidedCallback = check(arg1 ? valueForRef(arg1) : undefined);
+    let once = undefined;
+    let passive = undefined;
+    let capture = undefined;
+    {
+      let {
+        once: _once,
+        passive: _passive,
+        capture: _capture
+      } = args.named;
+      if (_once) {
+        once = valueForRef(_once);
+      }
+      if (_passive) {
+        passive = valueForRef(_passive);
+      }
+      if (_capture) {
+        capture = valueForRef(_capture);
+      }
+    }
+    let shouldUpdate = false;
+    if (listener === null) {
+      shouldUpdate = true;
+    } else {
+      shouldUpdate = eventName !== listener.eventName || userProvidedCallback !== listener.userProvidedCallback || once !== listener.once || passive !== listener.passive || capture !== listener.capture;
+    }
+    let options = undefined;
+
+    // we want to handle both `true` and `false` because both have a meaning:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=770208
+    if (shouldUpdate) {
+      if (once !== undefined || passive !== undefined || capture !== undefined) {
+        options = {
+          once,
+          passive,
+          capture
+        };
+      }
+    }
+    if (shouldUpdate) {
+      let callback = userProvidedCallback;
+      this.listener = {
+        eventName,
+        callback,
+        userProvidedCallback,
+        once,
+        passive,
+        capture,
+        options
+      };
+      if (listener) {
+        removeEventListener(element, listener.eventName, listener.callback, listener.options);
+      }
+      addEventListener(element, eventName, callback, options);
+    }
+  }
+}
+let adds = 0;
+let removes = 0;
+function removeEventListener(element, eventName, callback, options) {
+  removes++;
+  element.removeEventListener(eventName, callback, options);
+}
+function addEventListener(element, eventName, callback, options) {
+  adds++;
+  element.addEventListener(eventName, callback, options);
+}
+
+/**
+  The `{{on}}` modifier lets you easily add event listeners (it uses
+  [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+  internally).
+
+  For example, if you'd like to run a function on your component when a `<button>`
+  in the components template is clicked you might do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' this.saveLike}}>Like this post!</button>
+  ```
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+
+  export default class LikePostComponent extends Component {
+    saveLike = () => {
+      // someone likes your post!
+      // better send a request off to your server...
+    }
+  }
+  ```
+
+  ### Arguments
+
+  `{{on}}` accepts two positional arguments, and a few named arguments.
+
+  The positional arguments are:
+
+  - `event` -- the name to use when calling `addEventListener`
+  - `callback` -- the function to be passed to `addEventListener`
+
+  The named arguments are:
+
+  - capture -- a `true` value indicates that events of this type will be dispatched
+    to the registered listener before being dispatched to any EventTarget beneath it
+    in the DOM tree.
+  - once -- indicates that the listener should be invoked at most once after being
+    added. If true, the listener would be automatically removed when invoked.
+  - passive -- if `true`, indicates that the function specified by listener will never
+    call preventDefault(). If a passive listener does call preventDefault(), the user
+    agent will do nothing other than generate a console warning. See
+    [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
+    to learn more.
+
+  The callback function passed to `{{on}}` will receive any arguments that are passed
+  to the event handler. Most commonly this would be the `event` itself.
+
+  If you would like to pass additional arguments to the function you should use
+  the `{{fn}}` helper.
+
+  For example, in our example case above if you'd like to pass in the post that
+  was being liked when the button is clicked you could do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
+  ```
+
+  In this case, the `saveLike` function will receive two arguments: the click event
+  and the value of `@post`.
+
+  ### Function Context
+
+  In the example above, we used an arrow function to ensure that `likePost` is
+  properly bound to the `items-list`, but let's explore what happens if we
+  left out the arrow function:
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+
+  export default class LikePostComponent extends Component {
+    saveLike() {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this example, when the button is clicked `saveLike` will be invoked,
+  it will **not** have access to the component instance. In other
+  words, it will have no `this` context, so please make sure your functions
+  are bound (via an arrow function or other means) before passing into `on`!
+
+  @method on
+  @public
+*/
+class OnModifierManager {
+  getDebugName() {
+    return 'on';
+  }
+  getDebugInstance() {
+    return null;
+  }
+  get counters() {
+    return {
+      adds,
+      removes
+    };
+  }
+  create(_owner, element, _state, args) {
+    return new OnModifierState(element, args);
+  }
+  getTag({
+    tag
+  }) {
+    return tag;
+  }
+  install(state) {
+    state.updateListener();
+  }
+  update(state) {
+    state.updateListener();
+  }
+  getDestroyable(state) {
+    return state;
+  }
+}
+const on = setInternalModifierManager(new OnModifierManager(), {});
+
+export { DOMOperations as A, isSafeString as B, ConcreteBounds as C, DOMChanges as D, EMPTY_ARGS as E, normalizeStringValue as F, DebugRenderTreeImpl as G, isArgumentError as H, APPEND_OPCODES as I, move as J, externs as K, JumpIfNotModifiedOpcode as L, BeginTrackFrameOpcode as M, NS_SVG as N, EndTrackFrameOpcode as O, TEMPLATE_ONLY_COMPONENT_MANAGER as T, VMArgumentsImpl as V, CurriedValue as a, CursorImpl as b, EMPTY_NAMED as c, EMPTY_POSITIONAL as d, DOMChangesImpl as e, TemplateOnlyComponentDefinition as f, TemplateOnlyComponentManager as g, array as h, clear as i, concat as j, createCapturedArgs as k, curry as l, fn as m, get as n, hash as o, isWhitespace as p, on as q, reifyArgs as r, reifyNamed as s, reifyPositional as t, resetDebuggerCallback as u, setDebuggerCallback as v, templateOnlyComponent as w, COMMENT_NODE as x, TEXT_NODE as y, ELEMENT_NODE as z };