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

package/dist/prod/packages/@ember/array/lib/is-array.js

@@ -0,0 +1,64 @@
+import '../../../shared-chunks/property_get-DAKgbeJX.js';
+import typeOf from '../../utils/lib/type-of.js';
+import { isEmberArray } from '../-internals.js';
+
+/**
+ @module @ember/array
+*/
+
+/**
+  Returns true if the passed object is an array or Array-like.
+
+  Objects are considered Array-like if any of the following are true:
+
+    - the object is a native Array
+    - the object has an objectAt property
+    - the object is an Object, and has a length property
+
+  Unlike `typeOf` this method returns true even if the passed object is
+  not formally an array but appears to be array-like (i.e. implements `Array`)
+
+  ```javascript
+  import { isArray } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+
+  isArray();                                      // false
+  isArray([]);                                    // true
+  isArray(ArrayProxy.create({ content: [] }));    // true
+  ```
+
+  @method isArray
+  @static
+  @for @ember/array
+  @param {Object} obj The object to test
+  @return {Boolean} true if the passed object is an array or Array-like
+  @public
+*/
+function isArray(obj) {
+
+  // SAFETY: Property read checks are safe if it's an object
+  if (!obj || obj.setInterval) {
+    return false;
+  }
+
+  // EmberArray's `init` brands every instance via `setEmberArray`; the only
+  // unbranded EmberArray objects are native arrays upgraded by `A()`, which
+  // `Array.isArray` catches. So this matches `EmberArray.detect` without
+  // pulling in the mixin's module.
+  if (Array.isArray(obj) || isEmberArray(obj)) {
+    return true;
+  }
+  let type = typeOf(obj);
+  if ('array' === type) {
+    return true;
+  }
+
+  // SAFETY: Property read checks are safe if it's an object
+  let length = obj.length;
+  if (typeof length === 'number' && length === length && 'object' === type) {
+    return true;
+  }
+  return false;
+}
+
+export { isArray as default };

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

@@ -1,14 +1,14 @@
-import { o as objectAt, b as tagForProperty } from '../../shared-chunks/chain-tags-BP0V2LnZ.js';
-import { a as alias } from '../../shared-chunks/alias-DsIh-16z.js';
-import { P as PROPERTY_DID_CHANGE } from '../../shared-chunks/computed-D6MVTTDd.js';
-import { d as replace, c as arrayContentWillChange, b as arrayContentDidChange, a as addArrayObserver, r as removeArrayObserver } from '../../shared-chunks/array-DYFI95FA.js';
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
+import { o as objectAt, a as tagForProperty } from '../../shared-chunks/chain-tags-B2J7DsxO.js';
+import { a as alias } from '../../shared-chunks/alias-Bod6qdNp.js';
+import { P as PROPERTY_DID_CHANGE } from '../../shared-chunks/computed-DtIStxvq.js';
+import { r as replace, a as arrayContentWillChange, b as arrayContentDidChange, c as addArrayObserver, d as removeArrayObserver } from '../../shared-chunks/array-BzReKMeW.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
 import { i as isObject } from '../../shared-chunks/spec-BXl1reqK.js';
 import EmberObject from '../object/index.js';
 import { MutableArray } from './index.js';
-import { s as setCustomTagFor } from '../../shared-chunks/args-proxy-CaXVcI8G.js';
-import { k as consumeTag, x as validateTag, y as valueForTag, j as combine } from '../../shared-chunks/cache-CG6_L9db.js';
-import { t as tagFor } from '../../shared-chunks/meta-Ce6-qROq.js';
+import { s as setCustomTagFor } from '../../shared-chunks/args-proxy-CCoFtYLS.js';
+import { c as consumeTag, v as validateTag, a as valueForTag, d as combine } from '../../shared-chunks/cache-CofLhaS4.js';
+import { t as tagFor } from '../../shared-chunks/meta-BJtIZDir.js';
 
 /**
 @module @ember/array/proxy

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

@@ -1 +1,305 @@
-export { H as default, h as helper } from '../../shared-chunks/helper-CCK8Ef0x.js';
+import { setOwner } from '../-internals/owner/index.js';
+import { FrameworkObject } from '../object/-internals.js';
+import { g as getDebugName } from '../../shared-chunks/get-debug-name-BDxIL2Y1.js';
+import { join } from '../runloop/index.js';
+import { i as helperCapabilities } from '../../shared-chunks/api-DlJKfm_f.js';
+import { b as setHelperManager } from '../../shared-chunks/api-B_poQGXS.js';
+import { r as createTag, D as DIRTY_TAG, c as consumeTag } from '../../shared-chunks/cache-CofLhaS4.js';
+import { I as IS_CLASSIC_HELPER } from '../../shared-chunks/helper-brand-C9_8vvOf.js';
+
+/**
+@module @ember/component
+*/
+
+const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
+
+// Signature type utilities
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+
+// Implements Ember's `Factory` interface and tags it for narrowing/checking.
+
+// A zero-runtime-overhead private symbol to use in branding the component to
+// preserve its type parameter.
+
+/**
+  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.gjs
+  import Cost from '../components/cost';
+
+  <template>
+    <Cost @cents={{230}} />
+  </template>
+  ```
+
+  ```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.
+
+  ```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:
+
+  ```app/helpers/format-currency.js
+  import Helper from '@ember/component/helper';
+
+  export default class extends Helper {
+    compute([cents], { currency }) {
+      return `${currency}${cents * 0.01}`;
+    }
+  }
+  ```
+
+  Each time the input to a helper changes, the `compute` function will be
+  called again.
+
+  As instances, these helpers also have access to the container and will accept
+  injected dependencies.
+
+  Additionally, class helpers can call `recompute` to force a new computation.
+
+  @class Helper
+  @extends CoreObject
+  @public
+  @since 1.13.0
+*/
+// ESLint doesn't understand declaration merging.
+/* eslint-disable import/export */
+
+class Helper extends FrameworkObject {
+  static isHelperFactory = true;
+  static [IS_CLASSIC_HELPER] = true;
+
+  // `packages/ember/index.js` was setting `Helper.helper`. This seems like
+  // a bad idea and probably not something we want. We've moved that definition
+  // here, but it should definitely be reviewed and probably removed.
+  /** @deprecated */
+  static helper = helper;
+
+  // SAFETY: this is initialized in `init`, rather than `constructor`. It is
+  // safe to `declare` like this *if and only if* nothing uses the constructor
+  // directly in this class, since nothing else can run before `init`.
+
+  // SAFETY: this has no runtime existence whatsoever; it is a "phantom type"
+  // here to preserve the type param.
+
+  init(properties) {
+    super.init(properties);
+    this[RECOMPUTE_TAG] = createTag();
+  }
+
+  /**
+    On a class-based helper, it may be useful to force a recomputation of that
+    helpers value. This is akin to `rerender` on a component.
+     In most cases, `recompute` is not needed because accessing tracked
+    properties in `compute` will automatically re-run the helper when
+    those properties change. Use `recompute` only when you need to
+    trigger a recomputation imperatively, for example in response to an
+    external event:
+     ```app/helpers/current-time.js
+    import Helper from '@ember/component/helper';
+     export default class CurrentTimeHelper extends Helper {
+      interval = null;
+       compute() {
+        return new Date().toLocaleTimeString();
+      }
+       constructor() {
+        super(...arguments);
+        this.interval = setInterval(() => this.recompute(), 1000);
+      }
+       willDestroy() {
+        super.willDestroy();
+        clearInterval(this.interval);
+      }
+    }
+    ```
+     @method recompute
+    @public
+    @since 1.13.0
+  */
+  recompute() {
+    join(() => DIRTY_TAG(this[RECOMPUTE_TAG]));
+  }
+}
+/* eslint-enable import/export */
+
+class ClassicHelperManager {
+  capabilities = helperCapabilities('3.23', {
+    hasValue: true,
+    hasDestroyable: true
+  });
+  ownerInjection;
+  constructor(owner) {
+    let ownerInjection = {};
+    setOwner(ownerInjection, owner);
+    this.ownerInjection = ownerInjection;
+  }
+  createHelper(definition, args) {
+    let instance = isFactoryManager(definition) ? definition.create() : definition.create(this.ownerInjection);
+    return {
+      instance,
+      args
+    };
+  }
+  getDestroyable({
+    instance
+  }) {
+    return instance;
+  }
+  getValue({
+    instance,
+    args
+  }) {
+    let {
+      positional,
+      named
+    } = args;
+    let ret = instance.compute(positional, named);
+    consumeTag(instance[RECOMPUTE_TAG]);
+    return ret;
+  }
+  getDebugName(definition) {
+    return getDebugName((definition.class || definition)['prototype']);
+  }
+}
+function isFactoryManager(obj) {
+  return obj != null && 'class' in obj;
+}
+setHelperManager(owner => {
+  return new ClassicHelperManager(owner);
+}, Helper);
+
+///////////
+
+class Wrapper {
+  isHelperFactory = true;
+  constructor(compute) {
+    this.compute = compute;
+  }
+  create() {
+    // needs new instance or will leak containers
+    return {
+      compute: this.compute
+    };
+  }
+}
+class SimpleClassicHelperManager {
+  capabilities = helperCapabilities('3.23', {
+    hasValue: true
+  });
+  createHelper(definition, args) {
+    return () => definition.compute.call(null, args.positional, args.named);
+  }
+  getValue(fn) {
+    return fn();
+  }
+  getDebugName(definition) {
+    return getDebugName(definition.compute);
+  }
+}
+const SIMPLE_CLASSIC_HELPER_MANAGER = new SimpleClassicHelperManager();
+setHelperManager(() => SIMPLE_CLASSIC_HELPER_MANAGER, Wrapper.prototype);
+
+/*
+  Function-based helpers need to present with a constructor signature so that
+  type parameters can be preserved when `helper()` is passed a generic function
+  (this is particularly key for checking helper invocations with Glint).
+  Accordingly, we define an abstract class and declaration merge it with the
+  interface; this inherently provides an `abstract` constructor. Since it is
+  `abstract`, it is not callable, which is important since end users should not
+  be able to do `let myHelper = helper(someFn); new myHelper()`.
+ */
+
+/**
+ * The type of a function-based helper.
+ *
+ * @note This is *not* user-constructible: it is exported only so that the type
+ *   returned by the `helper` function can be named (and indeed can be exported
+ *   like `export default helper(...)` safely).
+ */
+// Making `FunctionBasedHelper` an alias this way allows callers to name it in
+// terms meaningful to *them*, while preserving the type behavior described on
+// the `abstract class FunctionBasedHelperInstance` below.
+
+// This abstract class -- specifically, its `protected abstract __concrete__`
+// member -- prevents subclasses from doing `class X extends helper(..)`, since
+// that is an error at runtime. While it is rare that people would type that, it
+// is not impossible and we use this to give them early signal via the types for
+// a behavior which will break (and in a somewhat inscrutable way!) at runtime.
+//
+// This is needful because we lie about what this actually is for Glint's sake:
+// a function-based helper returns a `Factory<SimpleHelper>`, which is designed
+// to be "opaque" from a consumer's POV, i.e. not user-callable or constructible
+// but only useable in a template (or via `invokeHelper()` which also treats it
+// as a fully opaque `object` from a type POV). But Glint needs a `Helper<S>` to
+// make it work the same way as class-based helpers. (Note that this does not
+// hold for plain functions as helpers, which it can handle distinctly.) This
+// signature thus makes it so that the item is usable *as* a `Helper` in Glint,
+// but without letting end users treat it as a helper class instance.
+
+/**
+  In many cases it is not necessary to use the full `Helper` class.
+  The `helper` method create pure-function helpers without instances.
+  For example:
+
+  ```app/helpers/format-currency.js
+  import { helper } from '@ember/component/helper';
+
+  export default helper(function([cents], {currency}) {
+    return `${currency}${cents * 0.01}`;
+  });
+  ```
+
+  @static
+  @param {Function} helper The helper function
+  @method helper
+  @for @ember/component/helper
+  @public
+  @since 1.13.0
+*/
+// This overload allows users to write types directly on the callback passed to
+// the `helper` function and infer the resulting type correctly.
+
+// This overload allows users to provide a `Signature` type explicitly at the
+// helper definition site, e.g. `helper<Sig>((pos, named) => {...})`. **Note:**
+// this overload must appear second, since TS' inference engine will not
+// correctly infer the type of `S` here from the types on the supplied callback.
+
+function helper(helperFn) {
+  // SAFETY: this is completely lies, in two ways:
+  //
+  // 1. `Wrapper` is a `Factory<SimpleHelper<S>>`, but from the perspective of
+  //    any external callers (i.e. Ember *users*), it is quite important that
+  //    the `Factory` relationship be hidden, because it is not public API for
+  //    an end user to call `.create()` on a helper created this way. Instead,
+  //    we provide them an `abstract new` signature (which means it cannot be
+  //    directly constructed by calling `new` on it) and which does not have the
+  //    `.create()` signature on it anymore.
+  //
+  // 2. The produced type here ends up being a subtype of `Helper`, which is not
+  //    strictly true. This is necessary for the sake of Glint, which provides
+  //    its information by way of a "declaration merge" with `Helper<S>` in the
+  //    case of items produced by `helper()`.
+  //
+  // Long-term, this entire construct can go away in favor of deprecating the
+  // `helper()` invocation in favor of using plain functions.
+  return new Wrapper(helperFn);
+}
+
+export { Helper as default, helper };

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

@@ -1,25 +1,25 @@
 export { g as getComponentTemplate, s as setComponentTemplate } from '../../shared-chunks/template-Dc_cBOoX.js';
-import { n as nativeDescDecorator } from '../../shared-chunks/decorator-B8Lpq40g.js';
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
-import { P as PROPERTY_DID_CHANGE } from '../../shared-chunks/computed-D6MVTTDd.js';
+import { n as nativeDescDecorator } from '../../shared-chunks/decorator-9ikVwsjY.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
+import { P as PROPERTY_DID_CHANGE } from '../../shared-chunks/computed-DtIStxvq.js';
 import { getOwner } from '../-internals/owner/index.js';
 import TargetActionSupport from '../-internals/runtime/lib/mixins/target_action_support.js';
 import ActionSupport from '../-internals/views/lib/mixins/action_support.js';
 import { getViewElement, getChildViews, addChildView } from '../-internals/views/lib/system/utils.js';
 import CoreView from '../-internals/views/lib/views/core_view.js';
 import '../object/index.js';
-import { a as guidFor } from '../../shared-chunks/guid-PO2v9BaN.js';
-import { s as setInternalComponentManager } from '../../shared-chunks/api-DOLN_cR2.js';
-import { l as isUpdatableRef, u as updateRef } from '../../shared-chunks/reference-D2agTt1V.js';
+import { g as guidFor } from '../../shared-chunks/guid-Cbq2sNV_.js';
+import { s as setInternalComponentManager } from '../../shared-chunks/api-DlJKfm_f.js';
+import { b as isUpdatableRef, u as updateRef } from '../../shared-chunks/reference-CG0yPgLy.js';
 import { n as normalizeProperty } from '../../shared-chunks/props-fiqxqhAH.js';
-import { m as createTag, D as DIRTY_TAG$1 } from '../../shared-chunks/cache-CG6_L9db.js';
-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-DCYSwLtz.js';
+import { r as createTag, D as DIRTY_TAG$1 } from '../../shared-chunks/cache-CofLhaS4.js';
+import { I as IS_DISPATCHING_ATTRS, D as DIRTY_TAG, B as BOUNDS, g as getComponentCapturedArgs, b as CURLY_COMPONENT_MANAGER } from '../../shared-chunks/curly-a6DP7r87.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-B_JYBuE8.js';
-import { s as setComponentManager$1 } from '../../shared-chunks/api-CGZbGcvX.js';
-export { c as capabilities } from '../../shared-chunks/api-CGZbGcvX.js';
-import '../../shared-chunks/capabilities-_5e35539.js';
+export { I as Input, T as Textarea } from '../../shared-chunks/textarea-DOmZ1x0E.js';
+import { s as setComponentManager$1 } from '../../shared-chunks/api-B_poQGXS.js';
+export { c as capabilities } from '../../shared-chunks/api-B_poQGXS.js';
+import '../../shared-chunks/capabilities-BuVYh-vx.js';
 
 let lazyEventsProcessed = new WeakMap();
 const EMPTY_ARRAY = Object.freeze([]);
@@ -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/component/template-only.js

@@ -1,4 +1,4 @@
-import { t as templateOnlyComponent } from '../../shared-chunks/template-only-CP0NT7ce.js';
+import { t as templateOnlyComponent } from '../../shared-chunks/template-only-DKNcKM5b.js';
 
 /**
   @module @ember/component/template-only

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

@@ -1,8 +1,8 @@
 import { getOwner } from '../-internals/owner/index.js';
-import { d as computed } from '../../shared-chunks/computed-D6MVTTDd.js';
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
+import { c as computed } from '../../shared-chunks/computed-DtIStxvq.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
 import { FrameworkObject } from '../object/-internals.js';
-import { i as inject$1 } from '../../shared-chunks/injected_property-COGiYHKc.js';
+import { i as inject$1 } from '../../shared-chunks/injected_property-Y-FadDej.js';
 import Mixin from '../object/mixin.js';
 import ActionHandler from '../-internals/runtime/lib/mixins/action_handler.js';
 

package/dist/prod/packages/@ember/debug/data-adapter.js

@@ -1,12 +1,12 @@
 import { getOwner } from '../-internals/owner/index.js';
 import { _backburner, next } from '../runloop/index.js';
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
 import { dasherize } from '../-internals/string/index.js';
 import Namespace from '../application/namespace.js';
 import EmberObject from '../object/index.js';
 import { A } from '../array/index.js';
-import { l as createCache, k as consumeTag, w as untrack, q as getValue } from '../../shared-chunks/cache-CG6_L9db.js';
-import { t as tagFor } from '../../shared-chunks/meta-Ce6-qROq.js';
+import { e as createCache, c as consumeTag, u as untrack, g as getValue } from '../../shared-chunks/cache-CofLhaS4.js';
+import { t as tagFor } from '../../shared-chunks/meta-BJtIZDir.js';
 import '../../shared-chunks/env-DXxsTFkM.js';
 import { assert } from './lib/assert.js';
 

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

@@ -4,14 +4,14 @@ import Namespace from '../application/namespace.js';
 import { Registry } from '../-internals/container/index.js';
 import DAG from '../../dag-map/index.js';
 import ContainerDebugAdapter from '../debug/container-debug-adapter.js';
-import { g as get } from '../../shared-chunks/property_get-Sw0SicEZ.js';
-import { s as set } from '../../shared-chunks/property_set-SHEIPMUG.js';
+import { g as get } from '../../shared-chunks/property_get-DAKgbeJX.js';
+import { s as set } from '../../shared-chunks/property_set-BaQJdVfS.js';
 import EngineInstance from './instance.js';
 import '../../route-recognizer/index.js';
-import '../../shared-chunks/rsvp-C6j8G1D1.js';
-import '../../shared-chunks/unrecognized-url-error-ClNyMFJt.js';
+import '../../shared-chunks/rsvp.es-DR7yS7qg.js';
+import '../../shared-chunks/unrecognized-url-error-jjQ-FqKB.js';
 import RoutingService from '../routing/lib/routing-service.js';
-import { a as setupEngineRegistry } from '../../shared-chunks/setup-registry-D14I0iDX.js';
+import { b as setupEngineRegistry } from '../../shared-chunks/setup-registry-Dfu8EyLU.js';
 import RegistryProxyMixin from '../-internals/runtime/lib/mixins/registry_proxy.js';
 import { StrictResolver } from './lib/strict-resolver.js';
 

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

@@ -1,11 +1,11 @@
 import EmberObject from '../object/index.js';
 import '../-internals/runtime/lib/ext/rsvp.js';
 import { Registry, privatize } from '../-internals/container/index.js';
-import { a as guidFor } from '../../shared-chunks/guid-PO2v9BaN.js';
+import { g as guidFor } from '../../shared-chunks/guid-Cbq2sNV_.js';
 import { ENGINE_PARENT, setEngineParent, getEngineParent } from './lib/engine-parent.js';
 import ContainerProxyMixin from '../-internals/runtime/lib/mixins/container_proxy.js';
 import RegistryProxyMixin from '../-internals/runtime/lib/mixins/registry_proxy.js';
-import { R as RSVP } from '../../shared-chunks/rsvp-C6j8G1D1.js';
+import { R as RSVP } from '../../shared-chunks/rsvp.es-DR7yS7qg.js';
 
 /**
 @module @ember/engine

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

@@ -1,11 +1,11 @@
-import { b as setHelperManager$1 } from '../../shared-chunks/api-CGZbGcvX.js';
-import { i as helperCapabilities } from '../../shared-chunks/api-DOLN_cR2.js';
-import { i as invokeHelper$1 } from '../../shared-chunks/invoke-D_jsLbsj.js';
-import { a as array$1, f as fn$1, h as hash$1 } from '../../shared-chunks/hash-C6IoC4eR.js';
-import { c as concat$1, g as get$1 } from '../../shared-chunks/get-tlL23wmp.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-sYlRiUn_.js';
-import { e as element$1 } from '../../shared-chunks/element-CT5H5uxF.js';
-import { u as uniqueId$1 } from '../../shared-chunks/unique-id-Hn8Qp4dS.js';
+import { b as setHelperManager$1 } from '../../shared-chunks/api-B_poQGXS.js';
+import { i as helperCapabilities } from '../../shared-chunks/api-DlJKfm_f.js';
+import { i as invokeHelper$1 } from '../../shared-chunks/invoke-DhQ5QRp2.js';
+import { a as array$1, f as fn$1, h as hash$1 } from '../../shared-chunks/hash-gEXIsSO4.js';
+import { c as concat$1, g as get$1 } from '../../shared-chunks/get-Dago5uGl.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/not-BOIVROuv.js';
+import { e as element$1 } from '../../shared-chunks/element-DgHdPZ8u.js';
+import { u as uniqueId$1 } from '../../shared-chunks/unique-id-o2pS74go.js';
 
 /**
 @module @ember/helper
@@ -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/index.js

@@ -1,5 +1,5 @@
-import { d as setModifierManager$1 } from '../../shared-chunks/api-CGZbGcvX.js';
-export { m as capabilities } from '../../shared-chunks/api-CGZbGcvX.js';
+import { d as setModifierManager$1 } from '../../shared-chunks/api-B_poQGXS.js';
+export { m as capabilities } from '../../shared-chunks/api-B_poQGXS.js';
 export { on } from './on.js';
 
 // NOTE: this uses assignment to *require* that the `glimmerSetModifierManager`

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

@@ -1,4 +1,4 @@
-import { o as on$1 } from '../../shared-chunks/on-Dgmychhk.js';
+import { o as on$1 } from '../../shared-chunks/on-BZHAxzdq.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,

package/dist/prod/packages/@ember/object/-internals.js

@@ -1,6 +1,6 @@
 export { g as cacheFor } from '../../shared-chunks/computed_cache-DmYKevAP.js';
-export { a as guidFor } from '../../shared-chunks/guid-PO2v9BaN.js';
-import '../../shared-chunks/super-D4qkU4uq.js';
+export { g as guidFor } from '../../shared-chunks/guid-Cbq2sNV_.js';
+import '../../shared-chunks/super-BBBjgF69.js';
 import EmberObject from './index.js';
 
 // Here we have runtime shenanigans to add debug-only errors to the class in dev

package/dist/prod/packages/@ember/object/compat.js

@@ -1,6 +1,6 @@
-import { s as setClassicDecorator, c as isElementDescriptor } from '../../shared-chunks/decorator-B8Lpq40g.js';
-import { v as track, U as UPDATE_TAG, k as consumeTag } from '../../shared-chunks/cache-CG6_L9db.js';
-import { t as tagFor } from '../../shared-chunks/meta-Ce6-qROq.js';
+import { s as setClassicDecorator, i as isElementDescriptor } from '../../shared-chunks/decorator-9ikVwsjY.js';
+import { t as track, U as UPDATE_TAG, c as consumeTag } from '../../shared-chunks/cache-CofLhaS4.js';
+import { t as tagFor } from '../../shared-chunks/meta-BJtIZDir.js';
 
 let wrapGetterSetter = function (target, key, desc) {
   let {