ember-source 7.1.0-beta.1 → 7.1.0

package/dist/dev/packages/shared-chunks/{helper-Do7NCZHI.js → helper-BubrhyuN.js}

@@ -29,20 +29,32 @@ const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
   Ember Helpers are functions that can compute values, and are used in templates.
   For example, this code calls a helper named `format-currency`:
 
-  ```app/templates/application.hbs
-  <Cost @cents={{230}} />
+  ```app/templates/application.gjs
+  import Cost from '../components/cost';
+    
+  <template>
+    <Cost @cents={{230}} />
+  </template>
   ```
 
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
+  ```app/components/cost.gjs
+  import formatCurrency from '../helpers/format-currency';
+    
+  <template>
+    <div>{{formatCurrency @cents currency="$"}}</div>
+  </template>
   ```
 
   Additionally a helper can be called as a nested helper.
   In this example, we show the formatted currency value if the `showMoney`
   named argument is truthy.
 
-  ```handlebars
-  {{if @showMoney (format-currency @cents currency="$")}}
+  ```gjs
+  import formatCurrency from '../helpers/format-currency';
+
+  <template>
+    {{if @showMoney (formatCurrency @cents currency="$")}}
+  </template>
   ```
 
   Helpers defined using a class must provide a `compute` function. For example:

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

@@ -38,11 +38,11 @@ import { i as isHTMLSafe } from './index-D-xTBV4B.js';
 import { isArray } from '../@ember/array/index.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-BRRFQJ99.js';
-import { g as get$1, c as concat } from './get-D5b5QlqE.js';
-import { o as on } from './on-BueSMv9L.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-Do7NCZHI.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-CgmHQiwi.js';
 import '../route-recognizer/index.js';
@@ -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/{on-BueSMv9L.js → on-BQii6ILK.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-O0eJQ4K-.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-BRRFQJ99.js';
+import { i as internalHelper } from './hash-BTwOuDGQ.js';
 
 const and = internalHelper(({
   positional

package/dist/dev/packages/shared-chunks/{setup-registry-BC5VMvei.js → setup-registry-BQZJfq-Y.js}

@@ -1,13 +1,13 @@
 import { privatize } from '../@ember/-internals/container/index.js';
 import { getOwner } from '../@ember/-internals/owner/index.js';
 import '../@ember/debug/index.js';
-import { I as Input, T as Textarea } from './textarea-WSlUEr0y.js';
+import { I as Input, T as Textarea } from './textarea-lD4apgrP.js';
 import { LinkTo } from '../@ember/routing/index.js';
 import './render-CpKaO-BO.js';
 import { c as clientBuilder } from './element-builder--iTIJyCB.js';
 import { r as rehydrationBuilder } from './rehydrate-builder-DCyIgnCR.js';
 import { s as serializeBuilder } from './serialize-builder-DxgGRvH_.js';
-import { o as outletHelper, O as OutletView, R as Renderer } from './index-CwnQYqK5.js';
+import { o as outletHelper, O as OutletView, R as Renderer } from './index-CL1zjHwo.js';
 import { t as templateFactory } from './index-CyZiGiEI.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 

package/dist/dev/packages/shared-chunks/{textarea-WSlUEr0y.js → textarea-lD4apgrP.js}

@@ -232,8 +232,12 @@ if (hasDOM) {
 /**
   The `Input` component lets you create an HTML `<input>` element.
 
-  ```handlebars
-  <Input @value="987" />
+  ```gjs
+  import { Input } from '@ember/component';
+    
+  <template>
+    <Input @value="987" />
+  </template>
   ```
 
   creates an `<input>` element with `type="text"` and value set to 987.

package/dist/prod/packages/@ember/-internals/glimmer/index.js

@@ -1,16 +1,16 @@
 export { t as template, a as templateCacheCounters } from '../../../shared-chunks/index-Bj71BDDA.js';
-export { R as RootTemplate, s as setupApplicationRegistry, a as setupEngineRegistry } from '../../../shared-chunks/setup-registry-C2KfZJWI.js';
-export { I as Input, T as Textarea } from '../../../shared-chunks/textarea-CHqL0Rdh.js';
+export { R as RootTemplate, s as setupApplicationRegistry, a as setupEngineRegistry } from '../../../shared-chunks/setup-registry-B3DhqtxX.js';
+export { I as Input, T as Textarea } from '../../../shared-chunks/textarea-Byj32raR.js';
 export { LinkTo } from '../../routing/index.js';
 export { default as Component, setComponentManager } from '../../component/index.js';
-export { H as Helper, h as helper } from '../../../shared-chunks/helper-DLjV2ZZW.js';
+export { H as Helper, h as helper } from '../../../shared-chunks/helper-CN6UzshW.js';
 export { S as SafeString, T as TrustedHTML, h as htmlSafe, i as isHTMLSafe, a as isTrustedHTML, t as trustHTML } from '../../../shared-chunks/index-D-xTBV4B.js';
-export { O as OutletView, R as Renderer, _ as _resetRenderers, a as renderComponent, r as renderSettled } from '../../../shared-chunks/index-qDFz6Mfe.js';
+export { O as OutletView, R as Renderer, _ as _resetRenderers, a as renderComponent, r as renderSettled } from '../../../shared-chunks/index-ClxHbCe9.js';
 export { D as DOMChanges } from '../../../shared-chunks/render-DkJJmoI4.js';
 export { D as DOMTreeConstruction } from '../../../shared-chunks/element-builder-CnlTPNyw.js';
 export { i as isSerializationFirstNode } from '../../../shared-chunks/rehydrate-builder-DJ8k-6fg.js';
 export { NodeDOMTreeConstruction } from '../../../@glimmer/node/index.js';
-export { e as element } from '../../../shared-chunks/element-DUOVW5Ho.js';
+export { e as element } from '../../../shared-chunks/element-9DRa_9dO.js';
 export { u as uniqueId } from '../../../shared-chunks/unique-id-CfHImDRV.js';
 export { c as componentCapabilities, m as modifierCapabilities } from '../../../shared-chunks/api-CM1trl_4.js';
 

package/dist/prod/packages/@ember/-internals/runtime/lib/mixins/target_action_support.js

@@ -10,7 +10,7 @@ import Mixin from '../../../../object/mixin.js';
 
 /**
 `TargetActionSupport` is a mixin that can be included in a class
-to add a `triggerAction` method with semantics similar to the Handlebars
+to add a `triggerAction` method with semantics similar to the
 `{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
 usually the best choice. This mixin is most often useful when you are
 doing more complex event handling in Components.

package/dist/prod/packages/@ember/application/index.js

@@ -24,7 +24,7 @@ import BucketCache from '../routing/lib/cache.js';
 import ApplicationInstance from './instance.js';
 import Engine, { buildInitializerMethod } from '../engine/index.js';
 import { privatize } from '../-internals/container/index.js';
-import { s as setupApplicationRegistry } from '../../shared-chunks/setup-registry-C2KfZJWI.js';
+import { s as setupApplicationRegistry } from '../../shared-chunks/setup-registry-B3DhqtxX.js';
 import RouterService from '../routing/router-service.js';
 
 /**

package/dist/prod/packages/@ember/application/instance.js

@@ -2,7 +2,7 @@ import { g as get } from '../../shared-chunks/property_get-CAFdpRyu.js';
 import { s as set } from '../../shared-chunks/property_set-BunbMFtp.js';
 import { e as environment } from '../../shared-chunks/index-Cc8WmrB-.js';
 import EngineInstance from '../engine/instance.js';
-import { r as renderSettled } from '../../shared-chunks/index-qDFz6Mfe.js';
+import { r as renderSettled } from '../../shared-chunks/index-ClxHbCe9.js';
 import '../routing/router.js';
 import '../object/index.js';
 import '../../shared-chunks/guid-Cbq2sNV_.js';

package/dist/prod/packages/@ember/array/index.js

@@ -494,6 +494,10 @@ const MutableArray = Mixin.create(EmberArray, MutableEnumerable, {
 /**
   Creates an `NativeArray` from an Array-like object.
   Does not modify the original object's contents.
+    
+  This exists primarily for historic reasons and should not be used
+  in new code. Prefer native [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
+  or [trackedArray](/ember/release/functions/@ember%2Freactive%2Fcollections/trackedArray).
 
   Example
 

package/dist/prod/packages/@ember/component/helper.js

@@ -1 +1 @@
-export { H as default, h as helper } from '../../shared-chunks/helper-DLjV2ZZW.js';
+export { H as default, h as helper } from '../../shared-chunks/helper-CN6UzshW.js';

package/dist/prod/packages/@ember/component/index.js

@@ -16,7 +16,7 @@ import { p as createTag, D as DIRTY_TAG$1 } from '../../shared-chunks/cache-BIlO
 import { I as IS_DISPATCHING_ATTRS, D as DIRTY_TAG, B as BOUNDS, g as getComponentCapturedArgs, C as CURLY_COMPONENT_MANAGER } from '../../shared-chunks/curly-ZzX43b50.js';
 import { h as hasDOM } from '../../shared-chunks/has-dom-DdQORPzI.js';
 import { a as decorateMethodV2 } from '../../shared-chunks/runtime-CYyqkz5q-BOdRhmsS.js';
-export { I as Input, T as Textarea } from '../../shared-chunks/textarea-CHqL0Rdh.js';
+export { I as Input, T as Textarea } from '../../shared-chunks/textarea-Byj32raR.js';
 import { s as setComponentManager$1 } from '../../shared-chunks/api-CM1trl_4.js';
 export { c as capabilities } from '../../shared-chunks/api-CM1trl_4.js';
 import '../../shared-chunks/capabilities-_5e35539.js';
@@ -55,6 +55,12 @@ const EMPTY_ARRAY = Object.freeze([]);
   API documentation for Template-only or Glimmer components, it is [available
   here](/ember/release/modules/@glimmer%2Fcomponent).
 
+  Note: Prior to Ember 6.8, by default, components were authored in paired `.hbs` and `.js`
+  files. This is still supported, but the default authoring format is now `.gjs` or "template tag".
+  The documentation for `@ember/component` still refers to the older authoring format. To read about
+  the new authoring format, see the 
+  [Glimmer Component API documentation](/ember/release/modules/@glimmer%2Fcomponent).
+    
   ## Defining a Classic Component
 
   If you want to customize the component in order to handle events, transform
@@ -81,7 +87,7 @@ const EMPTY_ARRAY = Object.freeze([]);
 
   And then use it in the component's template:
 
-  ```app/templates/components/person-profile.hbs
+  ```app/components/person-profile.hbs
   <h1>{{this.displayName}}</h1>
   {{yield}}
   ```
@@ -469,7 +475,7 @@ const EMPTY_ARRAY = Object.freeze([]);
   The `layout` property should be set to the default export of a template
   module, which is the name of a template file without the `.hbs` extension.
 
-  ```app/templates/components/person-profile.hbs
+  ```app/components/person-profile.hbs
   <h1>Person's Title</h1>
   <div class='details'>{{yield}}</div>
   ```

package/dist/prod/packages/@ember/engine/index.js

@@ -11,7 +11,7 @@ import '../../route-recognizer/index.js';
 import '../../shared-chunks/rsvp-CnCSY930.js';
 import '../../shared-chunks/unrecognized-url-error-DDBwfzdm.js';
 import RoutingService from '../routing/lib/routing-service.js';
-import { a as setupEngineRegistry } from '../../shared-chunks/setup-registry-C2KfZJWI.js';
+import { a as setupEngineRegistry } from '../../shared-chunks/setup-registry-B3DhqtxX.js';
 import RegistryProxyMixin from '../-internals/runtime/lib/mixins/registry_proxy.js';
 
 function props(obj) {

package/dist/prod/packages/@ember/helper/index.js

@@ -1,10 +1,10 @@
 import { b as setHelperManager$1 } from '../../shared-chunks/api-CM1trl_4.js';
 import { i as helperCapabilities } from '../../shared-chunks/api-zh_k31vb.js';
 import { i as invokeHelper$1 } from '../../shared-chunks/invoke-Cj5zMqHz.js';
-import { a as array$1, f as fn$1, h as hash$1 } from '../../shared-chunks/hash-mcs3pEFO.js';
-import { c as concat$1, g as get$1 } from '../../shared-chunks/get-t0-itmA-.js';
-import { a as and$1, e as eq$1, g as gt$1, b as gte$1, l as lt$1, c as lte$1, n as neq$1, d as not$1, o as or$1 } from '../../shared-chunks/or-3AxY5TPj.js';
-import { e as element$1 } from '../../shared-chunks/element-DUOVW5Ho.js';
+import { a as array$1, f as fn$1, h as hash$1 } from '../../shared-chunks/hash-Dkj3I4L4.js';
+import { c as concat$1, g as get$1 } from '../../shared-chunks/get-Dt5L0TcU.js';
+import { a as and$1, e as eq$1, g as gt$1, b as gte$1, l as lt$1, c as lte$1, n as neq$1, d as not$1, o as or$1 } from '../../shared-chunks/or-Crsa2wci.js';
+import { e as element$1 } from '../../shared-chunks/element-9DRa_9dO.js';
 import { u as uniqueId$1 } from '../../shared-chunks/unique-id-CfHImDRV.js';
 
 /**
@@ -336,18 +336,12 @@ const invokeHelper = invokeHelper$1;
  * as an argument to your components.
  *
  * ```
- * import { hash } from '@ember/helper';
- *
  * <template>
  *   {{#each-in (hash givenName='Jen' familyName='Weber') as |key value|}}
  *     <p>{{key}}: {{value}}</p>
  *   {{/each-in}}
  * </template>
  * ```
- *
- * **NOTE:** this example uses the experimental `<template>` feature, which is
- * the only place you need to import `hash` to use it (it is a built-in when
- * writing standalone `.hbs` files).
  */
 const hash = hash$1;
 /**
@@ -355,7 +349,6 @@ const hash = hash$1;
  * as an argument to your components.
  *
  * ```js
- * import { array } from '@ember/helper';
  *
  * <template>
  *   <ul>
@@ -364,10 +357,6 @@ const hash = hash$1;
  *   {{/each}}
  *   </ul>
  * </template>
- *
- * **NOTE:** this example uses the experimental `<template>` feature, which is
- * the only place you need to import `array` to use it (it is a built-in when
- * writing standalone `.hbs` files).
  * ```
  */
 const array = array$1;
@@ -388,10 +377,6 @@ const array = array$1;
  *
  * This will display the result of `@foo.item1` when `index` is `1`, and
  * `this.foo.item2` when `index` is `2`, etc.
- *
- * **NOTE:** this example uses the experimental `<template>` feature, which is
- * the only place you need to import `concat` to use it (it is a built-in when
- * writing standalone `.hbs` files).
  */
 const concat = concat$1;
 /**
@@ -431,10 +416,6 @@ const concat = concat$1;
  *
  * This will display the result of `@foo.item1` when `index` is `1`, and
  * `this.foo.item2` when `index` is `2`, etc.
- *
- * **NOTE:** this example uses the experimental `<template>` feature, which is
- * the only place you need to import `concat` to use it (it is a built-in when
- * writing standalone `.hbs` files).
  */
 const get = get$1;
 /**

package/dist/prod/packages/@ember/modifier/on.js

@@ -1,4 +1,4 @@
-import { o as on$1 } from '../../shared-chunks/on-B5NVufs_.js';
+import { o as on$1 } from '../../shared-chunks/on-CWgOWNSL.js';
 
 // In normal TypeScript, this modifier is essentially an opaque token that just
 // needs to be importable. Declaring it with a unique interface like this,