ember-source 7.2.0-alpha.4 → 7.2.0-beta.1

package/dist/dev/packages/shared-chunks/{index-dyv6rcBf.js → index-B3pPx1fL.js}

@@ -1,55 +1,50 @@
 import { privatize } from '../@ember/-internals/container/index.js';
 import { E as ENV } from './env-g-kaAFLN.js';
 import { isFactory, getOwner } from '../@ember/-internals/owner/index.js';
-import { a as guidFor } from './guid-PO2v9BaN.js';
+import { g as guidFor } from './guid-Cbq2sNV_.js';
 import { constructStyleDeprecationMessage, getViewId, getViewElement } from '../@ember/-internals/views/lib/system/utils.js';
 import { deprecate, warn } from '../@ember/debug/index.js';
 import { schedule, _backburner, _getCurrentRunLoop } from '../@ember/runloop/index.js';
 import { associateDestroyableChild, isDestroyed, destroy, registerDestructor, isDestroying } from '../@glimmer/destroyable/index.js';
 import { artifacts } from '../@glimmer/program/index.js';
-import { R as RuntimeOpImpl } from './program-CPXeXWVB.js';
-import { v as valueForRef, U as UNDEFINED_REFERENCE, b as createComputeRef, j as isConstRef, d as createConstRef, l as isUpdatableRef, f as createInvokableRef, h as createReadOnlyRef, i as createUnboundRef, e as createDebugAliasRef, a as childRefFromParts, u as updateRef } from './reference-C-OXd_kp.js';
-import { e as clientBuilder } from './element-builder-Cl1kHFJE.js';
-import { E as EMPTY_ARGS, g as createCapturedArgs, c as EMPTY_POSITIONAL, h as curry } from './untouchable-this-BHdAERUu.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-Dz3OWqXy.js';
-import { d as dict } from './collections-DEt-i-8B.js';
-import { u as unwrapTemplate, b as CurlyComponentManager, i as initialRenderInstrumentDetails, p as processComponentInitializationAssertions, a as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-YoYS2vXw.js';
-import { b as CONSTANT_TAG, k as consumeTag, u as isTracking, o as debug, D as DIRTY_TAG$1, m as createTag, B as valueForTag, c as CURRENT_TAG, z as validateTag } from './cache-CeWOBNQg.js';
-import { a as RSVP } from './rsvp-C6j8G1D1.js';
-import { h as hasDOM } from './index-DX90CU4L.js';
-import EngineInstance from '../@ember/engine/instance.js';
+import { R as RuntimeOpImpl } from './program-DlgjqLa6.js';
+import { v as valueForRef, U as UNDEFINED_REFERENCE, c as createComputeRef, i as isConstRef, a as createConstRef, d as isUpdatableRef, j as createInvokableRef, k as createReadOnlyRef, l as createUnboundRef, h as createDebugAliasRef, g as childRefFromParts, u as updateRef } from './reference-BqOLhKFy.js';
+import { c as clientBuilder } from './api-C0PAtEgQ.js';
+import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './arguments-CDkbOqTS.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-87_sKZ_k.js';
+import { d as dict } from './collections-DPkjqeA3.js';
+import { u as unwrapTemplate, a as CurlyComponentManager, i as initialRenderInstrumentDetails, p as processComponentInitializationAssertions, b as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-Ei5G8jhk.js';
+import { C as CONSTANT_TAG, c as consumeTag, z as isTracking, e as debug, D as DIRTY_TAG$1, r as createTag, a as valueForTag, k as CURRENT_TAG, v as validateTag } from './cache-DGDPVCpC.js';
+import { h as hasDOM } from './index-BGP1rw3B.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
-import { c as capabilityFlagsFrom } from './capabilities-CZkuOqqC.js';
-import { h as templateFactory } from './index-DkwVSPP5.js';
+import { c as capabilityFlagsFrom } from './capabilities-CajW4QjE.js';
+import { t as templateFactory } from './index-DaFzpTIE.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 import { g as getFactoryFor } from './container-BzzHmCNj.js';
-import { g as get, a as _getProp } from './property_get-BjbsrgpU.js';
-import { _ as _setProp, s as set } from './property_set-LJskl202.js';
+import { g as get, b as _getProp } from './property_get-CRP7MFz_.js';
+import { _ as _setProp, s as set } from './property_set-qCUylPEK.js';
 import { g as getDebugName } from './get-debug-name-CSniHBsn.js';
 import setGlobalContext from '../@glimmer/global-context/index.js';
-import { t as tagForObject, o as objectAt, b as tagForProperty } from './chain-tags-DfmU63mS.js';
+import { t as tagForObject, o as objectAt, a as tagForProperty } from './chain-tags-uWSImHzB.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
 import { i as isObject } from './spec-BXl1reqK.js';
-import { t as tagFor } from './meta-Cjo3zQJq.js';
+import { t as tagFor } from './meta-BqC7f9Ia.js';
 import { contentFor } from '../@ember/-internals/runtime/lib/mixins/-proxy.js';
 import { i as isProxy } from './is_proxy-Bzg0d4m4.js';
-import { i as internalHelper } from './internal-helper-IC87S6iZ.js';
+import { i as internalHelper } from './internal-helper-CKrni0b_.js';
 import { i as isHTMLSafe } from './index-D-xTBV4B.js';
-import { isArray } from '../@ember/array/index.js';
+import isArray from '../@ember/array/lib/is-array.js';
 import { g as getComponentTemplate } from './template-R_5UMHhb.js';
-import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DG5kRT-o.js';
-import { h as hash, f as fn, a as array } from './hash-2-93qikL.js';
-import { g as get$1, c as concat } from './get-CO3EIWsm.js';
-import { o as on } from './on-Ch_lyozr.js';
-import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-BxYzSEnC.js';
-import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-Bm6EhgSW.js';
+import { c as hasInternalComponentManager, 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$1, c as concat } from './get-6I3sjd-I.js';
+import { o as on } from './on-DlF0Wy7P.js';
+import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-Cu639ICT.js';
+import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-DIj85_-f.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-Hd96VZlE.js';
-import '../route-recognizer/index.js';
-import './unrecognized-url-error-BQdkjTtZ.js';
-import '../@ember/routing/lib/routing-service.js';
+import { a as uniqueId } from './unique-id-DQOhouG1.js';
 import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
-import { E as EvaluationContextImpl } from './program-context-BaYVr5GA.js';
+import { E as EvaluationContextImpl } from './program-context-Dq8xN2HI.js';
 
 function instrumentationPayload$1(def) {
   // "main" used to be the outlet name, keeping it around for compatibility
@@ -92,14 +87,15 @@ class OutletComponentManager {
       let currentState = valueForRef(currentStateRef);
       let currentOwner = currentState?.render?.owner;
       if (parentOwner && parentOwner !== currentOwner) {
-        (!(currentOwner instanceof EngineInstance) && assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance));
+        (!(currentOwner != null && 'buildChildEngineInstance' in currentOwner) && assert('Expected currentOwner to be an EngineInstance', currentOwner != null && 'buildChildEngineInstance' in currentOwner));
+        let engineInstance = currentOwner;
         let {
           mountPoint
-        } = currentOwner;
+        } = engineInstance;
         if (mountPoint) {
           state.engine = {
             mountPoint,
-            instance: currentOwner
+            instance: engineInstance
           };
         }
       }
@@ -246,7 +242,7 @@ class RootComponentDefinition {
 */
 
 /**
-  The `{{#each}}` helper loops over elements in a collection. It is an extension
+  The `{{#each}}` keyword loops over elements in a collection. It is an extension
   of the base Handlebars `{{#each}}` helper.
 
   The default behavior of `{{#each}}` is to yield its inner block once for every
@@ -290,6 +286,8 @@ class RootComponentDefinition {
     {{/each}}
   </ul>
   ```
+    
+  `#each` is a keyword and does not need to be imported. 
 
   ### Specifying Keys
 
@@ -357,11 +355,11 @@ class RootComponentDefinition {
  */
 
 /**
-  The `{{each-in}}` helper loops over properties on an object.
+  The `{{#each-in}}` keyword loops over properties on an object.
 
   For example, given this component definition:
 
-  ```app/components/developer-details.js
+  ```app/components/developer-details.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
 
@@ -370,21 +368,19 @@ class RootComponentDefinition {
       "name": "Shelly Sails",
       "age": 42
     };
+    
+    <template>
+      <ul>
+        {{#each-in this.developer as |key value|}}
+          <li>{{key}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
   }
   ```
 
   This template would display all properties on the `developer`
-  object in a list:
-
-  ```app/components/developer-details.hbs
-  <ul>
-    {{#each-in this.developer as |key value|}}
-      <li>{{key}}: {{value}}</li>
-    {{/each-in}}
-  </ul>
-  ```
-
-  Outputting their name and age:
+  object in a list, outputting their name and age:
 
   ```html
   <ul>
@@ -392,6 +388,8 @@ class RootComponentDefinition {
     <li>age: 42</li>
   </ul>
   ```
+ 
+  `#each-in` is a keyword and does not need to be imported.
 
   @method each-in
   @for Ember.Templates.helpers
@@ -861,73 +859,42 @@ const trackArray = internalHelper(({
 */
 
 /**
-  The `mut` helper lets you __clearly specify__ that a child `Component` can update the
-  (mutable) value passed to it, which will __change the value of the parent component__.
-
-  To specify that a parameter is mutable, when invoking the child `Component`:
+  The `mut` helper is a shortcut for updating for args.
+    
+  However, defining update functions on your backing class is preferable to using `mut`.
+    
+  More directly: Don't use `mut`. 
 
-  ```handlebars
-  <MyChild @childClickCount={{fn (mut totalClicks)}} />
-  ```
-
-   or
-
-  ```handlebars
-  {{my-child childClickCount=(mut totalClicks)}}
-  ```
-
-  The child `Component` can then modify the parent's value just by modifying its own
-  property:
-
-  ```javascript
-  // my-child.js
-  export default class MyChild extends Component {
-    click() {
-      this.incrementProperty('childClickCount');
-    }
-  }
-  ```
-
-  Note that for curly components (`{{my-component}}`) the bindings are already mutable,
-  making the `mut` unnecessary.
-
-  Additionally, the `mut` helper can be combined with the `fn` helper to
-  mutate a value. For example:
-
-  ```handlebars
-  <MyChild @childClickCount={{this.totalClicks}} @click-count-change={{fn (mut totalClicks))}} />
-  ```
-
-  or
+  The `mut` helper, when used with `fn`, will return a function that
+  sets the value passed to `mut` to its first argument. As an example, we can create a
+  button that increments a value passing the value directly to the `fn`:
 
   ```handlebars
-  {{my-child childClickCount=totalClicks click-count-change=(fn (mut totalClicks))}}
+  <MyChild @childClickCount={{this.totalClicks}} @clickCountChange={{fn (mut this.totalClicks)}} />
   ```
 
-  The child `Component` would invoke the function with the new click value:
+  The child `Component` would invoke the function with the new click count:
 
-  ```javascript
-  // my-child.js
+  ```app/components/my-child.gjs
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+    
   export default class MyChild extends Component {
-    click() {
-      this.get('click-count-change')(this.get('childClickCount') + 1);
+    @action
+    update() {
+      this.args.clickCountChange(this.args.childClickCount + 1);
     }
+    
+    <template>
+      <button {{on "click" this.update}}>
+        Click me!
+      </button>
+    </template>
   }
   ```
 
   The `mut` helper changes the `totalClicks` value to what was provided as the `fn` argument.
 
-  The `mut` helper, when used with `fn`, will return a function that
-  sets the value passed to `mut` to its first argument. As an example, we can create a
-  button that increments a value passing the value directly to the `fn`:
-
-  ```handlebars
-  {{! inc helper is not provided by Ember }}
-  <button onclick={{fn (mut count) (inc count)}}>
-    Increment count
-  </button>
-  ```
-
   @method mut
   @param {Object} [attr] the "two-way" attribute that can be modified.
   @for Ember.Templates.helpers
@@ -962,6 +929,10 @@ const mut = internalHelper(({
 /**
   The `readonly` helper let's you specify that a binding is one-way only,
   instead of two-way.
+  
+  This is a vestigial helper from the days of `@ember/component` and does not apply to
+  components extending from `@glimmer/component`.
+    
   When you pass a `readonly` binding from an outer context (e.g. parent component),
   to to an inner context (e.g. child component), you are saying that changing that
   property in the inner context does not change the value in the outer context.
@@ -974,14 +945,6 @@ const mut = internalHelper(({
   }
   ```
 
-  ```app/templates/components/my-parent.hbs
-  {{log totalClicks}} // -> 3
-  <MyChild @childClickCount={{readonly totalClicks}} />
-  ```
-  ```
-  {{my-child childClickCount=(readonly totalClicks)}}
-  ```
-
   Now, when you update `childClickCount`:
 
   ```app/components/my-child.js
@@ -1156,7 +1119,7 @@ class MountManager {
     // mount is a runtime helper, this shouldn't use dynamic layout
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
-    (!(owner instanceof EngineInstance) && assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance));
+    (!('buildChildEngineInstance' in owner) && assert('Expected owner to be an EngineInstance', 'buildChildEngineInstance' in owner));
     let engine = owner.buildChildEngineInstance(name);
     engine.boot();
     let applicationFactory = engine.factoryFor(`controller:application`);
@@ -1265,15 +1228,14 @@ class MountDefinition {
 
   For example, the following template mounts the `ember-chat` engine:
 
-  ```handlebars
-  {{! application.hbs }}
+  ```app/templates/application.gjs
   {{mount "ember-chat"}}
   ```
 
   Additionally, you can also pass in a `model` argument that will be
   set as the engines model. This can be an existing object:
 
-  ```
+  ```hbs
   <div>
     {{mount 'admin' model=userSettings}}
   </div>
@@ -1281,15 +1243,20 @@ class MountDefinition {
 
   Or an inline `hash`, and you can even pass components:
 
+  ```gjs
+  import SignInButton from '../components/sign-in-button';
+  <template>
+    <div>
+      <h1>Application template!</h1>
+      {{mount 'admin' model=(hash
+          title='Secret Admin'
+          signInButton=SignInButton
+      )}}
+    </div>
+  </template>
   ```
-  <div>
-    <h1>Application template!</h1>
-    {{mount 'admin' model=(hash
-        title='Secret Admin'
-        signInButton=(component 'sign-in-button')
-    )}}
-  </div>
-  ```
+ 
+ `mount` is built-in and does not need to be imported.
 
   @method mount
   @param {String} name Name of the engine to mount.
@@ -1433,23 +1400,30 @@ function makeRouteTemplate(owner, name, template) {
 /**
   The `{{outlet}}` helper lets you specify where a child route will render in
   your template. An important use of the `{{outlet}}` helper is in your
-  application's `application.hbs` file:
-
-  ```app/templates/application.hbs
-  <MyHeader />
-
-  <div class="my-dynamic-content">
-    <!-- this content will change based on the current route, which depends on the current URL -->
-    {{outlet}}
-  </div>
-
-  <MyFooter />
+  application's `application.gjs` file:
+
+  ```app/templates/application.gjs
+  import MyHeader from '../components/my-header';
+  import MyFooter from '../components/my-footer';
+    
+  <template>
+    <MyHeader />
+  
+    <div class="my-dynamic-content">
+      <!-- this content will change based on the current route, which depends on the current URL -->
+      {{outlet}}
+    </div>
+  
+    <MyFooter />
+  </template>
   ```
 
   See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
   information on how your `route` interacts with the `{{outlet}}` helper.
   Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
 
+  `outlet` is built-in and does not need to be imported. 
+ 
   @method outlet
   @for Ember.Templates.helpers
   @public
@@ -2001,7 +1975,12 @@ let renderSettledDeferred = null;
 */
 function renderSettled() {
   if (renderSettledDeferred === null) {
-    renderSettledDeferred = RSVP.defer();
+    let resolve;
+    let promise = new Promise(r => resolve = r);
+    renderSettledDeferred = {
+      promise,
+      resolve
+    };
     // if there is no current runloop, the promise created above will not have
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {

package/dist/dev/packages/shared-chunks/{index-DX90CU4L.js → index-BGP1rw3B.js}

@@ -19,4 +19,4 @@ const environment = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.definePropert
   window
 }, Symbol.toStringTag, { value: 'Module' }));
 
-export { history$1 as a, isFirefox as b, environment as e, hasDOM as h, isChrome as i, location$1 as l, userAgent as u, window as w };
+export { isChrome as a, history$1 as b, environment as e, hasDOM as h, isFirefox as i, location$1 as l, userAgent as u, window as w };

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

@@ -1,17 +1,17 @@
 import { a as assign } from './object-utils-AijlD-JH.js';
-import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, c as enumerate, r as reverse } from './array-utils-BEaSKdEb.js';
-import { ab as VM_PRIMITIVE_OP, aE as encodeHandle, o as VM_CONCAT_OP, O as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, N as VM_GET_PROPERTY_OP, P as VM_HAS_BLOCK_OP, au as VM_SPREAD_BLOCK_OP, m as VM_COMPILE_BLOCK_OP, Q as VM_HAS_BLOCK_PARAMS_OP, S as VM_IF_INLINE_OP, a2 as VM_NOT_OP, M as VM_GET_DYNAMIC_VAR_OP, $ as VM_LOG_OP, G as VM_FETCH_OP, ac as VM_PRIMITIVE_REFERENCE_OP, R as VM_HELPER_OP, x as VM_DUP_OP, A as VM_DYNAMIC_HELPER_OP, a7 as VM_POP_OP, h as VM_CAPTURE_ARGS_OP, t as VM_CURRY_OP, aH as isSmallInt, aF as encodeImmediate, ah as VM_PUSH_DYNAMIC_SCOPE_OP, g as VM_BIND_DYNAMIC_SCOPE_OP, a6 as VM_POP_DYNAMIC_SCOPE_OP, I as VM_GET_BLOCK_OP, U as VM_INVOKE_YIELD_OP, a9 as VM_POP_SCOPE_OP, i as VM_CHILD_SCOPE_OP, at as VM_SET_VARIABLE_OP, p as VM_CONSTANT_OP, ae as VM_PUSH_BLOCK_SCOPE_OP, ak as VM_PUSH_SYMBOL_TABLE_OP, ai as VM_PUSH_EMPTY_ARGS_OP, ad as VM_PUSH_ARGS_OP, D as VM_ENTER_OP, X as VM_JUMP_EQ_OP, F as VM_EXIT_OP, Z as VM_JUMP_UNLESS_OP, af as VM_PUSH_COMPONENT_DEFINITION_OP, _ as VM_LOAD_OP, f as VM_BEGIN_COMPONENT_TRANSACTION_OP, s as VM_CREATE_COMPONENT_OP, am as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, K as VM_GET_COMPONENT_SELF_OP, ap as VM_ROOT_SCOPE_OP, ar as VM_SET_BLOCK_OP, w as VM_DID_RENDER_LAYOUT_OP, l as VM_COMMIT_COMPONENT_TRANSACTION_OP, aa as VM_PREPARE_ARGS_OP, aA as VM_VIRTUAL_ROOT_SCOPE_OP, as as VM_SET_NAMED_VARIABLES_OP, aq as VM_SET_BLOCKS_OP, T as VM_INVOKE_COMPONENT_LAYOUT_OP, al as VM_PUT_COMPONENT_OPERATIONS_OP, a3 as VM_OPEN_DYNAMIC_ELEMENT_OP, v as VM_DID_CREATE_ELEMENT_OP, H as VM_FLUSH_ELEMENT_OP, j as VM_CLOSE_ELEMENT_OP, an as VM_RESOLVE_CURRIED_COMPONENT_OP, ao as VM_RESOLVE_DYNAMIC_COMPONENT_OP, ag as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, J as VM_GET_COMPONENT_LAYOUT_OP, a5 as VM_POPULATE_LAYOUT_OP, L as VM_GET_COMPONENT_TAG_NAME_OP, k as VM_COMMENT_OP, a1 as VM_MODIFIER_OP, B as VM_DYNAMIC_MODIFIER_OP, av as VM_STATIC_ATTR_OP, aw as VM_STATIC_COMPONENT_ATTR_OP, y as VM_DYNAMIC_ATTR_OP, n as VM_COMPONENT_ATTR_OP, a4 as VM_OPEN_ELEMENT_OP, u as VM_DEBUGGER_OP, ay as VM_TEXT_OP, z as VM_DYNAMIC_CONTENT_TYPE_OP, aj as VM_PUSH_REMOTE_ELEMENT_OP, a8 as VM_POP_REMOTE_ELEMENT_OP, az as VM_TO_BOOLEAN_OP, C as VM_ENTER_LIST_OP, W as VM_ITERATE_OP, E as VM_EXIT_LIST_OP } from './syscall-ops-nrBHMOTp.js';
-import { e as VM_RETURN_OP, i as isMachineOp, d as VM_PUSH_FRAME_OP, c as VM_POP_FRAME_OP, a as VM_INVOKE_VIRTUAL_OP, b as VM_JUMP_OP, f as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-5QCUIRx4.js';
-import { a as expect, u as unwrap, S as StackImpl, d as dict } from './collections-DEt-i-8B.js';
-import { i as isPresentArray } from './present-D0EfKzC6.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 { 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';
 import { a as assert } from './assert-Zqc4wiAV.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
-import { b as TYPE_SIZE, A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.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 { h as $v0, $ as $fp, c as $s0, e as $sp, d as $s1 } from './registers-Buvdhhxx.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-CZkuOqqC.js';
+import { h as hasCapability } from './capabilities-CajW4QjE.js';
 
 function isGetLikeTuple(opcode) {
   return Array.isArray(opcode) && opcode.length === 2;
@@ -1612,6 +1612,7 @@ STATEMENTS.add(opcodes.Append, (op, [, value]) => {
         op(VM_DYNAMIC_CONTENT_TYPE_OP);
       }, when => {
         when(ContentType.Component, () => {
+          op(VM_ASSERT_SAME_OP);
           op(VM_RESOLVE_CURRIED_COMPONENT_OP);
           op(VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP);
           InvokeNonStaticComponent(op, {
@@ -1954,4 +1955,4 @@ class TemplateImpl {
   }
 }
 
-export { CallDynamic as C, EMPTY_BLOCKS as E, InvokeBareComponent as I, SwitchCases as S, WrappedBuilder as W, EncoderImpl as a, InvokeStaticBlock as b, InvokeStaticBlockWithStack as c, compilable as d, compileStatements as e, encodeOp as f, templateCompilationContext as g, templateFactory as h, invokePreparedComponent as i, meta as m, templateCacheCounters as t };
+export { CallDynamic as C, EMPTY_BLOCKS as E, InvokeStaticBlock as I, SwitchCases as S, WrappedBuilder as W, templateCacheCounters as a, compileStatements as b, compilable as c, InvokeStaticBlockWithStack as d, templateCompilationContext as e, EncoderImpl as f, encodeOp as g, InvokeBareComponent as h, invokePreparedComponent as i, meta as m, templateFactory as t };

package/dist/dev/packages/shared-chunks/{injected_property-B075jH6c.js → injected_property-CbBLr5jt.js}

@@ -1,7 +1,7 @@
 import { getOwner } from '../@ember/-internals/owner/index.js';
 import '../@ember/debug/index.js';
-import { d as computed, f as defineProperty } from './computed-Daavz6vC.js';
-import { c as isElementDescriptor } from './decorator-DYQwMItS.js';
+import { c as computed, d as defineProperty } from './computed-BPCtuOxQ.js';
+import { i as isElementDescriptor } from './decorator-B5Uh5NFI.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 let DEBUG_INJECTION_FUNCTIONS;

package/dist/dev/packages/shared-chunks/{internal-Bpr6ihB_.js → internal-DTOXyEGM.js}

@@ -1,10 +1,10 @@
 import { setOwner } from '../@ember/-internals/owner/index.js';
-import { a as guidFor } from './guid-PO2v9BaN.js';
+import { g as guidFor } from './guid-Cbq2sNV_.js';
 import '../@ember/debug/index.js';
 import { s as setComponentTemplate } from './template-R_5UMHhb.js';
-import { s as setInternalComponentManager } from './api-DG5kRT-o.js';
-import { v as valueForRef, j as isConstRef, d as createConstRef } from './reference-C-OXd_kp.js';
-import { x as untrack } from './cache-CeWOBNQg.js';
+import { s as setInternalComponentManager } from './api-DuLOZMO_.js';
+import { v as valueForRef, i as isConstRef, a as createConstRef } from './reference-BqOLhKFy.js';
+import { u as untrack } from './cache-DGDPVCpC.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function NOOP() {}

package/dist/dev/packages/shared-chunks/{internal-helper-IC87S6iZ.js → internal-helper-CKrni0b_.js}

@@ -1,4 +1,4 @@
-import { j as setInternalHelperManager } from './api-DG5kRT-o.js';
+import { j as setInternalHelperManager } from './api-DuLOZMO_.js';
 
 function internalHelper(helper) {
   return setInternalHelperManager(helper, {});

package/dist/dev/packages/shared-chunks/{invoke-Ds0KEfP_.js → invoke-d9sqa50M.js}

@@ -1,8 +1,8 @@
 import { isDestroying, isDestroyed, associateDestroyableChild } from '../@glimmer/destroyable/index.js';
-import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-DG5kRT-o.js';
+import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-DuLOZMO_.js';
 import { getOwner } from '../@glimmer/owner/index.js';
-import { l as createCache, r as getValue } from './cache-CeWOBNQg.js';
-import { E as EMPTY_ARGS, b as EMPTY_NAMED, c as EMPTY_POSITIONAL } from './untouchable-this-BHdAERUu.js';
+import { g as createCache, h as getValue } from './cache-DGDPVCpC.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './arguments-CDkbOqTS.js';
 
 let ARGS_CACHES = new WeakMap() ;
 function getArgs(proxy) {

package/dist/dev/packages/shared-chunks/{libraries-P8Ins5CB.js → libraries-DwffpMGE.js}

@@ -1,6 +1,6 @@
 import { warn, debug } from '../@ember/debug/index.js';
 import VERSION from '../ember/version.js';
-import { g as get } from './property_get-BjbsrgpU.js';
+import { g as get } from './property_get-CRP7MFz_.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**

package/dist/dev/packages/shared-chunks/{meta-Cjo3zQJq.js → meta-BqC7f9Ia.js}

@@ -1,4 +1,4 @@
-import { n as createUpdatableTag, y as unwrap, o as debug, D as DIRTY_TAG } from './cache-CeWOBNQg.js';
+import { b as createUpdatableTag, d as unwrap, e as debug, D as DIRTY_TAG } from './cache-DGDPVCpC.js';
 
 function isObjectLike(u) {
   return typeof u === 'object' && u !== null || typeof u === 'function';

package/dist/{prod/packages/shared-chunks/namespace_search-TFdmjK_a.js → dev/packages/shared-chunks/namespace_search-BfvzEQzN.js}

@@ -131,4 +131,4 @@ function tryIsNamespace(lookup, prop) {
   }
 }
 
-export { NAMESPACES as N, NAMESPACES_BY_ID as a, addNamespace as b, findNamespaces as c, processNamespace as d, setUnprocessedMixins as e, findNamespace as f, isSearchDisabled as i, processAllNamespaces as p, removeNamespace as r, setSearchDisabled as s };
+export { NAMESPACES as N, NAMESPACES_BY_ID as a, addNamespace as b, findNamespaces as c, processNamespace as d, setSearchDisabled as e, findNamespace as f, isSearchDisabled as i, processAllNamespaces as p, removeNamespace as r, setUnprocessedMixins as s };

package/dist/dev/packages/shared-chunks/{normalize-CxG_iVLJ.js → normalize-CKySQVU7.js}

@@ -1,4 +1,4 @@
-import { a as expect } from './collections-DEt-i-8B.js';
+import { e as expect } from './collections-DPkjqeA3.js';
 import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
 
 class CursorImpl {
@@ -81,4 +81,4 @@ function isString(value) {
   return typeof value === 'string';
 }
 
-export { ConcreteBounds as C, CursorImpl as a, isFragment as b, clear as c, isNode as d, isSafeString as e, isString as f, isEmpty as i, move as m, normalizeStringValue as n, shouldCoerce as s };
+export { ConcreteBounds as C, CursorImpl as a, isEmpty as b, clear as c, isString as d, isFragment as e, isNode as f, isSafeString as i, move as m, normalizeStringValue as n, shouldCoerce as s };

package/dist/dev/packages/shared-chunks/{or-Bg6rCMF8.js → not-DYh6AY9Z.js}

@@ -1,23 +1,6 @@
 import { toBool } from '../@glimmer/global-context/index.js';
-import { b as createComputeRef, v as valueForRef } from './reference-C-OXd_kp.js';
-import { i as internalHelper } from './hash-2-93qikL.js';
-
-const and = internalHelper(({
-  positional
-}) => {
-  if (positional.length < 2) {
-    throw new Error(`\`and\` expects at least two arguments, but received ${positional.length}.`);
-  }
-  return createComputeRef(() => {
-    let last;
-    for (let i = 0; i < positional.length; i++) {
-      let arg = positional[i];
-      last = arg ? valueForRef(arg) : arg;
-      if (!toBool(last)) return last;
-    }
-    return last;
-  }, null, 'and');
-});
+import { c as createComputeRef, v as valueForRef } from './reference-BqOLhKFy.js';
+import { i as internalHelper } from './hash-6NDs_5_f.js';
 
 /**
  * Performs a strict equality comparison.
@@ -31,6 +14,18 @@ function eq(left, right) {
   return left === right;
 }
 
+/**
+ * Performs a strict inequality comparison.
+ *
+ * left !== right
+ */
+function neq(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`neq\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left !== right;
+}
+
 /**
  * Performs a greater than comparison.
  *
@@ -79,24 +74,22 @@ function lte(left, right) {
   return left <= right;
 }
 
-/**
- * Performs a strict inequality comparison.
- *
- * left !== right
- */
-function neq(left, right) {
-  if (arguments.length !== 2) {
-    throw new Error(`\`neq\` expects exactly two arguments, but received ${arguments.length}.`);
-  }
-  return left !== right;
-}
-
-const not = (...args) => {
-  if (args.length !== 1) {
-    throw new Error(`\`not\` expects exactly one argument, but received ${args.length}.`);
+const and = internalHelper(({
+  positional
+}) => {
+  if (positional.length < 2) {
+    throw new Error(`\`and\` expects at least two arguments, but received ${positional.length}.`);
   }
-  return !toBool(args[0]);
-};
+  return createComputeRef(() => {
+    let last;
+    for (let i = 0; i < positional.length; i++) {
+      let arg = positional[i];
+      last = arg ? valueForRef(arg) : arg;
+      if (!toBool(last)) return last;
+    }
+    return last;
+  }, null, 'and');
+});
 
 const or = internalHelper(({
   positional
@@ -115,4 +108,11 @@ const or = internalHelper(({
   }, null, 'or');
 });
 
+const not = (...args) => {
+  if (args.length !== 1) {
+    throw new Error(`\`not\` expects exactly one argument, but received ${args.length}.`);
+  }
+  return !toBool(args[0]);
+};
+
 export { and as a, gte as b, lte as c, not as d, eq as e, gt as g, lt as l, neq as n, or as o };