ember-source 7.1.0-alpha.4 → 7.1.0-alpha.5

package/dist/dev/packages/shared-chunks/dynamic-CgX8M02_.js

@@ -1,3823 +0,0 @@
-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-Cc5k9Oy4.js';
-import { d as debugToString } from './debug-to-string-CFb7h0lY.js';
-import { u as unwrap, e as expect, a as isIndexable$1, S as StackImpl, d as dict, i as isDict } from './collections-D_nY_0UJ.js';
-import { a as assign } from './object-utils-AijlD-JH.js';
-import { toBool, debugAssert, setPath, getPath, warnIfStyleNotTrusted } 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, e as createDebugAliasRef, b as childRefFor, f as isInvokableRef, u as updateRef } from './reference-C3TKDRnP.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, h as hasInternalComponentManager, f as hasInternalHelperManager, s as setInternalComponentManager, i as setInternalHelperManager, j as setInternalModifierManager } from './api-BQMslHhq.js';
-import { m as managerHasCapability } from './capabilities-O_xc7Yqk.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-BbdWMvgs.js';
-import { I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
-import { a as castToBrowser } from './simple-cast-DCvJLSin.js';
-
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-function buildUntouchableThis(source) {
-  let context = null;
-  {
-    let assertOnProperty = property => {
-      let access = typeof property === 'symbol' || typeof property === 'number' ? `[${String(property)}]` : `.${property}`;
-      throw new Error(`You accessed \`this${access}\` from a function passed to the ${source}, but the function itself was not bound to a valid \`this\` context. Consider updating to use a bound function (for instance, use an arrow function, \`() => {}\`).`);
-    };
-    context = new Proxy({}, {
-      get(_target, property) {
-        assertOnProperty(property);
-      },
-      set(_target, property) {
-        assertOnProperty(property);
-        return false;
-      },
-      has(_target, property) {
-        assertOnProperty(property);
-        return false;
-      }
-    });
-  }
-  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) {
-      (!(!opcode.isMachine) && assert(!opcode.isMachine, `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`));
-      operation.evaluate(vm, opcode);
-    } else {
-      (!(opcode.isMachine) && 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) {
-      // Only components should enter this path, as helpers and modifiers do not
-      // support string based resolution
-
-      {
-        if (isStrict) {
-          throw new Error(`Attempted to resolve a dynamic component with a string definition, \`${value}\` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.`);
-        }
-        let resolvedDefinition = expect(resolver).lookupComponent?.(value, owner) ?? null;
-        if (!resolvedDefinition) {
-          throw new Error(`Attempted to resolve \`${value}\`, which was expected to be a component, but nothing was found.`);
-        }
-      }
-      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;
-  if (!definition) {
-    throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
-  }
-
-  // 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() {
-    if (this.value === null) {
-      throw new Error('BUG: double 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) {
-    if (this.stack.current !== state) {
-      // eslint-disable-next-line @typescript-eslint/no-base-to-string
-      throw new Error(`BUG: expecting ${this.stack.current}, got ${state}`);
-    }
-    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() {
-    if (this.stack.size === 0) {
-      throw new Error('BUG: unbalanced pop');
-    }
-    this.stack.pop();
-  }
-  nodeFor(state) {
-    return expect(this.nodes.get(state));
-  }
-  appendChild(node, state) {
-    if (this.refs.has(state)) {
-      throw new Error('BUG: child already appended');
-    }
-    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 bounds = this.captureBounds(node);
-    let children = this.captureRefs(refs);
-    return {
-      id,
-      type,
-      name,
-      args: reifyArgsDebug(args),
-      instance,
-      bounds,
-      children
-    };
-  }
-  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)), false));
-});
-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) {
-    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, true);
-    if (manager === null) {
-      {
-        throw new Error(`Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${debugToString?.(hostDefinition)}`);
-      }
-    }
-    let 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();
-  let isStrict = constants.getValue(_isStrict);
-  vm.loadValue($t1, null); // Clear the temp register
-
-  let definition;
-  if (typeof component === 'string') {
-    if (isStrict) {
-      throw new Error(`Attempted to resolve a dynamic component with a string definition, \`${component}\` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.`);
-    }
-    let resolvedDefinition = resolveComponent(vm.context.resolver, constants, component, owner);
-    definition = expect(resolvedDefinition);
-  } else if (isCurriedValue(component)) {
-    definition = component;
-  } else {
-    definition = constants.component(component, owner);
-  }
-  if (!isCurriedValue(definition) && !definition.resolvedName && !definition.debugName) {
-    let debugLabel = ref.debugLabel;
-    if (debugLabel) {
-      definition.debugName = debugLabel;
-    }
-  }
-  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 (!(typeof value === 'function' || typeof value === 'object' && value !== null)) {
-    throw new Error(`Expected a component definition, but received ${value}. You may have accidentally done <${ref.debugLabel}>, where "${ref.debugLabel}" was a string instead of a curried component definition. You must either use the component definition directly, or use the {{component}} helper to create a curried component definition when invoking dynamically.`);
-  }
-  if (isCurriedValue(value)) {
-    definition = value;
-  } else {
-    definition = constants.component(value, vm.getOwner(), true);
-    if (definition === null) {
-      throw new Error(`Expected a dynamic component definition, but received an object or function that did not have a component manager associated with it. The dynamic invocation was \`<${ref.debugLabel}>\` or \`{{${ref.debugLabel}}}\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${debugToString?.(value) ?? value}`);
-    }
-  }
-  if (definition && !isCurriedValue(definition) && !definition.resolvedName && !definition.debugName) {
-    let debugLabel = ref.debugLabel;
-    if (debugLabel) {
-      definition.debugName = debugLabel;
-    }
-  }
-  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)) {
-    (!(!definition.manager) && 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 (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.willDestroy) && d !== null && "string" in d) {
-    throw new Error('BUG: Destructor has willDestroy, but the willDestroy capability was not enabled for this component. Pre-destruction hooks must be explicitly opted into');
-  }
-  if (d) vm.associateDestroyable(d);
-});
-APPEND_OPCODES.add(VM_BEGIN_COMPONENT_TRANSACTION_OP, (vm, {
-  op1: register
-}) => {
-  let name;
-  {
-    let {
-      definition,
-      manager
-    } = check(vm.fetchValue(check(register, CheckRegister)));
-    name = getDebugName(definition, manager);
-  }
-  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 compilable = definition.compilable;
-    if (compilable === null) {
-      (!(managerHasCapability(manager, instance.capabilities, InternalComponentCapabilities.dynamicLayout)) && assert(managerHasCapability(manager, instance.capabilities, InternalComponentCapabilities.dynamicLayout)));
-      let resolver = vm.context.resolver;
-      compilable = resolver === null ? null : manager.getDynamicLayout(state, resolver);
-    }
-
-    // For tearing down the debugRenderTree
-    vm.associateDestroyable(instance);
-    if (hasCustomDebugRenderTreeLifecycle(manager)) {
-      let nodes = manager.getDebugCustomRenderTree(instance.definition.state, instance.state, args);
-      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,
-        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;
-    (!(managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) && 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);
-    {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-      return createDebugAliasRef(atNames ? name : `@${name}`, ref);
-    }
-  }
-  capture() {
-    let {
-      names,
-      references
-    } = this;
-    let map = dict();
-    for (const [i, name] of enumerate(names)) {
-      {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-        map[name] = createDebugAliasRef(`@${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();
-  let resolver = vm.context.resolver;
-  let isStrict = false;
-  {
-    // strict check only happens in import.meta.env.DEV builds, no reason to load it otherwise
-    isStrict = vm.constants.getValue(decodeHandle(_isStrict));
-  }
-  vm.loadValue($v0, createCurryRef(type, definition, owner, capturedArgs, resolver, isStrict));
-});
-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, ref);
-      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, ref);
-      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);
-  }
-  debugAssert(helper !== null, () => `Expected a dynamic helper definition, but received an object or function that did not have a helper manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\` or \`(${ref.debugLabel})\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${debugToString?.(definition)}`);
-  return 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 {
-    if (!isCurriedType(value, CURRIED_HELPER) && !hasInternalHelperManager(value)) {
-      throw new Error(
-      // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
-      `Attempted use a dynamic value as a component or helper, but that value did not have an associated component or helper manager. The value was: ${value}`);
-    }
-    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;
-
-/*
- * @method normalizeProperty
- * @param element {HTMLElement}
- * @param slotName {String}
- * @returns {Object} { name, type }
- */
-function normalizeProperty(element, slotName) {
-  let type, normalized;
-  if (slotName in element) {
-    normalized = slotName;
-    type = 'prop';
-  } else {
-    let lower = slotName.toLowerCase();
-    if (lower in element) {
-      type = 'prop';
-      normalized = lower;
-    } else {
-      type = 'attr';
-      normalized = slotName;
-    }
-  }
-  if (type === 'prop' && (normalized.toLowerCase() === 'style' || preferAttr(element.tagName, normalized))) {
-    type = 'attr';
-  }
-  return {
-    normalized,
-    type
-  };
-}
-
-// Properties that MUST be set as attributes because the DOM properties
-// are read-only or have type mismatches with the HTML attributes.
-//
-// element.form is a read-only DOM property on all form-associated elements
-// that returns the owning HTMLFormElement (or null). The HTML `form` attribute
-// (set via setAttribute) associates the element with a form by ID.
-// See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/form
-//      https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement/form
-const ATTR_OVERRIDES = {
-  INPUT: {
-    form: true,
-    // HTMLElement.autocorrect is a boolean DOM property, but the HTML attribute
-    // uses "on"/"off" strings. Setting `element.autocorrect = "off"` coerces to
-    // `true` (truthy string). Must use setAttribute for correct "on"/"off" behavior.
-    // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/autocorrect
-    autocorrect: true,
-    // HTMLInputElement.list is a read-only DOM property that returns the associated
-    // HTMLDataListElement (or null). Must use setAttribute to set the datalist ID.
-    // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/list
-    list: true
-  },
-  SELECT: {
-    form: true
-  },
-  OPTION: {
-    form: true
-  },
-  TEXTAREA: {
-    form: true
-  },
-  LABEL: {
-    form: true
-  },
-  FIELDSET: {
-    form: true
-  },
-  LEGEND: {
-    form: true
-  },
-  OBJECT: {
-    form: true
-  },
-  OUTPUT: {
-    form: true
-  },
-  BUTTON: {
-    form: true
-  }
-};
-function preferAttr(tagName, propName) {
-  let tag = ATTR_OVERRIDES[tagName.toUpperCase()];
-  return !!(tag && tag[propName.toLowerCase()]);
-}
-
-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('`fn` helper');
-
-/**
-  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);
-      assertCallbackIsFn(callbackRef);
-      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');
-});
-function assertCallbackIsFn(callbackRef) {
-  if (!(callbackRef && (isInvokableRef(callbackRef) || typeof valueForRef(callbackRef) === 'function'))) {
-    throw new Error(`You must pass a function as the \`fn\` helper's first argument, you passed ${callbackRef ? valueForRef(callbackRef) : callbackRef}. While rendering:\n\n${callbackRef?.debugLabel}`);
-  }
-}
-
-/**
-  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;
-});
-
-const untouchableContext = buildUntouchableThis('`on` modifier');
-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 selector;
-    {
-      const el = this.element;
-      selector = el.tagName.toLowerCase() + (el.id ? `#${el.id}` : '') + Array.from(el.classList).map(c => `.${c}`).join('');
-    }
-    let arg0 = args.positional[0];
-    let eventName = check(arg0 ? valueForRef(arg0) : undefined);
-    if (!eventName) {
-      throw new Error(`You must pass a valid DOM event name as the first argument to the \`on\` modifier on ${selector}`);
-    }
-    let arg1 = args.positional[1];
-    let userProvidedCallback = check(arg1 ? valueForRef(arg1) : undefined);
-    if (typeof userProvidedCallback !== 'function') {
-      throw new Error(`You must pass a function as the second argument to the \`on\` modifier; you passed ${userProvidedCallback === null ? 'null' : typeof userProvidedCallback}. While rendering:\n\n${args.positional[1]?.debugLabel ?? '(unknown)'} on ${selector}`);
-    }
-    if (args.positional.length !== 2) {
-      throw new Error(`You can only pass two positional arguments (event name and callback) to the \`on\` modifier, but you provided ${args.positional.length}. Consider using the \`fn\` helper to provide additional arguments to the \`on\` callback on ${selector}`);
-    }
-    let once = undefined;
-    let passive = undefined;
-    let capture = undefined;
-    {
-      let {
-        once: _once,
-        passive: _passive,
-        capture: _capture,
-        ...extra
-      } = reifyNamed(args.named);
-      once = check(_once);
-      passive = check(_passive);
-      capture = check(_capture);
-      if (Object.keys(extra).length > 0) {
-        throw new Error(`You can only \`once\`, \`passive\` or \`capture\` named arguments to the \`on\` modifier, but you provided ${Object.keys(extra).join(', ')} on ${selector}`);
-      }
-    }
-    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;
-      {
-        callback = userProvidedCallback.bind(untouchableContext);
-        if (passive) {
-          let _callback = callback;
-          callback = event => {
-            event.preventDefault = () => {
-              throw new Error(`You marked this listener as 'passive', meaning that you must not call 'event.preventDefault()': \n\n${userProvidedCallback.name || `{anonymous function}`}`);
-            };
-            return _callback(event);
-          };
-        }
-      }
-      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(), {});
-
-const badProtocols = ['javascript:', 'vbscript:'];
-const badTags = ['A', 'BODY', 'LINK', 'IMG', 'IFRAME', 'BASE', 'FORM'];
-const badTagsForDataURI = ['EMBED'];
-const badAttributes = ['href', 'src', 'background', 'action'];
-const badAttributesForDataURI = ['src'];
-function has(array, item) {
-  return array.indexOf(item) !== -1;
-}
-function checkURI(tagName, attribute) {
-  return (tagName === null || has(badTags, tagName)) && has(badAttributes, attribute);
-}
-function checkDataURI(tagName, attribute) {
-  if (tagName === null) return false;
-  return has(badTagsForDataURI, tagName) && has(badAttributesForDataURI, attribute);
-}
-function requiresSanitization(tagName, attribute) {
-  return checkURI(tagName, attribute) || checkDataURI(tagName, attribute);
-}
-function findProtocolForURL() {
-  const weirdURL = URL;
-  if (typeof weirdURL === 'object' && weirdURL !== null &&
-  // this is super annoying, TS thinks that URL **must** be a function so `URL.parse` check
-  // thinks it is `never` without this `as unknown as any`
-
-  typeof weirdURL.parse === 'function') {
-    // In Ember-land the `fastboot` package sets the `URL` global to `require('url')`
-    // ultimately, this should be changed (so that we can either rely on the natural `URL` global
-    // that exists) but for now we have to detect the specific `FastBoot` case first
-    //
-    // a future version of `fastboot` will detect if this legacy URL setup is required (by
-    // inspecting Ember version) and if new enough, it will avoid shadowing the `URL` global
-    // constructor with `require('url')`.
-    let nodeURL = weirdURL;
-    return url => {
-      let protocol = null;
-      if (typeof url === 'string') {
-        protocol = nodeURL.parse(url).protocol;
-      }
-      return protocol === null ? ':' : protocol;
-    };
-  } else if (typeof weirdURL === 'function') {
-    return _url => {
-      try {
-        let url = new weirdURL(_url);
-        return url.protocol;
-      } catch {
-        // any non-fully qualified url string will trigger an error (because there is no
-        // baseURI that we can provide; in that case we **know** that the protocol is
-        // "safe" because it isn't specifically one of the `badProtocols` listed above
-        // (and those protocols can never be the default baseURI)
-        return ':';
-      }
-    };
-  } else {
-    throw new Error(`@glimmer/runtime needs a valid "globalThis.URL"`);
-  }
-}
-let _protocolForUrlImplementation;
-function protocolForUrl(url) {
-  if (!_protocolForUrlImplementation) {
-    _protocolForUrlImplementation = findProtocolForURL();
-  }
-  return _protocolForUrlImplementation(url);
-}
-function sanitizeAttributeValue(element, attribute, value) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  if (isSafeString(value)) {
-    return value.toHTML();
-  }
-  const tagName = element.tagName.toUpperCase();
-  let str = normalizeStringValue(value);
-  if (checkURI(tagName, attribute)) {
-    let protocol = protocolForUrl(str);
-    if (has(badProtocols, protocol)) {
-      return `unsafe:${str}`;
-    }
-  }
-  if (checkDataURI(tagName, attribute)) {
-    return `unsafe:${str}`;
-  }
-  return str;
-}
-
-function dynamicAttribute(element, attr, namespace, isTrusting = false) {
-  const {
-    tagName,
-    namespaceURI
-  } = element;
-  const attribute = {
-    element,
-    name: attr,
-    namespace
-  };
-  if (attr === 'style' && !isTrusting) {
-    return new DebugStyleAttributeManager(attribute);
-  }
-  if (namespaceURI === NS_SVG) {
-    return buildDynamicAttribute(tagName, attr, attribute);
-  }
-  const {
-    type,
-    normalized
-  } = normalizeProperty(element, attr);
-  if (type === 'attr') {
-    return buildDynamicAttribute(tagName, normalized, attribute);
-  } else {
-    return buildDynamicProperty(tagName, normalized, attribute);
-  }
-}
-function buildDynamicAttribute(tagName, name, attribute) {
-  if (requiresSanitization(tagName, name)) {
-    return new SafeDynamicAttribute(attribute);
-  } else {
-    return new SimpleDynamicAttribute(attribute);
-  }
-}
-function buildDynamicProperty(tagName, name, attribute) {
-  if (requiresSanitization(tagName, name)) {
-    return new SafeDynamicProperty(name, attribute);
-  }
-  if (isUserInputValue(tagName, name)) {
-    return new InputValueDynamicAttribute(name, attribute);
-  }
-  if (isOptionSelected(tagName, name)) {
-    return new OptionSelectedDynamicAttribute(name, attribute);
-  }
-  return new DefaultDynamicProperty(name, attribute);
-}
-class DynamicAttribute {
-  constructor(attribute) {
-    this.attribute = attribute;
-  }
-}
-class SimpleDynamicAttribute extends DynamicAttribute {
-  set(dom, value, _env) {
-    const normalizedValue = normalizeValue(value);
-    if (normalizedValue !== null) {
-      const {
-        name,
-        namespace
-      } = this.attribute;
-      dom.__setAttribute(name, normalizedValue, namespace);
-    }
-  }
-  update(value, _env) {
-    const normalizedValue = normalizeValue(value);
-    const {
-      element,
-      name
-    } = this.attribute;
-    if (normalizedValue === null) {
-      element.removeAttribute(name);
-    } else {
-      element.setAttribute(name, normalizedValue);
-    }
-  }
-}
-class DefaultDynamicProperty extends DynamicAttribute {
-  constructor(normalizedName, attribute) {
-    super(attribute);
-    this.normalizedName = normalizedName;
-  }
-  value;
-  set(dom, value, _env) {
-    if (value !== null && value !== undefined) {
-      this.value = value;
-      dom.__setProperty(this.normalizedName, value);
-    }
-  }
-  update(value, _env) {
-    const {
-      element
-    } = this.attribute;
-    if (this.value !== value) {
-      element[this.normalizedName] = this.value = value;
-      if (value === null || value === undefined) {
-        this.removeAttribute();
-      }
-    }
-  }
-  removeAttribute() {
-    // TODO this sucks but to preserve properties first and to meet current
-    // semantics we must do this.
-    const {
-      element,
-      namespace
-    } = this.attribute;
-    if (namespace) {
-      element.removeAttributeNS(namespace, this.normalizedName);
-    } else {
-      element.removeAttribute(this.normalizedName);
-    }
-  }
-}
-class SafeDynamicProperty extends DefaultDynamicProperty {
-  set(dom, value, env) {
-    const {
-      element,
-      name
-    } = this.attribute;
-    const sanitized = sanitizeAttributeValue(element, name, value);
-    super.set(dom, sanitized, env);
-  }
-  update(value, env) {
-    const {
-      element,
-      name
-    } = this.attribute;
-    const sanitized = sanitizeAttributeValue(element, name, value);
-    super.update(sanitized, env);
-  }
-}
-class SafeDynamicAttribute extends SimpleDynamicAttribute {
-  set(dom, value, env) {
-    const {
-      element,
-      name
-    } = this.attribute;
-    const sanitized = sanitizeAttributeValue(element, name, value);
-    super.set(dom, sanitized, env);
-  }
-  update(value, env) {
-    const {
-      element,
-      name
-    } = this.attribute;
-    const sanitized = sanitizeAttributeValue(element, name, value);
-    super.update(sanitized, env);
-  }
-}
-class InputValueDynamicAttribute extends DefaultDynamicProperty {
-  set(dom, value) {
-    const normalized = normalizeStringValue(value);
-    dom.__setProperty('value', normalized);
-
-    // GH#19219: Browsers don't reflect `input.value = ''` as a value attribute when
-    // type is later changed to "radio"/"checkbox". Explicitly set the attribute for <input>.
-    // Not needed for <textarea> (no value attribute).
-    if (value === '' && this.attribute.element.tagName === 'INPUT') {
-      dom.__setAttribute('value', '', null);
-    }
-  }
-  update(value) {
-    const input = castToBrowser(this.attribute.element);
-    const currentValue = input.value;
-    const normalizedValue = normalizeStringValue(value);
-    if (currentValue !== normalizedValue) {
-      input.value = normalizedValue;
-    }
-  }
-}
-class OptionSelectedDynamicAttribute extends DefaultDynamicProperty {
-  set(dom, value) {
-    if (value !== null && value !== undefined && value !== false) {
-      dom.__setProperty('selected', true);
-    }
-  }
-  update(value) {
-    const option = castToBrowser(this.attribute.element);
-    if (value) {
-      option.selected = true;
-    } else {
-      option.selected = false;
-    }
-  }
-}
-function isOptionSelected(tagName, attribute) {
-  return tagName === 'OPTION' && attribute === 'selected';
-}
-function isUserInputValue(tagName, attribute) {
-  return (tagName === 'INPUT' || tagName === 'TEXTAREA') && attribute === 'value';
-}
-function normalizeValue(value) {
-  if (value === false || value === undefined || value === null || typeof value.toString === 'undefined') {
-    return null;
-  }
-  if (value === true) {
-    return '';
-  }
-  // onclick function etc in SSR
-  if (typeof value === 'function') {
-    return null;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @fixme
-  return String(value);
-}
-let DebugStyleAttributeManager;
-{
-  DebugStyleAttributeManager = class extends SimpleDynamicAttribute {
-    set(dom, value, env) {
-      warnIfStyleNotTrusted(value);
-      super.set(dom, value, env);
-    }
-    update(value, env) {
-      warnIfStyleNotTrusted(value);
-      super.update(value, env);
-    }
-  };
-}
-
-export { COMMENT_NODE as A, TEXT_NODE as B, ConcreteBounds as C, DOMChanges as D, EMPTY_ARGS as E, ELEMENT_NODE as F, DOMOperations as G, DebugRenderTreeImpl as H, isArgumentError as I, APPEND_OPCODES as J, move as K, externs as L, JumpIfNotModifiedOpcode as M, NS_SVG as N, BeginTrackFrameOpcode as O, EndTrackFrameOpcode as P, SimpleDynamicAttribute as S, TEMPLATE_ONLY_COMPONENT_MANAGER as T, VMArgumentsImpl as V, CurriedValue as a, CursorImpl as b, DynamicAttribute as c, EMPTY_NAMED as d, EMPTY_POSITIONAL as e, DOMChangesImpl as f, TemplateOnlyComponentDefinition as g, TemplateOnlyComponentManager as h, array as i, clear as j, concat as k, createCapturedArgs as l, curry as m, dynamicAttribute as n, fn as o, get as p, hash as q, isWhitespace as r, normalizeProperty as s, on as t, reifyArgs as u, reifyNamed as v, reifyPositional as w, resetDebuggerCallback as x, setDebuggerCallback as y, templateOnlyComponent as z };