ember-source 7.3.0-alpha.5 → 7.3.0

package/dist/dev/packages/shared-chunks/{arguments-CDkbOqTS.js → arguments-BVmnQtAM.js}

@@ -5,16 +5,16 @@ import { c as createComputeRef, v as valueForRef, a as createConstRef, e as crea
 import { b as EMPTY_STRING_ARRAY, e as enumerate, c as emptyArray } from './array-utils-CZQxrdD3.js';
 import { C as CONSTANT_TAG, I as INITIAL, v as validateTag, c as consumeTag, a as valueForTag, o as beginTrackFrame, s as endTrackFrame, k as CURRENT_TAG } from './cache-DGDPVCpC.js';
 import { C as CURRIED_MODIFIER, a as CURRIED_COMPONENT } from './curried-BZnYakIg.js';
-import { j as VM_SYSCALL_SIZE, k as VM_CHILD_SCOPE_OP, l as VM_POP_SCOPE_OP, m as VM_PUSH_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, o as VM_CONSTANT_OP, p as decodeHandle, q as VM_CONSTANT_REFERENCE_OP, r as VM_PRIMITIVE_OP, s as isHandle, t as decodeImmediate, u as VM_PRIMITIVE_REFERENCE_OP, v as VM_DUP_OP, w as VM_POP_OP, x as VM_LOAD_OP, y as VM_FETCH_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, A as VM_ENTER_OP, B as VM_EXIT_OP, C as VM_PUSH_SYMBOL_TABLE_OP, D as VM_PUSH_BLOCK_SCOPE_OP, E as VM_COMPILE_BLOCK_OP, F as VM_INVOKE_YIELD_OP, G as VM_JUMP_IF_OP, H as VM_JUMP_UNLESS_OP, I as VM_JUMP_EQ_OP, b as VM_ASSERT_SAME_OP, J as VM_TO_BOOLEAN_OP, K as VM_TEXT_OP, L as VM_COMMENT_OP, M as VM_OPEN_ELEMENT_OP, N as VM_OPEN_DYNAMIC_ELEMENT_OP, O as VM_PUSH_REMOTE_ELEMENT_OP, P as VM_POP_REMOTE_ELEMENT_OP, Q as VM_FLUSH_ELEMENT_OP, R as VM_CLOSE_ELEMENT_OP, S as VM_MODIFIER_OP, T as VM_DYNAMIC_MODIFIER_OP, U as VM_STATIC_ATTR_OP, W as VM_DYNAMIC_ATTR_OP, X as VM_PUSH_COMPONENT_DEFINITION_OP, Y as VM_RESOLVE_DYNAMIC_COMPONENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, Z as VM_PUSH_ARGS_OP, _ as VM_PUSH_EMPTY_ARGS_OP, $ as VM_CAPTURE_ARGS_OP, a0 as VM_PREPARE_ARGS_OP, a1 as VM_CREATE_COMPONENT_OP, a2 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a3 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a4 as VM_PUT_COMPONENT_OPERATIONS_OP, a5 as VM_COMPONENT_ATTR_OP, a6 as VM_STATIC_COMPONENT_ATTR_OP, a7 as VM_DID_CREATE_ELEMENT_OP, a8 as VM_GET_COMPONENT_SELF_OP, a9 as VM_GET_COMPONENT_TAG_NAME_OP, aa as VM_GET_COMPONENT_LAYOUT_OP, V as VM_MAIN_OP, ab as VM_POPULATE_LAYOUT_OP, ac as VM_VIRTUAL_ROOT_SCOPE_OP, ad as VM_SET_NAMED_VARIABLES_OP, ae as VM_SET_BLOCKS_OP, af as VM_INVOKE_COMPONENT_LAYOUT_OP, ag as VM_DID_RENDER_LAYOUT_OP, ah as VM_COMMIT_COMPONENT_TRANSACTION_OP } from './syscall-ops-CN7STuUn.js';
+import { j as VM_SYSCALL_SIZE, k as VM_CHILD_SCOPE_OP, l as VM_POP_SCOPE_OP, m as VM_PUSH_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, o as VM_CONSTANT_OP, p as decodeHandle, q as VM_CONSTANT_REFERENCE_OP, r as VM_PRIMITIVE_OP, s as isHandle, t as decodeImmediate, u as VM_PRIMITIVE_REFERENCE_OP, v as VM_DUP_OP, w as VM_POP_OP, x as VM_LOAD_OP, y as VM_FETCH_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, A as VM_ENTER_OP, B as VM_EXIT_OP, C as VM_PUSH_SYMBOL_TABLE_OP, D as VM_PUSH_BLOCK_SCOPE_OP, E as VM_COMPILE_BLOCK_OP, F as VM_INVOKE_YIELD_OP, G as VM_JUMP_UNLESS_OP, H as VM_JUMP_EQ_OP, b as VM_ASSERT_SAME_OP, I as VM_TO_BOOLEAN_OP, J as VM_TEXT_OP, K as VM_COMMENT_OP, L as VM_OPEN_ELEMENT_OP, M as VM_OPEN_DYNAMIC_ELEMENT_OP, N as VM_PUSH_REMOTE_ELEMENT_OP, O as VM_POP_REMOTE_ELEMENT_OP, P as VM_FLUSH_ELEMENT_OP, Q as VM_CLOSE_ELEMENT_OP, R as VM_MODIFIER_OP, S as VM_DYNAMIC_MODIFIER_OP, T as VM_STATIC_ATTR_OP, U as VM_DYNAMIC_ATTR_OP, W as VM_PUSH_COMPONENT_DEFINITION_OP, X as VM_RESOLVE_DYNAMIC_COMPONENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, Y as VM_PUSH_ARGS_OP, Z as VM_PUSH_EMPTY_ARGS_OP, _ as VM_CAPTURE_ARGS_OP, $ as VM_PREPARE_ARGS_OP, a0 as VM_CREATE_COMPONENT_OP, a1 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a2 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a3 as VM_PUT_COMPONENT_OPERATIONS_OP, a4 as VM_COMPONENT_ATTR_OP, a5 as VM_STATIC_COMPONENT_ATTR_OP, a6 as VM_DID_CREATE_ELEMENT_OP, a7 as VM_GET_COMPONENT_SELF_OP, a8 as VM_GET_COMPONENT_TAG_NAME_OP, a9 as VM_GET_COMPONENT_LAYOUT_OP, V as VM_MAIN_OP, aa as VM_POPULATE_LAYOUT_OP, ab as VM_VIRTUAL_ROOT_SCOPE_OP, ac as VM_SET_NAMED_VARIABLES_OP, ad as VM_SET_BLOCKS_OP, ae as VM_INVOKE_COMPONENT_LAYOUT_OP, af as VM_DID_RENDER_LAYOUT_OP, ag as VM_COMMIT_COMPONENT_TRANSACTION_OP } from './syscall-ops-CkPT1Kfx.js';
 import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
 import { u as unwrapTemplate } from './template-BRrQR6KS.js';
 import { registerDestructor, destroy, associateDestroyableChild } from '../@glimmer/destroyable/index.js';
+import { b as getInternalModifierManager, c as hasInternalComponentManager } from './api-DuLOZMO_.js';
 import { m as managerHasCapability } from './capabilities-CajW4QjE.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { I as InternalComponentCapabilities } from './flags-BZxHQ0yn.js';
 import { n as normalizeStringValue, C as ConcreteBounds } from './normalize-CKySQVU7.js';
-import { b as getInternalModifierManager } from './api-DuLOZMO_.js';
 import { toBool } from '../@glimmer/global-context/index.js';
 
 function CheckInstanceof(Class) {
@@ -498,22 +498,6 @@ APPEND_OPCODES.add(VM_INVOKE_YIELD_OP, vm => {
   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
 }) => {
@@ -815,7 +799,11 @@ APPEND_OPCODES.add(VM_DYNAMIC_MODIFIER_OP, vm => {
     }
   }
   if (!isConstRef(ref) || tag) {
-    return vm.updateWith(new UpdateDynamicModifierOpcode(tag, instance, instanceRef));
+    let updateOpcode = new UpdateDynamicModifierOpcode(tag, instance, instanceRef);
+
+    // The block must own this opcode, or instances created on update are never destroyed.
+    vm.associateDestroyable(updateOpcode);
+    return vm.updateWith(updateOpcode);
   }
 });
 class UpdateModifierOpcode {
@@ -972,6 +960,9 @@ APPEND_OPCODES.add(VM_RESOLVE_DYNAMIC_COMPONENT_OP, (vm, {
   let isStrict = constants.getValue(_isStrict);
   vm.loadValue($t1, null); // Clear the temp register
 
+  {
+    assert(component === null || component === undefined || typeof component === 'string' || isCurriedValue(component) || (typeof component === 'object' || typeof component === 'function') && hasInternalComponentManager(component));
+  }
   let definition;
   if (typeof component === 'string') {
     if (isStrict) {

package/dist/dev/packages/shared-chunks/{compiler-QUSl_urU.js → compiler-BHFFl-fv.js}

@@ -5,7 +5,7 @@ import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { i as isVoidTag, b as build, v as voidMap, P as Printer } from './transform-resolutions-h1ik8gqW.js';
 import { u as unwrap, e as expect, d as dict, b as exhausted } from './collections-DPkjqeA3.js';
-import { o as opcodes } from './opcodes-CplRyHl_.js';
+import { o as opcodes } from './opcodes-DDajoGhq.js';
 import { C as CURRIED_MODIFIER, b as CURRIED_HELPER, a as CURRIED_COMPONENT } from './curried-BZnYakIg.js';
 import { a as WellKnownTagNames, W as WellKnownAttrNames } from './well-known-_EVO9RaV.js';
 

package/dist/dev/packages/shared-chunks/{curly-BbL6STF2.js → curly-qZIwixUW.js}

@@ -4,7 +4,7 @@ import { getViewElement, clearElementView, clearViewElement, addChildView, setVi
 import { debugFreeze } from '../@ember/debug/index.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { c as createComputeRef, v as valueForRef, e as createPrimitiveRef, f as childRefFor, g as childRefFromParts, a as createConstRef, d as isUpdatableRef, u as updateRef } from './reference-BqOLhKFy.js';
-import { f as reifyPositional } from './arguments-CDkbOqTS.js';
+import { f as reifyPositional } from './arguments-BVmnQtAM.js';
 import { E as EMPTY_ARRAY } from './array-utils-CZQxrdD3.js';
 import { a as valueForTag, p as beginUntrackFrame, w as endUntrackFrame, o as beginTrackFrame, s as endTrackFrame, c as consumeTag, v as validateTag } from './cache-DGDPVCpC.js';
 import { g as get } from './property_get-DXwpgTe7.js';

package/dist/dev/packages/shared-chunks/{element-BYLB-q7a.js → element-Cgoi4ldD.js}

@@ -67,30 +67,6 @@ function getElementDefinition(tagName) {
 
 // ============ Element Helper ============
 
-/**
-  The `element` helper lets you dynamically set the tag name of an element.
-
-  ```handlebars
-  {{#let (element @tagName) as |Tag|}}
-    <Tag class="my-element">Hello</Tag>
-  {{/let}}
-  ```
-
-  When `@tagName` is `"h1"`, this renders `<h1 class="my-element">Hello</h1>`.
-
-  When `@tagName` is an empty string `""`, the block content is rendered without
-  a wrapping element.
-
-  Passing `null`, `undefined`, or non-string values will throw an assertion error.
-
-  Changing the tag name will tear down and recreate the element and its contents.
- 
-  The `element` helper is built-in and does not need to be imported.
-
-  @method element
-  @for Ember.Templates.helpers
-  @public
-*/
 const element = internalHelper(({
   positional,
   named

package/dist/dev/packages/shared-chunks/get-BVBR6Afa.js

@@ -0,0 +1,40 @@
+import { c as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-BqOLhKFy.js';
+import { f as reifyPositional } from './arguments-BVmnQtAM.js';
+import { i as internalHelper } from './hash-BcOgEgJg.js';
+import { setPath, getPath } from '../@glimmer/global-context/index.js';
+import { i as isDict } from './collections-DPkjqeA3.js';
+
+const isEmpty = value => {
+  return value === null || value === undefined || typeof value.toString !== 'function';
+};
+const normalizeTextValue = value => {
+  if (isEmpty(value)) {
+    return '';
+  }
+  return String(value);
+};
+const concat = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
+});
+
+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');
+});
+
+export { concat as c, get as g };

package/dist/dev/packages/shared-chunks/hash-BcOgEgJg.js

@@ -0,0 +1,57 @@
+import { c as createComputeRef, b as isInvokableRef, u as updateRef, v as valueForRef } from './reference-BqOLhKFy.js';
+import { f as reifyPositional, g as buildUntouchableThis, h as check, e as reifyNamed } from './arguments-BVmnQtAM.js';
+import { j as setInternalHelperManager } from './api-DuLOZMO_.js';
+
+function internalHelper(helper) {
+  return setInternalHelperManager(helper, {});
+}
+
+const array = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => reifyPositional(positional), null, 'array');
+});
+
+const context = buildUntouchableThis('`fn` helper');
+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}`);
+  }
+}
+
+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;
+});
+
+export { array as a, fn as f, hash as h, internalHelper as i };

package/dist/dev/packages/shared-chunks/{index-DaFzpTIE.js → index-BYUSIu_W.js}

@@ -1,6 +1,6 @@
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, e as enumerate, r as reverse } from './array-utils-CZQxrdD3.js';
-import { r as VM_PRIMITIVE_OP, aE as encodeHandle, au as VM_CONCAT_OP, al as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, ap as VM_GET_PROPERTY_OP, as as VM_HAS_BLOCK_OP, ar as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, at as VM_HAS_BLOCK_PARAMS_OP, av as VM_IF_INLINE_OP, aw as VM_NOT_OP, ax as VM_GET_DYNAMIC_VAR_OP, ay as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, ak as VM_HELPER_OP, v as VM_DUP_OP, aj as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, $ as VM_CAPTURE_ARGS_OP, ai as VM_CURRY_OP, aF as isSmallInt, aG as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, aq as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, am as VM_SET_VARIABLE_OP, o as VM_CONSTANT_OP, D as VM_PUSH_BLOCK_SCOPE_OP, C as VM_PUSH_SYMBOL_TABLE_OP, _ as VM_PUSH_EMPTY_ARGS_OP, Z as VM_PUSH_ARGS_OP, A as VM_ENTER_OP, I as VM_JUMP_EQ_OP, B as VM_EXIT_OP, H as VM_JUMP_UNLESS_OP, X as VM_PUSH_COMPONENT_DEFINITION_OP, x as VM_LOAD_OP, a3 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a1 as VM_CREATE_COMPONENT_OP, a2 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a8 as VM_GET_COMPONENT_SELF_OP, ao as VM_ROOT_SCOPE_OP, an as VM_SET_BLOCK_OP, ag as VM_DID_RENDER_LAYOUT_OP, ah as VM_COMMIT_COMPONENT_TRANSACTION_OP, a0 as VM_PREPARE_ARGS_OP, ac as VM_VIRTUAL_ROOT_SCOPE_OP, ad as VM_SET_NAMED_VARIABLES_OP, ae as VM_SET_BLOCKS_OP, af as VM_INVOKE_COMPONENT_LAYOUT_OP, a4 as VM_PUT_COMPONENT_OPERATIONS_OP, N as VM_OPEN_DYNAMIC_ELEMENT_OP, a7 as VM_DID_CREATE_ELEMENT_OP, Q as VM_FLUSH_ELEMENT_OP, R as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Y as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, aa as VM_GET_COMPONENT_LAYOUT_OP, ab as VM_POPULATE_LAYOUT_OP, a9 as VM_GET_COMPONENT_TAG_NAME_OP, L as VM_COMMENT_OP, S as VM_MODIFIER_OP, T as VM_DYNAMIC_MODIFIER_OP, U as VM_STATIC_ATTR_OP, a6 as VM_STATIC_COMPONENT_ATTR_OP, W as VM_DYNAMIC_ATTR_OP, a5 as VM_COMPONENT_ATTR_OP, M as VM_OPEN_ELEMENT_OP, aA as VM_DEBUGGER_OP, K as VM_TEXT_OP, b as VM_ASSERT_SAME_OP, az as VM_DYNAMIC_CONTENT_TYPE_OP, O as VM_PUSH_REMOTE_ELEMENT_OP, P as VM_POP_REMOTE_ELEMENT_OP, J as VM_TO_BOOLEAN_OP, aB as VM_ENTER_LIST_OP, aD as VM_ITERATE_OP, aC as VM_EXIT_LIST_OP } from './syscall-ops-CN7STuUn.js';
+import { r as VM_PRIMITIVE_OP, aD as encodeHandle, at as VM_CONCAT_OP, ak as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, ao as VM_GET_PROPERTY_OP, ar as VM_HAS_BLOCK_OP, aq as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, as as VM_HAS_BLOCK_PARAMS_OP, au as VM_IF_INLINE_OP, av as VM_NOT_OP, aw as VM_GET_DYNAMIC_VAR_OP, ax as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, aj as VM_HELPER_OP, v as VM_DUP_OP, ai as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, _ as VM_CAPTURE_ARGS_OP, ah as VM_CURRY_OP, aE as isSmallInt, aF as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, ap as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, al as VM_SET_VARIABLE_OP, o as VM_CONSTANT_OP, D as VM_PUSH_BLOCK_SCOPE_OP, C as VM_PUSH_SYMBOL_TABLE_OP, Z as VM_PUSH_EMPTY_ARGS_OP, Y as VM_PUSH_ARGS_OP, A as VM_ENTER_OP, H as VM_JUMP_EQ_OP, B as VM_EXIT_OP, G as VM_JUMP_UNLESS_OP, W as VM_PUSH_COMPONENT_DEFINITION_OP, x as VM_LOAD_OP, a2 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a0 as VM_CREATE_COMPONENT_OP, a1 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a7 as VM_GET_COMPONENT_SELF_OP, an as VM_ROOT_SCOPE_OP, am as VM_SET_BLOCK_OP, af as VM_DID_RENDER_LAYOUT_OP, ag as VM_COMMIT_COMPONENT_TRANSACTION_OP, $ as VM_PREPARE_ARGS_OP, ab as VM_VIRTUAL_ROOT_SCOPE_OP, ac as VM_SET_NAMED_VARIABLES_OP, ad as VM_SET_BLOCKS_OP, ae as VM_INVOKE_COMPONENT_LAYOUT_OP, a3 as VM_PUT_COMPONENT_OPERATIONS_OP, M as VM_OPEN_DYNAMIC_ELEMENT_OP, a6 as VM_DID_CREATE_ELEMENT_OP, P as VM_FLUSH_ELEMENT_OP, Q as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, X as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, a9 as VM_GET_COMPONENT_LAYOUT_OP, aa as VM_POPULATE_LAYOUT_OP, a8 as VM_GET_COMPONENT_TAG_NAME_OP, K as VM_COMMENT_OP, R as VM_MODIFIER_OP, S as VM_DYNAMIC_MODIFIER_OP, T as VM_STATIC_ATTR_OP, a5 as VM_STATIC_COMPONENT_ATTR_OP, U as VM_DYNAMIC_ATTR_OP, a4 as VM_COMPONENT_ATTR_OP, L as VM_OPEN_ELEMENT_OP, az as VM_DEBUGGER_OP, J as VM_TEXT_OP, b as VM_ASSERT_SAME_OP, ay as VM_DYNAMIC_CONTENT_TYPE_OP, N as VM_PUSH_REMOTE_ELEMENT_OP, O as VM_POP_REMOTE_ELEMENT_OP, I as VM_TO_BOOLEAN_OP, aA as VM_ENTER_LIST_OP, aC as VM_ITERATE_OP, aB as VM_EXIT_LIST_OP } from './syscall-ops-CkPT1Kfx.js';
 import { b as VM_RETURN_OP, i as isMachineOp, f as VM_PUSH_FRAME_OP, e as VM_POP_FRAME_OP, d as VM_INVOKE_VIRTUAL_OP, c as VM_JUMP_OP, a as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
 import { e as expect, u as unwrap, S as StackImpl, d as dict } from './collections-DPkjqeA3.js';
 import { i as isPresentArray } from './present-B1rrjAVM.js';
@@ -8,7 +8,7 @@ import { a as assert } from './assert-Zqc4wiAV.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
 import { a as TYPE_SIZE, A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-BZxHQ0yn.js';
 import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
-import { o as opcodes } from './opcodes-CplRyHl_.js';
+import { o as opcodes } from './opcodes-DDajoGhq.js';
 import { a as $v0, f as $fp, $ as $s0, g as $sp, h as $s1 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
 import { h as hasCapability } from './capabilities-CajW4QjE.js';
@@ -1054,7 +1054,7 @@ function SwitchCases(op, bootstrap, matcher) {
  * # Updating Execution
  *
  * Updating execution for this `replayable` occurs if the `body` added an
- * assertion, via one of the `JumpIf`, `JumpUnless` or `AssertSame` opcodes.
+ * assertion, via one of the `JumpUnless`, `JumpEq` or `AssertSame` opcodes.
  *
  * If, during updating executon, the assertion fails, the initial VM is
  * restored, and the stored arguments are pushed onto the stack. The DOM

package/dist/dev/packages/shared-chunks/{index-Czn34wUZ.js → index-COgCjiy-.js}

@@ -5,7 +5,7 @@ import { associateDestroyableChild, destroy, registerDestructor, isDestroyed, is
 import { artifacts } from '../@glimmer/program/index.js';
 import { R as RuntimeOpImpl } from './program-DlgjqLa6.js';
 import { c as clientBuilder } from './api-Dz70AUL_.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1 } from './render-CtH73XOv.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1 } from './render-B5RULomD.js';
 import { c as consumeTag, z as isTracking, e as debug, a as valueForTag, k as CURRENT_TAG, v as validateTag } from './cache-DGDPVCpC.js';
 import { h as hasDOM } from './index-BGP1rw3B.js';
 import { g as get$1, b as _getProp } from './property_get-DXwpgTe7.js';
@@ -28,15 +28,15 @@ import { isFactory } from '../@ember/-internals/owner/index.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { g as getComponentTemplate } from './template-R_5UMHhb.js';
 import { a as getInternalHelperManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DuLOZMO_.js';
-import { h as hash, f as fn, a as array } from './hash-6NDs_5_f.js';
-import { g as get, c as concat } from './get-6I3sjd-I.js';
-import { o as on } from './on-DlF0Wy7P.js';
+import { h as hash, f as fn, a as array } from './hash-BcOgEgJg.js';
+import { g as get, c as concat } from './get-BVBR6Afa.js';
+import { o as on } from './on-DXmOUOBH.js';
 import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-Cu639ICT.js';
 import { i as isCurlyManager } from './curly-brand-B_F79Dep.js';
 import { i as isClassicHelper } from './helper-brand-C9_8vvOf.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-DQOhouG1.js';
-import { E as EvaluationContextImpl } from './program-context-Dq8xN2HI.js';
+import { a as uniqueId } from './unique-id-Csxuh1I7.js';
+import { E as EvaluationContextImpl } from './program-context-BBB1Ga5h.js';
 
 /**
 @module ember
@@ -150,7 +150,7 @@ const trackArray = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 /**
@@ -160,46 +160,91 @@ const trackArray = internalHelper(({
   The default behavior of `{{#each}}` is to yield its inner block once for every
   item in an array passing the item as the first block parameter.
 
-  Assuming the `@developers` argument contains this array:
+  ```gjs {data-filename="app/components/developer-list.gjs"}
+  import Component from '@glimmer/component';
 
-  ```javascript
-  [{ name: 'Yehuda' },{ name: 'Tom' }, { name: 'Paul' }];
-  ```
+  export default class DeveloperList extends Component {
+    developers = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person|}}
-      <li>Hello, {{person.name}}!</li>
-    {{/each}}
-  </ul>
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  The same rules apply to arrays of primitives.
+  The same rules apply to arrays of primitives:
+
+  ```gjs {data-filename="app/components/developer-names.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperNames extends Component {
+    developerNames = ['Yehuda', 'Tom', 'Paul'];
 
-  ```javascript
-  ['Yehuda', 'Tom', 'Paul']
+    <template>
+      <ul>
+        {{#each this.developerNames as |name|}}
+          <li>Hello, {{name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  ```handlebars
-  <ul>
-    {{#each @developerNames as |name|}}
-      <li>Hello, {{name}}!</li>
-    {{/each}}
-  </ul>
+  `{{#each}}` also supports native JavaScript [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)
+  values and other iterables:
+
+  ```gjs {data-filename="app/components/developer-set.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperSet extends Component {
+    developers = new Set([
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ]);
+
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  During iteration, the index of each item in the array is provided as a second block
-  parameter.
+  During iteration, the index of each item in the array is provided as a second
+  block parameter:
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person index|}}
-      <li>Hello, {{person.name}}! You're number {{index}} in line</li>
-    {{/each}}
-  </ul>
+  ```gjs {data-filename="app/components/developer-list-with-index.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperListWithIndex extends Component {
+    developers = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
+
+    <template>
+      <ul>
+        {{#each this.developers as |person index|}}
+          <li>Hello, {{person.name}}! You're number {{index}} in line</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
-    
-  `#each` is a keyword and does not need to be imported. 
+
+  `#each` is a keyword and does not need to be imported.
 
   ### Specifying Keys
 
@@ -215,30 +260,38 @@ const trackArray = internalHelper(({
   needed. However, in some rare cases, the objects' identities may change even
   though they represent the same underlying data.
 
-  For example:
+  For example, mapping over `people` produces a new array of new objects on each
+  render. Use `key` so Ember can match items across those renders:
 
-  ```javascript
-  people.map(person => {
-    return { ...person, type: 'developer' };
-  });
-  ```
+  ```gjs {data-filename="app/components/mapped-developers.gjs"}
+  import Component from '@glimmer/component';
 
-  In this case, each time the `people` array is `map`-ed over, it will produce
-  an new array with completely different objects between renders. In these cases,
-  you can help Ember determine how these objects related to each other with the
-  `key` option:
+  export default class MappedDevelopers extends Component {
+    people = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
 
-  ```handlebars
-  <ul>
-    {{#each @developers key="name" as |person|}}
-      <li>Hello, {{person.name}}!</li>
-    {{/each}}
-  </ul>
+    get developers() {
+      return this.people.map((person) => {
+        return { ...person, type: 'developer' };
+      });
+    }
+
+    <template>
+      <ul>
+        {{#each this.developers key="name" as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
   By doing so, Ember will use the value of the property specified (`person.name`
   in the example) to find a "match" from the previous render. That is, if Ember
-  has previously seen an object from the `@developers` array with a matching
+  has previously seen an object from the `developers` array with a matching
   name, its DOM elements will be re-used.
 
   There are two special values for `key`:
@@ -251,36 +304,47 @@ const trackArray = internalHelper(({
   `{{#each}}` can have a matching `{{else}}`. The contents of this block will render
   if the collection is empty.
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person|}}
-      <li>{{person.name}} is available!</li>
-    {{else}}
-      <li>Sorry, nobody is available for this task.</li>
-    {{/each}}
-  </ul>
+  ```gjs {data-filename="app/components/available-developers.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class AvailableDevelopers extends Component {
+    developers = [];
+
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>{{person.name}} is available!</li>
+        {{else}}
+          <li>Sorry, nobody is available for this task.</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
   @method each
-  @for Ember.Templates.helpers
+  @for Keywords
+  @static
+  @noimport
   @public
  */
 
 /**
-  The `{{#each-in}}` keyword loops over properties on an object.
+  The `{{#each-in}}` keyword loops over properties on an object, or entries in a
+  native JavaScript [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map).
 
   For example, given this component definition:
 
-  ```app/components/developer-details.gjs
+  ```gjs {data-filename="app/components/developer-details.gjs"}
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
 
-  export default class extends Component {
+  export default class DeveloperDetails extends Component {
     @tracked developer = {
-      "name": "Shelly Sails",
-      "age": 42
+      name: 'Shelly Sails',
+      age: 42,
     };
-    
+
     <template>
       <ul>
         {{#each-in this.developer as |key value|}}
@@ -300,11 +364,56 @@ const trackArray = internalHelper(({
     <li>age: 42</li>
   </ul>
   ```
- 
+
+  The same pattern works with a `Map`:
+
+  ```gjs {data-filename="app/components/developer-map.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperMap extends Component {
+    map = new Map([
+      ['name', 'Shelly Sails'],
+      ['age', 42],
+    ]);
+
+    <template>
+      <ul>
+        {{#each-in this.map as |key value|}}
+          <li>{{key}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
+  }
+  ```
+
+  When a `Map` uses object keys, you can pass `key="@identity"` to explicitly
+  track entries across re-renders using the JavaScript identity of each key:
+
+  ```gjs {data-filename="app/components/object-keyed-map.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class ObjectKeyedMap extends Component {
+    map = new Map([
+      [{ name: 'one' }, 'foo'],
+      [{ name: 'two' }, 'bar'],
+    ]);
+
+    <template>
+      <ul>
+        {{#each-in this.map key="@identity" as |key value|}}
+          <li>{{key.name}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
+  }
+  ```
+
   `#each-in` is a keyword and does not need to be imported.
 
   @method each-in
-  @for Ember.Templates.helpers
+  @static
+  @noimport
+  @for Keywords
   @public
   @since 2.1.0
 */
@@ -331,7 +440,7 @@ const eachIn = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 /**
@@ -351,7 +460,7 @@ const eachIn = internalHelper(({
 
   The child `Component` would invoke the function with the new click count:
 
-  ```app/components/my-child.gjs
+  ```gjs {data-filename="app/components/my-child.gjs"}
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
     
@@ -373,7 +482,8 @@ const eachIn = internalHelper(({
 
   @method mut
   @param {Object} [attr] the "two-way" attribute that can be modified.
-  @for Ember.Templates.helpers
+  @static
+  @for Keywords
   @public
 */
 
@@ -398,7 +508,7 @@ const mut = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -510,7 +620,9 @@ const mut = internalHelper(({
 
   @method readonly
   @param {Object} [attr] the read-only attribute.
-  @for Ember.Templates.helpers
+  @for Keywords
+  @noimport
+  @static
   @private
 */
 const readonly = internalHelper(({
@@ -522,7 +634,7 @@ const readonly = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -548,9 +660,13 @@ const readonly = internalHelper(({
 
   The `unbound` helper only accepts a single argument, and it return an
   unbound value.
+ 
+ `unbound` is a template keyword and does not need to be imported.
 
   @method unbound
-  @for Ember.Templates.helpers
+  @static
+  @noimport
+  @for Keywords
   @public
 */