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

package/dist/{packages/shared-chunks/dynamic-CuBsUXX8.js → dev/packages/shared-chunks/dynamic-CFg3dljk.js}

@@ -1,28 +1,27 @@
-import { v as VM_SYSCALL_SIZE, C as CURRIED_COMPONENT, w as VM_CHILD_SCOPE_OP, x as VM_POP_SCOPE_OP, y as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_POP_DYNAMIC_SCOPE_OP, A as VM_CONSTANT_OP, B as decodeHandle, D as VM_CONSTANT_REFERENCE_OP, E as VM_PRIMITIVE_OP, G as isHandle, H as decodeImmediate, I as VM_PRIMITIVE_REFERENCE_OP, J as VM_DUP_OP, K as VM_POP_OP, L as VM_LOAD_OP, M as VM_FETCH_OP, N as VM_BIND_DYNAMIC_SCOPE_OP, O as VM_ENTER_OP, P as VM_EXIT_OP, Q as VM_PUSH_SYMBOL_TABLE_OP, R as VM_PUSH_BLOCK_SCOPE_OP, S as VM_COMPILE_BLOCK_OP, T as VM_INVOKE_YIELD_OP, U as VM_JUMP_IF_OP, W as VM_JUMP_UNLESS_OP, X as VM_JUMP_EQ_OP, e as VM_ASSERT_SAME_OP, Y as VM_TO_BOOLEAN_OP, Z as VM_TEXT_OP, _ as VM_COMMENT_OP, $ as VM_OPEN_ELEMENT_OP, a0 as VM_OPEN_DYNAMIC_ELEMENT_OP, a1 as VM_PUSH_REMOTE_ELEMENT_OP, a2 as VM_POP_REMOTE_ELEMENT_OP, a3 as VM_FLUSH_ELEMENT_OP, a4 as VM_CLOSE_ELEMENT_OP, a5 as VM_MODIFIER_OP, a6 as VM_DYNAMIC_MODIFIER_OP, a7 as VM_STATIC_ATTR_OP, a8 as VM_DYNAMIC_ATTR_OP, a9 as CURRIED_MODIFIER, aa as VM_PUSH_COMPONENT_DEFINITION_OP, ab as VM_RESOLVE_DYNAMIC_COMPONENT_OP, i as VM_RESOLVE_CURRIED_COMPONENT_OP, j as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, ac as VM_PUSH_ARGS_OP, ad as VM_PUSH_EMPTY_ARGS_OP, ae as VM_CAPTURE_ARGS_OP, af as VM_PREPARE_ARGS_OP, m as managerHasCapability, ag as VM_CREATE_COMPONENT_OP, ah as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, ai as VM_BEGIN_COMPONENT_TRANSACTION_OP, aj as VM_PUT_COMPONENT_OPERATIONS_OP, ak as VM_COMPONENT_ATTR_OP, al as VM_STATIC_COMPONENT_ATTR_OP, am as VM_DID_CREATE_ELEMENT_OP, an as VM_GET_COMPONENT_SELF_OP, ao as VM_GET_COMPONENT_TAG_NAME_OP, ap as VM_GET_COMPONENT_LAYOUT_OP, V as VM_MAIN_OP, aq as VM_POPULATE_LAYOUT_OP, ar as VM_VIRTUAL_ROOT_SCOPE_OP, as as VM_SET_NAMED_VARIABLES_OP, at as VM_SET_BLOCKS_OP, au as VM_INVOKE_COMPONENT_LAYOUT_OP, av as VM_DID_RENDER_LAYOUT_OP, aw as VM_COMMIT_COMPONENT_TRANSACTION_OP, ax as VM_CURRY_OP, ay as VM_DYNAMIC_HELPER_OP, az as CURRIED_HELPER, aA as VM_HELPER_OP, aB as VM_GET_VARIABLE_OP, aC as VM_SET_VARIABLE_OP, aD as VM_SET_BLOCK_OP, aE as VM_ROOT_SCOPE_OP, aF as VM_GET_PROPERTY_OP, aG as VM_GET_BLOCK_OP, aH as VM_SPREAD_BLOCK_OP, aI as VM_HAS_BLOCK_OP, aJ as VM_HAS_BLOCK_PARAMS_OP, aK as VM_CONCAT_OP, aL as VM_IF_INLINE_OP, aM as VM_NOT_OP, aN as VM_GET_DYNAMIC_VAR_OP, aO as VM_LOG_OP, d as VM_CONTENT_TYPE_OP, aP as VM_DYNAMIC_CONTENT_TYPE_OP, f as VM_APPEND_HTML_OP, k as VM_APPEND_SAFE_HTML_OP, g as VM_APPEND_TEXT_OP, l as VM_APPEND_DOCUMENT_FRAGMENT_OP, n as VM_APPEND_NODE_OP, aQ as VM_DEBUGGER_OP, aR as VM_ENTER_LIST_OP, aS as VM_EXIT_LIST_OP, aT as VM_ITERATE_OP } from './capabilities-DHiXCCuB.js';
-import { d as debugToString } from './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
-import { u as unwrap, e as expect, a as isIndexable$1, S as StackImpl, d as dict, i as isDict } from './collections-B8me-ZlQ.js';
+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, createCache, getValue, createUpdatableTag } from '../@glimmer/validator/index.js';
-import { b as createComputeRef, v as valueForRef, d as createConstRef, g as createPrimitiveRef, j as isConstRef, U as UNDEFINED_REFERENCE, N as NULL_REFERENCE, T as TRUE_REFERENCE, F as FALSE_REFERENCE, R as REFERENCE, e as createDebugAliasRef, c as childRefFor, k as isInvokableRef, u as updateRef } from './reference-B6HMX4y0.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, isDestroying, isDestroyed } from '../@glimmer/destroyable/index.js';
-import { b as getInternalModifierManager, a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager, s as setInternalComponentManager, j as setInternalHelperManager, f as hasValue, h as hasDestroyable, k as setInternalModifierManager } from './api-CkUl6KyJ.js';
+import { registerDestructor, destroy, associateDestroyableChild, _hasDestroyableChildren } from '../@glimmer/destroyable/index.js';
+import { d as getInternalModifierManager, g as getInternalHelperManager, b as hasInternalComponentManager, f as hasInternalHelperManager, s as setInternalComponentManager, i as setInternalHelperManager, j as setInternalModifierManager } from './api-BqXkkT0p.js';
+import { m as managerHasCapability } from './capabilities-O_xc7Yqk.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { a as createIteratorRef } from './iterable-BKS7az3P.js';
-import { getOwner } from '../@glimmer/owner/index.js';
-import { a as assert } from './assert-CUCJBR2C.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 unwrapTemplate } from './constants-oDhF27qL.js';
-import { I as InternalComponentCapabilities } from './flags-BsZlvEeR.js';
-import { c as castToBrowser } from './simple-cast-BXTrayoV.js';
+import { a as assert } from './assert-CUCJBR2C.js';
+import { a as unwrapTemplate } from './constants-eoaL3OJQ.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;
-  if (isDevelopingApp()) {
+  {
     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, \`() => {}\`).`);
@@ -201,7 +200,7 @@ function createCurryRef(type, inner, owner, args, resolver, isStrict) {
       // Only components should enter this path, as helpers and modifiers do not
       // support string based resolution
 
-      if (isDevelopingApp()) {
+      {
         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.`);
         }
@@ -280,7 +279,7 @@ function hasCustomDebugRenderTreeLifecycle(manager) {
 
 function resolveComponent(resolver, constants, name, owner) {
   let definition = resolver?.lookupComponent?.(name, expect(owner)) ?? null;
-  if (isDevelopingApp() && !definition) {
+  if (!definition) {
     throw new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
   }
 
@@ -299,7 +298,7 @@ class Ref {
     return this.value;
   }
   release() {
-    if (isDevelopingApp() && this.value === null) {
+    if (this.value === null) {
       throw new Error('BUG: double release?');
     }
     this.value = null;
@@ -339,7 +338,7 @@ class DebugRenderTreeImpl {
     this.enter(state);
   }
   didRender(state, bounds) {
-    if (isDevelopingApp() && this.stack.current !== state) {
+    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}`);
     }
@@ -380,7 +379,7 @@ class DebugRenderTreeImpl {
     this.stack.push(state);
   }
   exit() {
-    if (isDevelopingApp() && this.stack.size === 0) {
+    if (this.stack.size === 0) {
       throw new Error('BUG: unbalanced pop');
     }
     this.stack.pop();
@@ -389,7 +388,7 @@ class DebugRenderTreeImpl {
     return expect(this.nodes.get(state));
   }
   appendChild(node, state) {
-    if (isDevelopingApp() && this.refs.has(state)) {
+    if (this.refs.has(state)) {
       throw new Error('BUG: child already appended');
     }
     let parent = this.stack.current;
@@ -918,10 +917,8 @@ APPEND_OPCODES.add(VM_DYNAMIC_MODIFIER_OP, vm => {
     }
     let manager = getInternalModifierManager(hostDefinition, true);
     if (manager === null) {
-      if (isDevelopingApp()) {
+      {
         throw new Error(`Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was \`{{${ref.debugLabel}}}\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${debugToString?.(hostDefinition)}`);
-      } else {
-        throw new Error('BUG: modifier manager expected');
       }
     }
     let definition = {
@@ -1064,6 +1061,16 @@ class UpdateDynamicAttributeOpcode {
   }
 }
 
+/**
+ * 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
 }) => {
@@ -1087,7 +1094,8 @@ APPEND_OPCODES.add(VM_RESOLVE_DYNAMIC_COMPONENT_OP, (vm, {
   op1: _isStrict
 }) => {
   let stack = vm.stack;
-  let component = check(valueForRef(check(stack.pop(), CheckReference)));
+  let ref = check(stack.pop());
+  let component = check(valueForRef(ref));
   let constants = vm.constants;
   let owner = vm.getOwner();
   let isStrict = constants.getValue(_isStrict);
@@ -1095,7 +1103,7 @@ APPEND_OPCODES.add(VM_RESOLVE_DYNAMIC_COMPONENT_OP, (vm, {
 
   let definition;
   if (typeof component === 'string') {
-    if (isDevelopingApp() && isStrict) {
+    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);
@@ -1105,6 +1113,12 @@ APPEND_OPCODES.add(VM_RESOLVE_DYNAMIC_COMPONENT_OP, (vm, {
   } 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 => {
@@ -1113,17 +1127,23 @@ APPEND_OPCODES.add(VM_RESOLVE_CURRIED_COMPONENT_OP, vm => {
   let value = valueForRef(ref);
   let constants = vm.constants;
   let definition;
-  if (isDevelopingApp() && !(typeof value === 'function' || typeof value === 'object' && value !== null)) {
+  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 (isDevelopingApp() && definition === null) {
+    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 => {
@@ -1298,7 +1318,7 @@ APPEND_OPCODES.add(VM_REGISTER_COMPONENT_DESTRUCTOR_OP, (vm, {
     capabilities
   } = check(vm.fetchValue(check(register, CheckRegister)));
   let d = manager.getDestroyable(state);
-  if (isDevelopingApp() && !managerHasCapability(manager, capabilities, InternalComponentCapabilities.willDestroy) && d !== null && "string" in d) {
+  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);
@@ -1307,7 +1327,7 @@ APPEND_OPCODES.add(VM_BEGIN_COMPONENT_TRANSACTION_OP, (vm, {
   op1: register
 }) => {
   let name;
-  if (isDevelopingApp()) {
+  {
     let {
       definition,
       manager
@@ -1790,6 +1810,14 @@ class ReferenceChecker {
 }
 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();
@@ -2011,11 +2039,9 @@ class NamedArgumentsImpl {
       return UNDEFINED_REFERENCE;
     }
     let ref = stack.get(idx, base);
-    if (isDevelopingApp()) {
+    {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       return createDebugAliasRef(atNames ? name : `@${name}`, ref);
-    } else {
-      return ref;
     }
   }
   capture() {
@@ -2025,11 +2051,9 @@ class NamedArgumentsImpl {
     } = this;
     let map = dict();
     for (const [i, name] of enumerate(names)) {
-      if (isDevelopingApp()) {
+      {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
         map[name] = createDebugAliasRef(`@${name}`, unwrap(references[i]));
-      } else {
-        map[name] = unwrap(references[i]);
       }
     }
     return map;
@@ -2271,7 +2295,7 @@ APPEND_OPCODES.add(VM_CURRY_OP, (vm, {
   let owner = vm.getOwner();
   let resolver = vm.context.resolver;
   let isStrict = false;
-  if (isDevelopingApp()) {
+  {
     // strict check only happens in import.meta.env.DEV builds, no reason to load it otherwise
     isStrict = vm.constants.getValue(decodeHandle(_isStrict));
   }
@@ -2523,7 +2547,7 @@ function toDynamicContentType(value) {
   if (isCurriedType(value, CURRIED_COMPONENT) || hasInternalComponentManager(value)) {
     return ContentType.Component;
   } else {
-    if (isDevelopingApp() && !isCurriedType(value, CURRIED_HELPER) && !hasInternalHelperManager(value)) {
+    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}`);
@@ -2892,22 +2916,27 @@ function normalizeProperty(element, slotName) {
   };
 }
 
-// properties that MUST be set as attributes, due to:
-// * browser bug
-// * strange spec outlier
+// 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,
-    // Chrome 46.0.2464.0: 'autocorrect' in document.createElement('input') === false
-    // Safari 8.0.7: 'autocorrect' in document.createElement('input') === false
-    // Mobile Safari (iOS 8.4 simulator): 'autocorrect' in document.createElement('input') === 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,
-    // Chrome 54.0.2840.98: 'list' in document.createElement('input') === true
-    // Safari 9.1.3: 'list' in document.createElement('input') === false
+    // 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
   },
-  // element.form is actually a legitimate readOnly property, that is to be
-  // mutated, but must be mutated by setAttribute...
   SELECT: {
     form: true
   },
@@ -3094,7 +3123,7 @@ const fn = internalHelper(({
   return createComputeRef(() => {
     return (...invocationArgs) => {
       let [fn, ...args] = reifyPositional(positional);
-      if (isDevelopingApp()) assertCallbackIsFn(callbackRef);
+      assertCallbackIsFn(callbackRef);
       if (isInvokableRef(callbackRef)) {
         let value = args.length > 0 ? args[0] : invocationArgs[0];
         return void updateRef(callbackRef, value);
@@ -3259,64 +3288,6 @@ const hash = internalHelper(({
   return ref;
 });
 
-let ARGS_CACHES = isDevelopingApp() ? new WeakMap() : undefined;
-function getArgs(proxy) {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-  return getValue(isDevelopingApp() ? ARGS_CACHES.get(proxy) : proxy.argsCache);
-}
-class SimpleArgsProxy {
-  argsCache;
-  constructor(context, computeArgs = () => EMPTY_ARGS) {
-    let argsCache = createCache(() => computeArgs(context));
-    if (isDevelopingApp()) {
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-      ARGS_CACHES.set(this, argsCache);
-      Object.freeze(this);
-    } else {
-      this.argsCache = argsCache;
-    }
-  }
-  get named() {
-    return getArgs(this).named || EMPTY_NAMED;
-  }
-  get positional() {
-    return getArgs(this).positional || EMPTY_POSITIONAL;
-  }
-}
-
-////////////
-
-function invokeHelper(context, definition, computeArgs) {
-  if (isDevelopingApp() && (typeof context !== 'object' || context === null)) {
-    throw new Error(`Expected a context object to be passed as the first parameter to invokeHelper, got ${context}`);
-  }
-  const owner = getOwner(context);
-  const internalManager = getInternalHelperManager(definition);
-  if (isDevelopingApp() && typeof internalManager === 'function') {
-    throw new Error('Found a helper manager, but it was an internal built-in helper manager. `invokeHelper` does not support internal helpers yet.');
-  }
-  const manager = internalManager.getDelegateFor(owner);
-  let args = new SimpleArgsProxy(context, computeArgs);
-  let bucket = manager.createHelper(definition, args);
-  let cache;
-  if (hasValue(manager)) {
-    cache = createCache(() => {
-      if (isDevelopingApp() && (isDestroying(cache) || isDestroyed(cache))) {
-        throw new Error(`You attempted to get the value of a helper after the helper was destroyed, which is not allowed`);
-      }
-      return manager.getValue(bucket);
-    });
-    associateDestroyableChild(context, cache);
-  } else {
-    throw new Error('TODO: unreachable, to be implemented with hasScheduledEffect');
-  }
-  if (hasDestroyable(manager)) {
-    let destroyable = manager.getDestroyable(bucket);
-    associateDestroyableChild(cache, destroyable);
-  }
-  return cache;
-}
-
 const untouchableContext = buildUntouchableThis('`on` modifier');
 class OnModifierState {
   tag = createUpdatableTag();
@@ -3349,18 +3320,28 @@ class OnModifierState {
       args,
       listener
     } = this;
-    assert(args.positional[0]);
-    let eventName = check(valueForRef(args.positional[0]));
+    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);
-    assert(typeof userProvidedCallback === 'function', `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 ?? `{unlabeled value}`}`);
-    if (isDevelopingApp() && 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.`);
+    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;
-    if (isDevelopingApp()) {
+    {
       let {
         once: _once,
         passive: _passive,
@@ -3371,22 +3352,7 @@ class OnModifierState {
       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(', ')}.`);
-      }
-    } else {
-      let {
-        once: _once,
-        passive: _passive,
-        capture: _capture
-      } = args.named;
-      if (_once) {
-        once = valueForRef(_once);
-      }
-      if (_passive) {
-        passive = valueForRef(_passive);
-      }
-      if (_capture) {
-        capture = valueForRef(_capture);
+        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;
@@ -3410,7 +3376,7 @@ class OnModifierState {
     }
     if (shouldUpdate) {
       let callback = userProvidedCallback;
-      if (isDevelopingApp()) {
+      {
         callback = userProvidedCallback.bind(untouchableContext);
         if (passive) {
           let _callback = callback;
@@ -3663,7 +3629,7 @@ function dynamicAttribute(element, attr, namespace, isTrusting = false) {
     name: attr,
     namespace
   };
-  if (isDevelopingApp() && attr === 'style' && !isTrusting) {
+  if (attr === 'style' && !isTrusting) {
     return new DebugStyleAttributeManager(attribute);
   }
   if (namespaceURI === NS_SVG) {
@@ -3802,7 +3768,15 @@ class SafeDynamicAttribute extends SimpleDynamicAttribute {
 }
 class InputValueDynamicAttribute extends DefaultDynamicProperty {
   set(dom, value) {
-    dom.__setProperty('value', normalizeStringValue(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);
@@ -3850,7 +3824,7 @@ function normalizeValue(value) {
   return String(value);
 }
 let DebugStyleAttributeManager;
-if (isDevelopingApp()) {
+{
   DebugStyleAttributeManager = class extends SimpleDynamicAttribute {
     set(dom, value, env) {
       warnIfStyleNotTrusted(value);
@@ -3863,4 +3837,4 @@ if (isDevelopingApp()) {
   };
 }
 
-export { APPEND_OPCODES as A, BeginTrackFrameOpcode as B, ConcreteBounds as C, DOMChanges as D, EndTrackFrameOpcode as E, TemplateOnlyComponentManager as F, createCapturedArgs as G, curry as H, isWhitespace as I, JumpIfNotModifiedOpcode as J, normalizeProperty as K, reifyArgs as L, reifyNamed as M, NS_SVG as N, reifyPositional as O, resetDebuggerCallback as P, setDebuggerCallback as Q, SimpleDynamicAttribute as S, TEXT_NODE as T, VMArgumentsImpl as V, array as a, DOMOperations as b, concat as c, CursorImpl as d, dynamicAttribute as e, fn as f, get as g, hash as h, invokeHelper as i, clear as j, DebugRenderTreeImpl as k, isArgumentError as l, DOMChangesImpl as m, move as n, on as o, externs as p, COMMENT_NODE as q, ELEMENT_NODE as r, CurriedValue as s, templateOnlyComponent as t, DynamicAttribute as u, EMPTY_ARGS as v, EMPTY_NAMED as w, EMPTY_POSITIONAL as x, TEMPLATE_ONLY_COMPONENT_MANAGER as y, TemplateOnlyComponentDefinition as z };
+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 };

package/dist/{packages/shared-chunks/element-builder-BuVym8EM.js → dev/packages/shared-chunks/element-builder-BOxP8emt.js}

@@ -1,10 +1,9 @@
-import { b as DOMOperations, d as CursorImpl, C as ConcreteBounds, e as dynamicAttribute, j as clear } from './dynamic-CuBsUXX8.js';
+import { G as DOMOperations, b as CursorImpl, C as ConcreteBounds, n as dynamicAttribute, j as clear } from './dynamic-CFg3dljk.js';
 import { a as assert } from './assert-CUCJBR2C.js';
 import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
-import './debug-to-string-BsFOvUtQ.js';
-import { S as StackImpl, e as expect } from './collections-B8me-ZlQ.js';
-import '@embroider/macros';
-import { destroy, registerDestructor } from '../@glimmer/destroyable/index.js';
+import './debug-to-string-CFb7h0lY.js';
+import { S as StackImpl, e as expect } from './collections-D_nY_0UJ.js';
+import { registerDestructor, destroy } from '../@glimmer/destroyable/index.js';
 
 class TreeConstruction extends DOMOperations {
   createElementNS(namespace, tag) {

package/dist/{packages/shared-chunks/flags-BsZlvEeR.js → dev/packages/shared-chunks/flags-B9qxc-pB.js}

@@ -21,4 +21,4 @@ const TYPE_MASK = 0b00000000000000000000000011111111;
 const OPERAND_LEN_MASK = 0b00000000000000000000001100000000;
 const MACHINE_MASK = 0b00000000000000000000010000000000;
 
-export { ARG_SHIFT as A, InternalComponentCapabilities as I, MAX_SIZE as M, OPERAND_LEN_MASK as O, TYPE_SIZE as T, MACHINE_MASK as a, TYPE_MASK as b };
+export { ARG_SHIFT as A, InternalComponentCapabilities as I, MACHINE_MASK as M, OPERAND_LEN_MASK as O, TYPE_MASK as T, MAX_SIZE as a, TYPE_SIZE as b };

package/dist/{packages/shared-chunks/capabilities-DHiXCCuB.js → dev/packages/shared-chunks/fragment-Cc5k9Oy4.js}

@@ -1,11 +1,6 @@
-import './debug-to-string-BsFOvUtQ.js';
-import { isDevelopingApp } from '@embroider/macros';
 import { e as $v0, f as $t1, g as $t0, h as $s1, $ as $s0, d as $sp, c as $fp, b as $ra, a as $pc } from './registers-ylirb0dq.js';
+import './debug-to-string-CFb7h0lY.js';
 import { b as assertNever } from './assert-CUCJBR2C.js';
-import '../@glimmer/global-context/index.js';
-import '../@glimmer/validator/index.js';
-import './reference-B6HMX4y0.js';
-import { I as InternalComponentCapabilities } from './flags-BsZlvEeR.js';
 
 const CURRIED_COMPONENT = 0;
 const CURRIED_HELPER = 1;
@@ -913,30 +908,4 @@ const as = Object.fromEntries(Object.entries(STYLES).map(([k, v]) => [k, value =
   style: v
 })]));
 
-const FROM_CAPABILITIES = isDevelopingApp() ? new WeakSet() : undefined;
-function buildCapabilities(capabilities) {
-  if (isDevelopingApp()) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-    FROM_CAPABILITIES.add(capabilities);
-    Object.freeze(capabilities);
-  }
-  return capabilities;
-}
-const EMPTY = InternalComponentCapabilities.Empty;
-/**
- * Converts a ComponentCapabilities object into a 32-bit integer representation.
- */
-function capabilityFlagsFrom(capabilities) {
-  return EMPTY | capability(capabilities, 'dynamicLayout') | capability(capabilities, 'dynamicTag') | capability(capabilities, 'prepareArgs') | capability(capabilities, 'createArgs') | capability(capabilities, 'attributeHook') | capability(capabilities, 'elementHook') | capability(capabilities, 'dynamicScope') | capability(capabilities, 'createCaller') | capability(capabilities, 'updateHook') | capability(capabilities, 'createInstance') | capability(capabilities, 'wrapped') | capability(capabilities, 'willDestroy') | capability(capabilities, 'hasSubOwner');
-}
-function capability(capabilities, capability) {
-  return capabilities[capability] ? InternalComponentCapabilities[capability] : EMPTY;
-}
-function managerHasCapability(_manager, capabilities, capability) {
-  return !!(capabilities & capability);
-}
-function hasCapability(capabilities, capability) {
-  return !!(capabilities & capability);
-}
-
-export { VM_OPEN_ELEMENT_OP as $, VM_CONSTANT_OP as A, decodeHandle as B, CURRIED_COMPONENT as C, VM_CONSTANT_REFERENCE_OP as D, VM_PRIMITIVE_OP as E, FROM_CAPABILITIES as F, isHandle as G, decodeImmediate as H, VM_PRIMITIVE_REFERENCE_OP as I, VM_DUP_OP as J, VM_POP_OP as K, VM_LOAD_OP as L, VM_FETCH_OP as M, VM_BIND_DYNAMIC_SCOPE_OP as N, VM_ENTER_OP as O, VM_EXIT_OP as P, VM_PUSH_SYMBOL_TABLE_OP as Q, VM_PUSH_BLOCK_SCOPE_OP as R, VM_COMPILE_BLOCK_OP as S, VM_INVOKE_YIELD_OP as T, VM_JUMP_IF_OP as U, VM_MAIN_OP as V, VM_JUMP_UNLESS_OP as W, VM_JUMP_EQ_OP as X, VM_TO_BOOLEAN_OP as Y, VM_TEXT_OP as Z, VM_COMMENT_OP as _, constants as a, VM_OPEN_DYNAMIC_ELEMENT_OP as a0, VM_PUSH_REMOTE_ELEMENT_OP as a1, VM_POP_REMOTE_ELEMENT_OP as a2, VM_FLUSH_ELEMENT_OP as a3, VM_CLOSE_ELEMENT_OP as a4, VM_MODIFIER_OP as a5, VM_DYNAMIC_MODIFIER_OP as a6, VM_STATIC_ATTR_OP as a7, VM_DYNAMIC_ATTR_OP as a8, CURRIED_MODIFIER as a9, VM_HELPER_OP as aA, VM_GET_VARIABLE_OP as aB, VM_SET_VARIABLE_OP as aC, VM_SET_BLOCK_OP as aD, VM_ROOT_SCOPE_OP as aE, VM_GET_PROPERTY_OP as aF, VM_GET_BLOCK_OP as aG, VM_SPREAD_BLOCK_OP as aH, VM_HAS_BLOCK_OP as aI, VM_HAS_BLOCK_PARAMS_OP as aJ, VM_CONCAT_OP as aK, VM_IF_INLINE_OP as aL, VM_NOT_OP as aM, VM_GET_DYNAMIC_VAR_OP as aN, VM_LOG_OP as aO, VM_DYNAMIC_CONTENT_TYPE_OP as aP, VM_DEBUGGER_OP as aQ, VM_ENTER_LIST_OP as aR, VM_EXIT_LIST_OP as aS, VM_ITERATE_OP as aT, encodeHandle as aU, isMachineOp as aV, isSmallInt as aW, encodeImmediate as aX, VM_PUSH_COMPONENT_DEFINITION_OP as aa, VM_RESOLVE_DYNAMIC_COMPONENT_OP as ab, VM_PUSH_ARGS_OP as ac, VM_PUSH_EMPTY_ARGS_OP as ad, VM_CAPTURE_ARGS_OP as ae, VM_PREPARE_ARGS_OP as af, VM_CREATE_COMPONENT_OP as ag, VM_REGISTER_COMPONENT_DESTRUCTOR_OP as ah, VM_BEGIN_COMPONENT_TRANSACTION_OP as ai, VM_PUT_COMPONENT_OPERATIONS_OP as aj, VM_COMPONENT_ATTR_OP as ak, VM_STATIC_COMPONENT_ATTR_OP as al, VM_DID_CREATE_ELEMENT_OP as am, VM_GET_COMPONENT_SELF_OP as an, VM_GET_COMPONENT_TAG_NAME_OP as ao, VM_GET_COMPONENT_LAYOUT_OP as ap, VM_POPULATE_LAYOUT_OP as aq, VM_VIRTUAL_ROOT_SCOPE_OP as ar, VM_SET_NAMED_VARIABLES_OP as as, VM_SET_BLOCKS_OP as at, VM_INVOKE_COMPONENT_LAYOUT_OP as au, VM_DID_RENDER_LAYOUT_OP as av, VM_COMMIT_COMPONENT_TRANSACTION_OP as aw, VM_CURRY_OP as ax, VM_DYNAMIC_HELPER_OP as ay, CURRIED_HELPER as az, buildCapabilities as b, capabilityFlagsFrom as c, VM_CONTENT_TYPE_OP as d, VM_ASSERT_SAME_OP as e, VM_APPEND_HTML_OP as f, VM_APPEND_TEXT_OP as g, hasCapability as h, VM_RESOLVE_CURRIED_COMPONENT_OP as i, VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP as j, VM_APPEND_SAFE_HTML_OP as k, VM_APPEND_DOCUMENT_FRAGMENT_OP as l, managerHasCapability as m, VM_APPEND_NODE_OP as n, VM_INVOKE_STATIC_OP as o, VM_RETURN_TO_OP as p, VM_RETURN_OP as q, VM_JUMP_OP as r, VM_INVOKE_VIRTUAL_OP as s, VM_POP_FRAME_OP as t, VM_PUSH_FRAME_OP as u, VM_SYSCALL_SIZE as v, VM_CHILD_SCOPE_OP as w, VM_POP_SCOPE_OP as x, VM_PUSH_DYNAMIC_SCOPE_OP as y, VM_POP_DYNAMIC_SCOPE_OP as z };
+export { VM_CLOSE_ELEMENT_OP as $, isHandle as A, decodeImmediate as B, CURRIED_COMPONENT as C, VM_PRIMITIVE_REFERENCE_OP as D, VM_DUP_OP as E, VM_POP_OP as F, VM_LOAD_OP as G, VM_FETCH_OP as H, VM_BIND_DYNAMIC_SCOPE_OP as I, VM_ENTER_OP as J, VM_EXIT_OP as K, VM_PUSH_SYMBOL_TABLE_OP as L, VM_PUSH_BLOCK_SCOPE_OP as M, VM_COMPILE_BLOCK_OP as N, VM_INVOKE_YIELD_OP as O, VM_JUMP_IF_OP as P, VM_JUMP_UNLESS_OP as Q, VM_JUMP_EQ_OP as R, VM_TO_BOOLEAN_OP as S, VM_TEXT_OP as T, VM_COMMENT_OP as U, VM_MAIN_OP as V, VM_OPEN_ELEMENT_OP as W, VM_OPEN_DYNAMIC_ELEMENT_OP as X, VM_PUSH_REMOTE_ELEMENT_OP as Y, VM_POP_REMOTE_ELEMENT_OP as Z, VM_FLUSH_ELEMENT_OP as _, VM_CONTENT_TYPE_OP as a, VM_MODIFIER_OP as a0, VM_DYNAMIC_MODIFIER_OP as a1, VM_STATIC_ATTR_OP as a2, VM_DYNAMIC_ATTR_OP as a3, CURRIED_MODIFIER as a4, VM_PUSH_COMPONENT_DEFINITION_OP as a5, VM_RESOLVE_DYNAMIC_COMPONENT_OP as a6, VM_PUSH_ARGS_OP as a7, VM_PUSH_EMPTY_ARGS_OP as a8, VM_CAPTURE_ARGS_OP as a9, VM_GET_PROPERTY_OP as aA, VM_GET_BLOCK_OP as aB, VM_SPREAD_BLOCK_OP as aC, VM_HAS_BLOCK_OP as aD, VM_HAS_BLOCK_PARAMS_OP as aE, VM_CONCAT_OP as aF, VM_IF_INLINE_OP as aG, VM_NOT_OP as aH, VM_GET_DYNAMIC_VAR_OP as aI, VM_LOG_OP as aJ, VM_DYNAMIC_CONTENT_TYPE_OP as aK, VM_DEBUGGER_OP as aL, VM_ENTER_LIST_OP as aM, VM_EXIT_LIST_OP as aN, VM_ITERATE_OP as aO, encodeHandle as aP, isMachineOp as aQ, isSmallInt as aR, encodeImmediate as aS, VM_PREPARE_ARGS_OP as aa, VM_CREATE_COMPONENT_OP as ab, VM_REGISTER_COMPONENT_DESTRUCTOR_OP as ac, VM_BEGIN_COMPONENT_TRANSACTION_OP as ad, VM_PUT_COMPONENT_OPERATIONS_OP as ae, VM_COMPONENT_ATTR_OP as af, VM_STATIC_COMPONENT_ATTR_OP as ag, VM_DID_CREATE_ELEMENT_OP as ah, VM_GET_COMPONENT_SELF_OP as ai, VM_GET_COMPONENT_TAG_NAME_OP as aj, VM_GET_COMPONENT_LAYOUT_OP as ak, VM_POPULATE_LAYOUT_OP as al, VM_VIRTUAL_ROOT_SCOPE_OP as am, VM_SET_NAMED_VARIABLES_OP as an, VM_SET_BLOCKS_OP as ao, VM_INVOKE_COMPONENT_LAYOUT_OP as ap, VM_DID_RENDER_LAYOUT_OP as aq, VM_COMMIT_COMPONENT_TRANSACTION_OP as ar, VM_CURRY_OP as as, VM_DYNAMIC_HELPER_OP as at, CURRIED_HELPER as au, VM_HELPER_OP as av, VM_GET_VARIABLE_OP as aw, VM_SET_VARIABLE_OP as ax, VM_SET_BLOCK_OP as ay, VM_ROOT_SCOPE_OP as az, VM_ASSERT_SAME_OP as b, constants as c, VM_APPEND_HTML_OP as d, VM_APPEND_TEXT_OP as e, VM_RESOLVE_CURRIED_COMPONENT_OP as f, VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP as g, VM_APPEND_SAFE_HTML_OP as h, VM_APPEND_DOCUMENT_FRAGMENT_OP as i, VM_APPEND_NODE_OP as j, VM_INVOKE_STATIC_OP as k, VM_RETURN_TO_OP as l, VM_RETURN_OP as m, VM_JUMP_OP as n, VM_INVOKE_VIRTUAL_OP as o, VM_POP_FRAME_OP as p, VM_PUSH_FRAME_OP as q, VM_SYSCALL_SIZE as r, VM_CHILD_SCOPE_OP as s, VM_POP_SCOPE_OP as t, VM_PUSH_DYNAMIC_SCOPE_OP as u, VM_POP_DYNAMIC_SCOPE_OP as v, VM_CONSTANT_OP as w, decodeHandle as x, VM_CONSTANT_REFERENCE_OP as y, VM_PRIMITIVE_OP as z };