ember-source 7.1.0-alpha.5 → 7.1.0

package/dist/dev/packages/shared-chunks/{index-CTxkmV78.js → index-CL1zjHwo.js}

@@ -9,18 +9,18 @@ import { associateDestroyableChild, isDestroyed, destroy, registerDestructor, is
 import { artifacts } from '../@glimmer/program/index.js';
 import { R as RuntimeOpImpl } from './program-DzAfcWFj.js';
 import { v as valueForRef, U as UNDEFINED_REFERENCE, a as createComputeRef, i as isConstRef, c 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-BoPB2LfI.js';
-import { c as clientBuilder } from './element-builder-kHVx0F__.js';
-import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './untouchable-this-cH6_N2LJ.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-DDdabL30.js';
+import { c as clientBuilder } from './element-builder--iTIJyCB.js';
+import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './untouchable-this-B3DVwpHS.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-CpKaO-BO.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-CvC8E_4-.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-BBzF_bI8.js';
 import { b as CONSTANT_TAG, k as consumeTag, u as isTracking, o as debug, D as DIRTY_TAG$1, m as createTag, z as valueForTag, c as CURRENT_TAG, y as validateTag } from './cache-B7dqAS38.js';
 import { a as RSVP } from './rsvp-CnCSY930.js';
 import { h as hasDOM } from './index-BGP1rw3B.js';
 import EngineInstance from '../@ember/engine/instance.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { c as capabilityFlagsFrom } from './capabilities-CZkuOqqC.js';
-import { t as templateFactory } from './index-DmGmwWPJ.js';
+import { t as templateFactory } from './index-CyZiGiEI.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 import { g as getFactoryFor } from './container-BzzHmCNj.js';
 import { g as get, b as _getProp } from './property_get-CIBS9umw.js';
@@ -33,23 +33,23 @@ import { i as isObject } from './spec-BXl1reqK.js';
 import { t as tagFor } from './meta-BmRXesrk.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-Dsl9_7H_.js';
+import { i as internalHelper } from './internal-helper-Ez7zbEIa.js';
 import { i as isHTMLSafe } from './index-D-xTBV4B.js';
 import { isArray } from '../@ember/array/index.js';
-import { g as getComponentTemplate } from './template-kM-7TTcc.js';
-import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-WvJPuo9z.js';
-import { h as hash, f as fn, a as array } from './hash-D3BENmhU.js';
-import { g as get$1, c as concat } from './get-CpJjYeJO.js';
-import { o as on } from './on-D8QwT-eN.js';
-import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-Yluyu0DY.js';
-import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-DlC4YesW.js';
+import { g as getComponentTemplate } from './template-R_5UMHhb.js';
+import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-BawZUDYD.js';
+import { h as hash, f as fn, a as array } from './hash-BTwOuDGQ.js';
+import { g as get$1, c as concat } from './get-BehtPmsu.js';
+import { o as on } from './on-BQii6ILK.js';
+import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-BqOt8bDl.js';
+import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-BubrhyuN.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-A83bjEE-.js';
+import { a as uniqueId } from './unique-id-CgmHQiwi.js';
 import '../route-recognizer/index.js';
 import './unrecognized-url-error-B3wUTorp.js';
 import '../@ember/routing/lib/routing-service.js';
 import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
-import { E as EvaluationContextImpl } from './program-context-CqcQMsfa.js';
+import { E as EvaluationContextImpl } from './program-context-CadjldRr.js';
 
 function instrumentationPayload$1(def) {
   // "main" used to be the outlet name, keeping it around for compatibility
@@ -246,7 +246,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 +290,8 @@ class RootComponentDefinition {
     {{/each}}
   </ul>
   ```
+    
+  `#each` is a keyword and does not need to be imported. 
 
   ### Specifying Keys
 
@@ -357,11 +359,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 +372,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 +392,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 +863,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 +933,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 +949,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
@@ -1265,15 +1232,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 +1247,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 +1404,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

package/dist/dev/packages/shared-chunks/{index-DmGmwWPJ.js → index-CyZiGiEI.js}

@@ -1,16 +1,15 @@
 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 { s as VM_PRIMITIVE_OP, aG as VM_RETURN_OP, aM as encodeHandle, aN as isMachineOp, aw as VM_CONCAT_OP, an as VM_GET_VARIABLE_OP, r as VM_CONSTANT_REFERENCE_OP, ar as VM_GET_PROPERTY_OP, au as VM_HAS_BLOCK_OP, at as VM_SPREAD_BLOCK_OP, F as VM_COMPILE_BLOCK_OP, av as VM_HAS_BLOCK_PARAMS_OP, ax as VM_IF_INLINE_OP, ay as VM_NOT_OP, az as VM_GET_DYNAMIC_VAR_OP, aK as VM_PUSH_FRAME_OP, aA as VM_LOG_OP, aJ as VM_POP_FRAME_OP, z as VM_FETCH_OP, v as VM_PRIMITIVE_REFERENCE_OP, am as VM_HELPER_OP, w as VM_DUP_OP, al as VM_DYNAMIC_HELPER_OP, x as VM_POP_OP, a0 as VM_CAPTURE_ARGS_OP, ak as VM_CURRY_OP, aO as isSmallInt, aP as encodeImmediate, n as VM_PUSH_DYNAMIC_SCOPE_OP, A as VM_BIND_DYNAMIC_SCOPE_OP, o as VM_POP_DYNAMIC_SCOPE_OP, as as VM_GET_BLOCK_OP, G as VM_INVOKE_YIELD_OP, m as VM_POP_SCOPE_OP, l as VM_CHILD_SCOPE_OP, ao as VM_SET_VARIABLE_OP, aI as VM_INVOKE_VIRTUAL_OP, p as VM_CONSTANT_OP, E as VM_PUSH_BLOCK_SCOPE_OP, D as VM_PUSH_SYMBOL_TABLE_OP, $ as VM_PUSH_EMPTY_ARGS_OP, _ as VM_PUSH_ARGS_OP, B as VM_ENTER_OP, J as VM_JUMP_EQ_OP, aH as VM_JUMP_OP, C as VM_EXIT_OP, aF as VM_RETURN_TO_OP, I as VM_JUMP_UNLESS_OP, Y as VM_PUSH_COMPONENT_DEFINITION_OP, y as VM_LOAD_OP, a4 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a2 as VM_CREATE_COMPONENT_OP, a3 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a9 as VM_GET_COMPONENT_SELF_OP, aq as VM_ROOT_SCOPE_OP, ap as VM_SET_BLOCK_OP, ah as VM_DID_RENDER_LAYOUT_OP, ai as VM_COMMIT_COMPONENT_TRANSACTION_OP, a1 as VM_PREPARE_ARGS_OP, ad as VM_VIRTUAL_ROOT_SCOPE_OP, ae as VM_SET_NAMED_VARIABLES_OP, af as VM_SET_BLOCKS_OP, ag as VM_INVOKE_COMPONENT_LAYOUT_OP, a5 as VM_PUT_COMPONENT_OPERATIONS_OP, O as VM_OPEN_DYNAMIC_ELEMENT_OP, a8 as VM_DID_CREATE_ELEMENT_OP, R as VM_FLUSH_ELEMENT_OP, S as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Z as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, ab as VM_GET_COMPONENT_LAYOUT_OP, ac as VM_POPULATE_LAYOUT_OP, aa as VM_GET_COMPONENT_TAG_NAME_OP, M as VM_COMMENT_OP, T as VM_MODIFIER_OP, U as VM_DYNAMIC_MODIFIER_OP, W as VM_STATIC_ATTR_OP, a7 as VM_STATIC_COMPONENT_ATTR_OP, X as VM_DYNAMIC_ATTR_OP, a6 as VM_COMPONENT_ATTR_OP, N as VM_OPEN_ELEMENT_OP, aj as VM_DEBUGGER_OP, L as VM_TEXT_OP, j as VM_INVOKE_STATIC_OP, aB as VM_DYNAMIC_CONTENT_TYPE_OP, P as VM_PUSH_REMOTE_ELEMENT_OP, Q as VM_POP_REMOTE_ELEMENT_OP, K as VM_TO_BOOLEAN_OP, aC as VM_ENTER_LIST_OP, aE as VM_ITERATE_OP, aD as VM_EXIT_LIST_OP } from './opcode-metadata-9iSW5JGP.js';
-import './curried-BVwSNqpf.js';
-import './reference-BoPB2LfI.js';
+import { r as VM_PRIMITIVE_OP, aF as encodeHandle, av as VM_CONCAT_OP, am as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, aq as VM_GET_PROPERTY_OP, at as VM_HAS_BLOCK_OP, as as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, au as VM_HAS_BLOCK_PARAMS_OP, aw as VM_IF_INLINE_OP, ax as VM_NOT_OP, ay as VM_GET_DYNAMIC_VAR_OP, az as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, al as VM_HELPER_OP, v as VM_DUP_OP, ak as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, $ as VM_CAPTURE_ARGS_OP, aj as VM_CURRY_OP, aG as isSmallInt, aH as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, ar as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, an 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, ap as VM_ROOT_SCOPE_OP, ao 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, ai as VM_DEBUGGER_OP, K as VM_TEXT_OP, aA 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-BPFtDquC.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-CUCJBR2C.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 { d as debugToString } from './debug-to-string-CFb7h0lY.js';
+import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
 import { o as opcodes } from './opcodes-CplRyHl_.js';
-import { a as $v0, f as $fp, $ as $s0, e as $sp, d as $s1 } from './registers-DoamZwaG.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';
 

package/dist/dev/packages/shared-chunks/{internal-CbQSKXEm.js → internal-CAL-jHZt.js}

@@ -1,8 +1,8 @@
 import { setOwner } from '../@ember/-internals/owner/index.js';
 import { g as guidFor } from './guid-Cbq2sNV_.js';
 import '../@ember/debug/index.js';
-import { s as setComponentTemplate } from './template-kM-7TTcc.js';
-import { s as setInternalComponentManager } from './api-WvJPuo9z.js';
+import { s as setComponentTemplate } from './template-R_5UMHhb.js';
+import { s as setInternalComponentManager } from './api-BawZUDYD.js';
 import { v as valueForRef, i as isConstRef, c as createConstRef } from './reference-BoPB2LfI.js';
 import { x as untrack } from './cache-B7dqAS38.js';
 import { assert } from '../@ember/debug/lib/assert.js';

package/dist/dev/packages/shared-chunks/{internal-helper-Dsl9_7H_.js → internal-helper-Ez7zbEIa.js}

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

package/dist/dev/packages/shared-chunks/{invoke-B6j6DdDz.js → invoke-B8M5fQQS.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-WvJPuo9z.js';
+import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-BawZUDYD.js';
 import { getOwner } from '../@glimmer/owner/index.js';
 import { l as createCache, r as getValue } from './cache-B7dqAS38.js';
-import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './untouchable-this-cH6_N2LJ.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './untouchable-this-B3DVwpHS.js';
 
 let ARGS_CACHES = new WeakMap() ;
 function getArgs(proxy) {

package/dist/dev/packages/shared-chunks/{on-D8QwT-eN.js → on-BQii6ILK.js}

@@ -1,6 +1,6 @@
-import { g as buildUntouchableThis, h as check, e as reifyNamed } from './untouchable-this-cH6_N2LJ.js';
+import { g as buildUntouchableThis, h as check, e as reifyNamed } from './untouchable-this-B3DVwpHS.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';
-import { k as setInternalModifierManager } from './api-WvJPuo9z.js';
+import { k as setInternalModifierManager } from './api-BawZUDYD.js';
 import { v as valueForRef } from './reference-BoPB2LfI.js';
 import { n as createUpdatableTag } from './cache-B7dqAS38.js';
 
@@ -139,11 +139,7 @@ function addEventListener(element, eventName, callback, options) {
   For example, if you'd like to run a function on your component when a `<button>`
   in the components template is clicked you might do something like:
 
-  ```app/components/like-post.hbs
-  <button {{on 'click' this.saveLike}}>Like this post!</button>
-  ```
-
-  ```app/components/like-post.js
+  ```app/components/like-post.gjs
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
 
@@ -152,6 +148,10 @@ function addEventListener(element, eventName, callback, options) {
       // someone likes your post!
       // better send a request off to your server...
     }
+    
+    <template>
+      <button {{on 'click' this.saveLike}}>Like this post!</button>
+    </template>
   }
   ```
 
@@ -199,7 +199,7 @@ function addEventListener(element, eventName, callback, options) {
   properly bound to the `items-list`, but let's explore what happens if we
   left out the arrow function:
 
-  ```app/components/like-post.js
+  ```app/components/like-post.gjs
   import Component from '@glimmer/component';
 
   export default class LikePostComponent extends Component {

package/dist/dev/packages/shared-chunks/{or-DBU9Ge4r.js → or-BTH3yuFG.js}

@@ -1,6 +1,6 @@
 import { toBool } from '../@glimmer/global-context/index.js';
 import { a as createComputeRef, v as valueForRef } from './reference-BoPB2LfI.js';
-import { i as internalHelper } from './hash-D3BENmhU.js';
+import { i as internalHelper } from './hash-BTwOuDGQ.js';
 
 const and = internalHelper(({
   positional

package/dist/dev/packages/shared-chunks/{program-context-CqcQMsfa.js → program-context-CadjldRr.js}

@@ -1,7 +1,8 @@
-import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, j as VM_INVOKE_STATIC_OP } from './opcode-metadata-9iSW5JGP.js';
-import { $ as $s0 } from './registers-DoamZwaG.js';
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP } from './syscall-ops-BPFtDquC.js';
+import { V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
+import { $ as $s0 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-DmGmwWPJ.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-CyZiGiEI.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {

package/dist/{prod/packages/shared-chunks/registers-DoamZwaG.js → dev/packages/shared-chunks/registers-C_W2qYHJ.js}

@@ -32,4 +32,4 @@ function isLowLevelRegister(register) {
   return register <= $sp;
 }
 
-export { $s0 as $, $v0 as a, $t1 as b, $t0 as c, $s1 as d, $sp as e, $fp as f, $ra as g, $pc as h, isLowLevelRegister as i };
+export { $s0 as $, $v0 as a, $t1 as b, $t0 as c, $pc as d, $ra as e, $fp as f, $sp as g, $s1 as h, isLowLevelRegister as i };

package/dist/dev/packages/shared-chunks/{rehydrate-builder-DdzXTaJk.js → rehydrate-builder-DCyIgnCR.js}

@@ -1,7 +1,7 @@
-import { N as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, e as NS_SVG } from './element-builder-kHVx0F__.js';
+import { N as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, e as NS_SVG } from './element-builder--iTIJyCB.js';
 import { c as castToSimple, a as castToBrowser } from './simple-cast-DCvJLSin.js';
 import { e as expect } from './collections-DPkjqeA3.js';
-import { a as assert } from './assert-CUCJBR2C.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
 import { C as ConcreteBounds, a as CursorImpl } from './normalize-CKySQVU7.js';
 
 const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';

package/dist/dev/packages/shared-chunks/{render-DDdabL30.js → render-CpKaO-BO.js}

@@ -2,20 +2,21 @@ import { u as unwrap, e as expect, a as isIndexable, S as StackImpl } from './co
 import { a as unwrapHandle } from './template-BRrQR6KS.js';
 import { v as valueForRef, f as childRefFor, U as UNDEFINED_REFERENCE, a as createComputeRef, T as TRUE_REFERENCE, F as FALSE_REFERENCE, i as isConstRef, u as updateRef, c as createConstRef } from './reference-BoPB2LfI.js';
 import { w as track, U as UPDATE_TAG, o as debug, v as resetTracking, g as beginTrackFrame, p as endTrackFrame } from './cache-B7dqAS38.js';
-import { a as assert } from './assert-CUCJBR2C.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
 import { P as ProgramImpl } from './program-DzAfcWFj.js';
-import { A as APPEND_OPCODES, D as DebugRenderTreeImpl, i as isArgumentError, j as isCurriedType, d as curry, h as check, k as resolveCurriedValue, f as reifyPositional, l as AssertFilter, V as VMArgumentsImpl, m as externs, J as JumpIfNotModifiedOpcode, B as BeginTrackFrameOpcode, n as EndTrackFrameOpcode } from './untouchable-this-cH6_N2LJ.js';
-import { B as BLACKLIST_TABLE, f as DOMOperations, D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder-kHVx0F__.js';
+import { A as APPEND_OPCODES, D as DebugRenderTreeImpl, i as isArgumentError, j as isCurriedType, d as curry, h as check, k as resolveCurriedValue, f as reifyPositional, l as AssertFilter, V as VMArgumentsImpl, m as externs, J as JumpIfNotModifiedOpcode, B as BeginTrackFrameOpcode, n as EndTrackFrameOpcode } from './untouchable-this-B3DVwpHS.js';
+import { B as BLACKLIST_TABLE, f as DOMOperations, D as DOMTreeConstruction, N as NewTreeBuilder } from './element-builder--iTIJyCB.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { associateDestroyableChild, _hasDestroyableChildren, destroy, destroyChildren, registerDestructor } from '../@glimmer/destroyable/index.js';
 import { toBool, debugAssert, assertGlobalContextWasSet } from '../@glimmer/global-context/index.js';
 import { createIteratorRef, createIteratorItemRef } from '../@glimmer/reference/index.js';
 import { r as reverse } from './array-utils-CZQxrdD3.js';
-import { a as $v0, h as $pc, g as $ra, f as $fp, e as $sp, i as isLowLevelRegister } from './registers-DoamZwaG.js';
-import { aj as VM_DEBUGGER_OP, q as decodeHandle, ak as VM_CURRY_OP, al as VM_DYNAMIC_HELPER_OP, am as VM_HELPER_OP, an as VM_GET_VARIABLE_OP, ao as VM_SET_VARIABLE_OP, ap as VM_SET_BLOCK_OP, aq as VM_ROOT_SCOPE_OP, ar as VM_GET_PROPERTY_OP, as as VM_GET_BLOCK_OP, at as VM_SPREAD_BLOCK_OP, au as VM_HAS_BLOCK_OP, av as VM_HAS_BLOCK_PARAMS_OP, aw as VM_CONCAT_OP, ax as VM_IF_INLINE_OP, ay as VM_NOT_OP, az as VM_GET_DYNAMIC_VAR_OP, aA as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, aB as VM_DYNAMIC_CONTENT_TYPE_OP, c as VM_APPEND_HTML_OP, g as VM_APPEND_SAFE_HTML_OP, d as VM_APPEND_TEXT_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, aC as VM_ENTER_LIST_OP, aD as VM_EXIT_LIST_OP, aE as VM_ITERATE_OP, aF as VM_RETURN_TO_OP, aG as VM_RETURN_OP, aH as VM_JUMP_OP, aI as VM_INVOKE_VIRTUAL_OP, j as VM_INVOKE_STATIC_OP, aJ as VM_POP_FRAME_OP, aK as VM_PUSH_FRAME_OP } from './opcode-metadata-9iSW5JGP.js';
-import { b as CURRIED_COMPONENT, a as CURRIED_HELPER } from './curried-BVwSNqpf.js';
-import { d as debugToString } from './debug-to-string-CFb7h0lY.js';
-import { a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager } from './api-WvJPuo9z.js';
+import { a as $v0, d as $pc, e as $ra, f as $fp, g as $sp, i as isLowLevelRegister } from './registers-C_W2qYHJ.js';
+import { a as VM_RETURN_TO_OP, b as VM_RETURN_OP, c as VM_JUMP_OP, d as VM_INVOKE_VIRTUAL_OP, V as VM_INVOKE_STATIC_OP, e as VM_POP_FRAME_OP, f as VM_PUSH_FRAME_OP } from './vm-ops-ImHv0Wtg.js';
+import { a as CURRIED_COMPONENT, b as CURRIED_HELPER } from './curried-BZnYakIg.js';
+import { ai as VM_DEBUGGER_OP, p as decodeHandle, aj as VM_CURRY_OP, ak as VM_DYNAMIC_HELPER_OP, al as VM_HELPER_OP, am as VM_GET_VARIABLE_OP, an as VM_SET_VARIABLE_OP, ao as VM_SET_BLOCK_OP, ap as VM_ROOT_SCOPE_OP, aq as VM_GET_PROPERTY_OP, ar as VM_GET_BLOCK_OP, as as VM_SPREAD_BLOCK_OP, at as VM_HAS_BLOCK_OP, au as VM_HAS_BLOCK_PARAMS_OP, av as VM_CONCAT_OP, aw as VM_IF_INLINE_OP, ax as VM_NOT_OP, ay as VM_GET_DYNAMIC_VAR_OP, az as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, aA as VM_DYNAMIC_CONTENT_TYPE_OP, c as VM_APPEND_HTML_OP, g as VM_APPEND_SAFE_HTML_OP, d as VM_APPEND_TEXT_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, aB as VM_ENTER_LIST_OP, aC as VM_EXIT_LIST_OP, aD as VM_ITERATE_OP } from './syscall-ops-BPFtDquC.js';
+import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
+import { a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager } from './api-BawZUDYD.js';
 import { ContentType } from '../@glimmer/vm/index.js';
 import { b as isEmpty, d as isString, s as shouldCoerce, i as isSafeString, e as isFragment, f as isNode, m as move, c as clear } from './normalize-CKySQVU7.js';
 

package/dist/dev/packages/shared-chunks/{chunk-3SQBS3Y5-Cj4eryg1.js → runtime-CYyqkz5q-BOdRhmsS.js}

@@ -1,23 +1,4 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-
-// src/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  c: () => decorateClass,
-  f: () => decorateFieldV1,
-  g: () => decorateFieldV2,
-  i: () => initializeDeferredDecorator,
-  m: () => decorateMethodV1,
-  n: () => decorateMethodV2,
-  p: () => decoratePOJO
-});
-var deferred = /* @__PURE__ */new WeakMap();
+const deferred = /* @__PURE__ */new WeakMap();
 function deferDecorator(proto, prop, desc) {
   let map = deferred.get(proto);
   if (!map) {
@@ -27,18 +8,16 @@ function deferDecorator(proto, prop, desc) {
   map.set(prop, desc);
 }
 function findDeferredDecorator(target, prop) {
+  var _a;
   let cursor = target.prototype;
   while (cursor) {
-    let desc = deferred.get(cursor)?.get(prop);
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
     if (desc) {
       return desc;
     }
-    cursor = cursor.prototype;
+    cursor = Object.getPrototypeOf(cursor);
   }
 }
-function decorateFieldV1(target, prop, decorators, initializer) {
-  return decorateFieldV2(target.prototype, prop, decorators, initializer);
-}
 function decorateFieldV2(prototype, prop, decorators, initializer) {
   let desc = {
     configurable: true,
@@ -58,11 +37,6 @@ function decorateFieldV2(prototype, prop, decorators, initializer) {
     deferDecorator(prototype, prop, desc);
   }
 }
-function decorateMethodV1({
-  prototype
-}, prop, decorators) {
-  return decorateMethodV2(prototype, prop, decorators);
-}
 function decorateMethodV2(prototype, prop, decorators) {
   const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
   let desc = {
@@ -88,34 +62,5 @@ function initializeDeferredDecorator(target, prop) {
     });
   }
 }
-function decorateClass(target, decorators) {
-  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
-}
-function decoratePOJO(pojo, decorated) {
-  for (let [type, prop, decorators] of decorated) {
-    if (type === "field") {
-      decoratePojoField(pojo, prop, decorators);
-    } else {
-      decorateMethodV2(pojo, prop, decorators);
-    }
-  }
-  return pojo;
-}
-function decoratePojoField(pojo, prop, decorators) {
-  let desc = {
-    configurable: true,
-    enumerable: true,
-    writable: true,
-    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
-  };
-  for (let decorator of decorators) {
-    desc = decorator(pojo, prop, desc) || desc;
-  }
-  if (desc.initializer) {
-    desc.value = desc.initializer.call(pojo);
-    delete desc.initializer;
-  }
-  Object.defineProperty(pojo, prop, desc);
-}
 
 export { decorateMethodV2 as a, decorateFieldV2 as d, initializeDeferredDecorator as i };

package/dist/dev/packages/shared-chunks/{serialize-builder-B3u9Wr3n.js → serialize-builder-DxgGRvH_.js}

@@ -1,5 +1,5 @@
 import { C as ConcreteBounds } from './normalize-CKySQVU7.js';
-import { N as NewTreeBuilder } from './element-builder-kHVx0F__.js';
+import { N as NewTreeBuilder } from './element-builder--iTIJyCB.js';
 
 /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */