ember-source 5.0.0 → 5.1.0-alpha.2

package/dist/ember.debug.js

@@ -6,7 +6,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   5.0.0
+ * @version   5.1.0-alpha.2
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */
@@ -1633,7 +1633,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     @param {Hash} options
     @public
   */
-  class Input extends AbstractInput {
+  class _Input extends AbstractInput {
     constructor() {
       super(...arguments);
       this._checked = valueFrom(this.args.named['checked']);
@@ -1703,11 +1703,11 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
     }
   }
-  __decorate$1([_object.action], Input.prototype, "change", null);
-  __decorate$1([_object.action], Input.prototype, "input", null);
-  __decorate$1([_object.action], Input.prototype, "checkedDidChange", null);
-  var Input$1 = opaquify(Input, InputTemplate);
-  _exports.Input = Input$1;
+  __decorate$1([_object.action], _Input.prototype, "change", null);
+  __decorate$1([_object.action], _Input.prototype, "input", null);
+  __decorate$1([_object.action], _Input.prototype, "checkedDidChange", null);
+  var Input = opaquify(_Input, InputTemplate);
+  _exports.Input = Input;
   var LinkToTemplate = (0, _opcodeCompiler.templateFactory)({
     "id": "CVwkBtGh",
     "block": "[[[11,3],[16,1,[30,0,[\"id\"]]],[16,0,[30,0,[\"class\"]]],[16,\"role\",[30,0,[\"role\"]]],[16,\"title\",[30,0,[\"title\"]]],[16,\"rel\",[30,0,[\"rel\"]]],[16,\"tabindex\",[30,0,[\"tabindex\"]]],[16,\"target\",[30,0,[\"target\"]]],[17,1],[16,6,[30,0,[\"href\"]]],[4,[38,0],[\"click\",[30,0,[\"click\"]]],null],[12],[18,2,null],[13]],[\"&attrs\",\"&default\"],false,[\"on\",\"yield\"]]",
@@ -1965,7 +1965,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     @see {Ember.Templates.components.LinkTo}
     @public
   **/
-  class LinkTo extends InternalComponent {
+  class _LinkTo extends InternalComponent {
     constructor() {
       super(...arguments);
       // GH #17963
@@ -2191,11 +2191,11 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
     }
   }
-  __decorate$2([(0, _service.service)('-routing')], LinkTo.prototype, "routing", void 0);
-  __decorate$2([_object.action], LinkTo.prototype, "click", null);
+  __decorate$2([(0, _service.service)('-routing')], _LinkTo.prototype, "routing", void 0);
+  __decorate$2([_object.action], _LinkTo.prototype, "click", null);
   var {
     prototype
-  } = LinkTo;
+  } = _LinkTo;
   var descriptorFor = (target, property) => {
     if (target) {
       return Object.getOwnPropertyDescriptor(target, property) || descriptorFor(Object.getPrototypeOf(target), property);
@@ -2276,8 +2276,8 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       }
     });
   }
-  var LinkTo$1 = opaquify(LinkTo, LinkToTemplate);
-  _exports.LinkTo = LinkTo$1;
+  var LinkTo = opaquify(_LinkTo, LinkToTemplate);
+  _exports.LinkTo = LinkTo;
   var TextareaTemplate = (0, _opcodeCompiler.templateFactory)({
     "id": "OpzctQXz",
     "block": "[[[11,\"textarea\"],[16,1,[30,0,[\"id\"]]],[16,0,[30,0,[\"class\"]]],[17,1],[16,2,[30,0,[\"value\"]]],[4,[38,0],[\"change\",[30,0,[\"change\"]]],null],[4,[38,0],[\"input\",[30,0,[\"input\"]]],null],[4,[38,0],[\"keyup\",[30,0,[\"keyUp\"]]],null],[4,[38,0],[\"paste\",[30,0,[\"valueDidChange\"]]],null],[4,[38,0],[\"cut\",[30,0,[\"valueDidChange\"]]],null],[12],[13]],[\"&attrs\"],false,[\"on\"]]",
@@ -2424,7 +2424,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     @see {Ember.Templates.components.Textarea}
     @public
   **/
-  class Textarea extends AbstractInput {
+  class _Textarea extends AbstractInput {
     static toString() {
       return 'Textarea';
     }
@@ -2443,10 +2443,10 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       return supportedArguments.indexOf(name) !== -1 || super.isSupportedArgument(name);
     }
   }
-  __decorate$3([_object.action], Textarea.prototype, "change", null);
-  __decorate$3([_object.action], Textarea.prototype, "input", null);
-  var Textarea$1 = opaquify(Textarea, TextareaTemplate);
-  _exports.Textarea = Textarea$1;
+  __decorate$3([_object.action], _Textarea.prototype, "change", null);
+  __decorate$3([_object.action], _Textarea.prototype, "input", null);
+  var Textarea = opaquify(_Textarea, TextareaTemplate);
+  _exports.Textarea = Textarea;
   function isTemplateFactory(template) {
     return typeof template === 'function';
   }
@@ -3533,49 +3533,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   Component.isComponentFactory = true;
   // We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
   Component.reopenClass({
-    /**
-     Enables components to take a list of parameters as arguments.
-      For example, a component that takes two parameters with the names
-      `name` and `age`:
-         ```app/components/my-component.js
-      import Component from '@ember/component';
-         let MyComponent = Component.extend();
-         MyComponent.reopenClass({
-        positionalParams: ['name', 'age']
-      });
-         export default MyComponent;
-      ```
-         It can then be invoked like this:
-         ```hbs
-      {{my-component "John" 38}}
-      ```
-         The parameters can be referred to just like named parameters:
-         ```hbs
-      Name: {{name}}, Age: {{age}}.
-      ```
-         Using a string instead of an array allows for an arbitrary number of
-      parameters:
-         ```app/components/my-component.js
-      import Component from '@ember/component';
-         let MyComponent = Component.extend();
-         MyComponent.reopenClass({
-        positionalParams: 'names'
-      });
-         export default MyComponent;
-      ```
-         It can then be invoked like this:
-         ```hbs
-      {{my-component "John" "Michael" "Scott"}}
-      ```
-      The parameters can then be referred to by enumerating over the list:
-         ```hbs
-      {{#each names as |name|}}{{name}}{{/each}}
-      ```
-         @static
-      @public
-      @property positionalParams
-      @since 1.13.0
-      */
     positionalParams: []
   });
   (0, _manager2.setInternalComponentManager)(CURLY_COMPONENT_MANAGER, Component);
@@ -3586,29 +3543,6 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   var _a;
   var RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
   var IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
-  /**
-    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
-  */
-  function helper(helperFn) {
-    return new Wrapper(helperFn);
-  }
   class Helper extends _internals.FrameworkObject {
     init(properties) {
       super.init(properties);
@@ -3651,6 +3585,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   // here, but it should definitely be reviewed and probably removed.
   /** @deprecated */
   Helper.helper = helper;
+  /* eslint-enable import/export */
   function isClassicHelper(obj) {
     return obj[IS_CLASSIC_HELPER] === true;
   }
@@ -3734,10 +3669,7 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
       });
     }
     createHelper(definition, args) {
-      var {
-        compute
-      } = definition;
-      return () => compute.call(null, args.positional, args.named);
+      return () => definition.compute.call(null, args.positional, args.named);
     }
     getValue(fn) {
       return fn();
@@ -3748,6 +3680,29 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
   }
   var SIMPLE_CLASSIC_HELPER_MANAGER = new SimpleClassicHelperManager();
   (0, _manager2.setHelperManager)(() => SIMPLE_CLASSIC_HELPER_MANAGER, Wrapper.prototype);
+  function helper(helperFn
+  // At the implementation site, we don't care about the actual underlying type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ) {
+    // 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);
+  }
 
   /**
   @module @ember/template
@@ -6236,9 +6191,9 @@ define("@ember/-internals/glimmer/index", ["exports", "@glimmer/opcode-compiler"
     registry.optionsForType('helper', {
       instantiate: false
     });
-    registry.register('component:input', Input$1);
-    registry.register('component:link-to', LinkTo$1);
-    registry.register('component:textarea', Textarea$1);
+    registry.register('component:input', Input);
+    registry.register('component:link-to', LinkTo);
+    registry.register('component:textarea', Textarea);
     if (!_environment2.ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
       registry.register((0, _container.privatize)`component:-default`, Component);
     }
@@ -8283,44 +8238,6 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
       desc._readOnly = true;
       return this;
     }
-    /**
-      In some cases, you may want to annotate computed properties with additional
-      metadata about how they function or what values they operate on. For example,
-      computed property functions may close over variables that are then no longer
-      available for introspection. You can pass a hash of these values to a
-      computed property.
-         Example:
-         ```javascript
-      import { computed } from '@ember/object';
-      import Person from 'my-app/utils/person';
-         class Store {
-        @computed().meta({ type: Person })
-        get person() {
-          let personId = this.personId;
-          return Person.create({ id: personId });
-        }
-      }
-      ```
-         Classic Class Example:
-         ```javascript
-      import { computed } from '@ember/object';
-      import Person from 'my-app/utils/person';
-         const Store = EmberObject.extend({
-        person: computed(function() {
-          let personId = this.get('personId');
-          return Person.create({ id: personId });
-        }).meta({ type: Person })
-      });
-      ```
-         The hash that you pass to the `meta()` function will be saved on the
-      computed property descriptor under the `_meta` key. Ember runtime
-      exposes a public API for retrieving these values from classes,
-      via the `metaForProperty()` function.
-         @method meta
-      @param {Object} meta
-      @chainable
-      @public
-    */
     meta(meta) {
       var prop = descriptorForDecorator(this);
       if (arguments.length === 0) {
@@ -8880,38 +8797,13 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
       propertyNames = Array.from(arguments);
     }
     for (; i < propertyNames.length; i++) {
-      ret[propertyNames[i]] = get(obj, propertyNames[i]);
+      // SAFETY: we are just walking the list of property names, so we know the
+      // index access never produces `undefined`.
+      var name = propertyNames[i];
+      ret[name] = get(obj, name);
     }
     return ret;
   }
-
-  /**
-   @module @ember/object
-  */
-  /**
-    Set a list of properties on an object. These properties are set inside
-    a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-    observers will be buffered.
-  
-    ```javascript
-    import EmberObject from '@ember/object';
-    let anObject = EmberObject.create();
-  
-    anObject.setProperties({
-      firstName: 'Stanley',
-      lastName: 'Stuart',
-      age: 21
-    });
-    ```
-  
-    @method setProperties
-    @static
-    @for @ember/object
-    @param obj
-    @param {Object} properties
-    @return properties
-    @public
-  */
   function setProperties(obj, properties) {
     if (properties === null || typeof properties !== 'object') {
       return properties;
@@ -8919,6 +8811,9 @@ define("@ember/-internals/metal/index", ["exports", "@ember/-internals/meta", "@
     changeProperties(() => {
       var props = Object.keys(properties);
       for (var propertyName of props) {
+        // SAFETY: casting `properties` this way is safe because any object in JS
+        // can be indexed this way, and the result will be `unknown`, making it
+        // safe for callers.
         set(obj, propertyName, properties[propertyName]);
       }
     });
@@ -10012,6 +9907,9 @@ define("@ember/-internals/utility-types/index", ["exports"], function (_exports)
   Object.defineProperty(_exports, "__esModule", {
     value: true
   });
+  _exports.Opaque = void 0;
+  class Opaque {}
+  _exports.Opaque = Opaque;
 });
 define("@ember/-internals/utils/index", ["exports", "@glimmer/util", "@ember/debug"], function (_exports, _util, _debug) {
   "use strict";
@@ -14052,7 +13950,6 @@ define("@ember/array/proxy", ["exports", "@ember/-internals/metal", "@ember/obje
     }
     _addArrangedContentArrayObserver(arrangedContent) {
       if (arrangedContent && !arrangedContent.isDestroyed) {
-        // @ts-expect-error This check is still good for ensuring correctness
         (true && !(arrangedContent !== this) && (0, _debug.assert)("Can't set ArrayProxy's content to itself", arrangedContent !== this));
         (true && !(function (arr) {
           return Array.isArray(arr) || _array.default.detect(arr);
@@ -14258,12 +14155,27 @@ define("@ember/component/template-only", ["exports", "@glimmer/runtime"], functi
   Object.defineProperty(_exports, "__esModule", {
     value: true
   });
-  Object.defineProperty(_exports, "default", {
-    enumerable: true,
-    get: function () {
-      return _runtime.templateOnlyComponent;
-    }
-  });
+  _exports.default = void 0;
+  /**
+    @module @ember/component/template-only
+    @public
+  */
+
+  // NOTES:
+  //
+  // 1. The generic here is for a *signature: a way to hang information for tools
+  //    like Glint which can provide typey checking for component templates using
+  //    information supplied via this generic. While it may appear useless on this
+  //    class definition and extension, it is used by external tools and should
+  //    not be removed.
+  // 2. SAFETY: this cast is *throwing away* information that is not part of the
+  //    public API and replacing it with something which has the same calling
+  //    contract, but much less information (since we do not want to expose the
+  //    internal APIs like `moduleName` etc.).
+  // prettier-ignore
+  var templateOnly = _runtime.templateOnlyComponent;
+  var _default = templateOnly;
+  _exports.default = _default;
 });
 define("@ember/controller/index", ["exports", "@ember/-internals/owner", "@ember/object", "@ember/object/-internals", "@ember/-internals/metal", "@ember/object/mixin", "@ember/-internals/runtime", "@ember/-internals/utils"], function (_exports, _owner, _object, _internals, _metal, _mixin, _runtime, _utils) {
   "use strict";
@@ -14989,6 +14901,8 @@ define("@ember/debug/index", ["exports", "@ember/-internals/browser-environment"
   _exports.warn = void 0;
   // These are the default production build versions:
   var noop = () => {};
+  // SAFETY: these casts are just straight-up lies, but the point is that they do
+  // not do anything in production builds.
   var assert = noop;
   _exports.assert = assert;
   var info = noop;
@@ -15063,39 +14977,13 @@ define("@ember/debug/index", ["exports", "@ember/-internals/browser-environment"
   @module @ember/debug
   */
   if (true /* DEBUG */) {
-    /**
-      Verify that a certain expectation is met, or throw a exception otherwise.
-         This is useful for communicating assumptions in the code to other human
-      readers as well as catching bugs that accidentally violates these
-      expectations.
-         Assertions are removed from production builds, so they can be freely added
-      for documentation and debugging purposes without worries of incuring any
-      performance penalty. However, because of that, they should not be used for
-      checks that could reasonably fail during normal usage. Furthermore, care
-      should be taken to avoid accidentally relying on side-effects produced from
-      evaluating the condition itself, since the code will not run in production.
-         ```javascript
-      import { assert } from '@ember/debug';
-         // Test for truthiness
-      assert('Must pass a string', typeof str === 'string');
-         // Fail unconditionally
-      assert('This code path should never be run');
-      ```
-         @method assert
-      @static
-      @for @ember/debug
-      @param {String} description Describes the expectation. This will become the
-        text of the Error thrown if the assertion fails.
-      @param {any} condition Must be truthy for the assertion to pass. If
-        falsy, an exception will be thrown.
-      @public
-      @since 1.0.0
-    */
-    setDebugFunction('assert', function assert(desc, test) {
+    // eslint-disable-next-line no-inner-declarations
+    function _assert(desc, test) {
       if (!test) {
         throw new Error(`Assertion Failed: ${desc}`);
       }
-    });
+    }
+    setDebugFunction('assert', _assert);
     /**
       Display a debug notice.
          Calls to this function are not invoked in production builds.
@@ -15719,6 +15607,7 @@ define("@ember/debug/lib/warn", ["exports", "@ember/debug/index", "@ember/debug/
       }
       (0, _index.assert)(missingOptionsDeprecation, Boolean(options));
       (0, _index.assert)(missingOptionsIdDeprecation, Boolean(options && options.id));
+      // SAFETY: we checked this by way of the `arguments` check above.
       (0, _handlers.invoke)('warn', message, test, options);
     };
   }
@@ -16696,54 +16585,462 @@ define("@ember/helper/index", ["exports", "@glimmer/manager", "@glimmer/runtime"
   Object.defineProperty(_exports, "__esModule", {
     value: true
   });
-  Object.defineProperty(_exports, "array", {
-    enumerable: true,
-    get: function () {
-      return _runtime.array;
-    }
-  });
-  Object.defineProperty(_exports, "capabilities", {
-    enumerable: true,
-    get: function () {
-      return _manager.helperCapabilities;
-    }
-  });
-  Object.defineProperty(_exports, "concat", {
-    enumerable: true,
-    get: function () {
-      return _runtime.concat;
-    }
-  });
-  Object.defineProperty(_exports, "fn", {
-    enumerable: true,
-    get: function () {
-      return _runtime.fn;
+  _exports.setHelperManager = _exports.invokeHelper = _exports.hash = _exports.get = _exports.fn = _exports.concat = _exports.capabilities = _exports.array = void 0;
+  /**
+  @module @ember/helper
+  */
+
+  /**
+    `capabilities` returns a capabilities configuration which can be used to modify
+    the behavior of the manager. Manager capabilities _must_ be provided using the
+    `capabilities` function, as the underlying implementation can change over time.
+  
+    The first argument to capabilities is a version string, which is the version of
+    Ember that the capabilities were defined in. Ember can add new versions at any
+    time, and these may have entirely different behaviors, but it will not remove
+    old versions until the next major version.
+  
+    ```js
+    capabilities('3.23');
+    ```
+  
+    The second argument is an object of capabilities and boolean values indicating
+    whether they are enabled or disabled.
+  
+    ```js
+    capabilities('3.23', {
+      hasValue: true,
+      hasDestructor: true,
+    });
+    ```
+  
+    If no value is specified, then the default value will be used.
+  
+    ### `3.23` capabilities
+  
+    #### `hasDestroyable`
+  
+    - Default value: false
+  
+    Determines if the helper has a destroyable to include in the destructor
+    hierarchy. If enabled, the `getDestroyable` hook will be called, and its result
+    will be associated with the destroyable parent block.
+  
+    #### `hasValue`
+  
+    - Default value: false
+  
+    Determines if the helper has a value which can be used externally. The helper's
+    `getValue` hook will be run whenever the value of the helper is accessed if this
+    capability is enabled.
+  
+    @method capabilities
+    @for @ember/helper
+    @static
+    @param {String} managerApiVersion The version of capabilities that are being used
+    @param options The capabilities values
+    @return {Capabilities} The capabilities object instance
+    @public
+  */
+  var capabilities = _manager.helperCapabilities;
+  /**
+    Sets the helper manager for an object or function.
+  
+    ```js
+    setHelperManager((owner) => new ClassHelperManager(owner), Helper)
+    ```
+  
+    When a value is used as a helper in a template, the helper manager is looked up
+    on the object by walking up its prototype chain and finding the first helper
+    manager. This manager then receives the value and can create and manage an
+    instance of a helper from it. This provides a layer of indirection that allows
+    users to design high-level helper APIs, without Ember needing to worry about the
+    details. High-level APIs can be experimented with and iterated on while the
+    core of Ember helpers remains stable, and new APIs can be introduced gradually
+    over time to existing code bases.
+  
+    `setHelperManager` receives two arguments:
+  
+    1. A factory function, which receives the `owner` and returns an instance of a
+      helper manager.
+    2. A helper definition, which is the object or function to associate the factory function with.
+  
+    The first time the object is looked up, the factory function will be called to
+    create the helper manager. It will be cached, and in subsequent lookups the
+    cached helper manager will be used instead.
+  
+    Only one helper manager is guaranteed to exist per `owner` and per usage of
+    `setHelperManager`, so many helpers will end up using the same instance of the
+    helper manager. As such, you should only store state that is related to the
+    manager itself. If you want to store state specific to a particular helper
+    definition, you should assign a unique helper manager to that helper. In
+    general, most managers should either be stateless, or only have the `owner` they
+    were created with as state.
+  
+    Helper managers must fulfill the following interface (This example uses
+    [TypeScript interfaces](https://www.typescriptlang.org/docs/handbook/interfaces.html)
+    for precision, you do not need to write helper managers using TypeScript):
+  
+    ```ts
+    interface HelperManager<HelperStateBucket> {
+      capabilities: HelperCapabilities;
+  
+      createHelper(definition: HelperDefinition, args: TemplateArgs): HelperStateBucket;
+  
+      getValue?(bucket: HelperStateBucket): unknown;
+  
+      runEffect?(bucket: HelperStateBucket): void;
+  
+      getDestroyable?(bucket: HelperStateBucket): object;
     }
-  });
-  Object.defineProperty(_exports, "get", {
-    enumerable: true,
-    get: function () {
-      return _runtime.get;
+    ```
+  
+    The capabilities property _must_ be provided using the `capabilities()` function
+    imported from the same module as `setHelperManager`:
+  
+    ```js
+    import { capabilities } from '@ember/helper';
+  
+    class MyHelperManager {
+      capabilities = capabilities('3.21.0', { hasValue: true });
+  
+      // ...snip...
     }
-  });
-  Object.defineProperty(_exports, "hash", {
-    enumerable: true,
-    get: function () {
-      return _runtime.hash;
+    ```
+  
+    Below is a description of each of the methods on the interface and their
+    functions.
+  
+    #### `createHelper`
+  
+    `createHelper` is a required hook on the HelperManager interface. The hook is
+    passed the definition of the helper that is currently being created, and is
+    expected to return a _state bucket_. This state bucket is what represents the
+    current state of the helper, and will be passed to the other lifecycle hooks at
+    appropriate times. It is not necessarily related to the definition of the
+    helper itself - for instance, you could return an object _containing_ an
+    instance of the helper:
+  
+    ```js
+    class MyManager {
+      createHelper(Definition, args) {
+        return {
+          instance: new Definition(args);
+        };
+      }
     }
-  });
-  Object.defineProperty(_exports, "invokeHelper", {
-    enumerable: true,
-    get: function () {
-      return _runtime.invokeHelper;
+    ```
+  
+    This allows the manager to store metadata that it doesn't want to expose to the
+    user.
+  
+    This hook is _not_ autotracked - changes to tracked values used within this hook
+    will _not_ result in a call to any of the other lifecycle hooks. This is because
+    it is unclear what should happen if it invalidates, and rather than make a
+    decision at this point, the initial API is aiming to allow as much expressivity
+    as possible. This could change in the future with changes to capabilities and
+    their behaviors.
+  
+    If users do want to autotrack some values used during construction, they can
+    either create the instance of the helper in `runEffect` or `getValue`, or they
+    can use the `cache` API to autotrack the `createHelper` hook themselves. This
+    provides maximum flexibility and expressiveness to manager authors.
+  
+    This hook has the following timing semantics:
+  
+    **Always**
+    - called as discovered during DOM construction
+    - called in definition order in the template
+  
+    #### `getValue`
+  
+    `getValue` is an optional hook that should return the value of the helper. This
+    is the value that is returned from the helper and passed into the template.
+  
+    This hook is called when the value is requested from the helper (e.g. when the
+    template is rendering and the helper value is needed). The hook is autotracked,
+    and will rerun whenever any tracked values used inside of it are updated.
+    Otherwise it does not rerun.
+  
+    > Note: This means that arguments which are not _consumed_ within the hook will
+    > not trigger updates.
+  
+    This hook is only called for helpers with the `hasValue` capability enabled.
+    This hook has the following timing semantics:
+  
+    **Always**
+    - called the first time the helper value is requested
+    - called after autotracked state has changed
+  
+    **Never**
+    - called if the `hasValue` capability is disabled
+  
+    #### `runEffect`
+  
+    `runEffect` is an optional hook that should run the effect that the helper is
+    applying, setting it up or updating it.
+  
+    This hook is scheduled to be called some time after render and prior to paint.
+    There is not a guaranteed, 1-to-1 relationship between a render pass and this
+    hook firing. For instance, multiple render passes could occur, and the hook may
+    only trigger once. It may also never trigger if it was dirtied in one render
+    pass and then destroyed in the next.
+  
+    The hook is autotracked, and will rerun whenever any tracked values used inside
+    of it are updated. Otherwise it does not rerun.
+  
+    The hook is also run during a time period where state mutations are _disabled_
+    in Ember. Any tracked state mutation will throw an error during this time,
+    including changes to tracked properties, changes made using `Ember.set`, updates
+    to computed properties, etc. This is meant to prevent infinite rerenders and
+    other antipatterns.
+  
+    This hook is only called for helpers with the `hasScheduledEffect` capability
+    enabled. This hook is also not called in SSR currently, though this could be
+    added as a capability in the future. It has the following timing semantics:
+  
+    **Always**
+    - called after the helper was first created, if the helper has not been
+      destroyed since creation
+    - called after autotracked state has changed, if the helper has not been
+      destroyed during render
+  
+    **Never**
+    - called if the `hasScheduledEffect` capability is disabled
+    - called in SSR
+  
+    #### `getDestroyable`
+  
+    `getDestroyable` is an optional hook that users can use to register a
+    destroyable object for the helper. This destroyable will be registered to the
+    containing block or template parent, and will be destroyed when it is destroyed.
+    See the [Destroyables RFC](https://github.com/emberjs/rfcs/blob/master/text/0580-destroyables.md)
+    for more details.
+  
+    `getDestroyable` is only called if the `hasDestroyable` capability is enabled.
+  
+    This hook has the following timing semantics:
+  
+    **Always**
+    - called immediately after the `createHelper` hook is called
+  
+    **Never**
+    - called if the `hasDestroyable` capability is disabled
+  
+    @method setHelperManager
+    @for @ember/helper
+    @static
+    @param {Function} factory A factory function which receives an optional owner, and returns a helper manager
+    @param {object} definition The definition to associate the manager factory with
+    @return {object} The definition passed into setHelperManager
+    @public
+  */
+  _exports.capabilities = capabilities;
+  var setHelperManager = _manager.setHelperManager;
+  /**
+    The `invokeHelper` function can be used to create a helper instance in
+    JavaScript.
+  
+    To access a helper's value you have to use `getValue` from
+    `@glimmer/tracking/primitives/cache`.
+  
+    ```js
+    // app/components/data-loader.js
+    import Component from '@glimmer/component';
+    import { getValue } from '@glimmer/tracking/primitives/cache';
+    import Helper from '@ember/component/helper';
+    import { invokeHelper } from '@ember/helper';
+  
+    class PlusOne extends Helper {
+      compute([number]) {
+        return number + 1;
+      }
     }
-  });
-  Object.defineProperty(_exports, "setHelperManager", {
-    enumerable: true,
-    get: function () {
-      return _manager.setHelperManager;
+  
+    export default class PlusOneComponent extends Component {
+      plusOne = invokeHelper(this, PlusOne, () => {
+        return {
+          positional: [this.args.number],
+        };
+      });
+  
+      get value() {
+        return getValue(this.plusOne);
+      }
     }
-  });
+    ```
+    ```js
+    {{this.value}}
+    ```
+  
+    It receives three arguments:
+  
+    * `context`: The parent context of the helper. When the parent is torn down and
+      removed, the helper will be as well.
+    * `definition`: The definition of the helper.
+    * `computeArgs`: An optional function that produces the arguments to the helper.
+      The function receives the parent context as an argument, and must return an
+      object with a `positional` property that is an array and/or a `named`
+      property that is an object.
+  
+    And it returns a Cache instance that contains the most recent value of the
+    helper. You can access the helper using `getValue()` like any other cache. The
+    cache is also destroyable, and using the `destroy()` function on it will cause
+    the helper to be torn down.
+  
+    Note that using `getValue()` on helpers that have scheduled effects will not
+    trigger the effect early. Effects will continue to run at their scheduled time.
+  
+    @method invokeHelper
+    @for @ember/helper
+    @static
+    @param {object} context The parent context of the helper
+    @param {object} definition The helper definition
+    @param {Function} computeArgs An optional function that produces args
+    @returns
+    @public
+  */
+  _exports.setHelperManager = setHelperManager;
+  var invokeHelper = _runtime.invokeHelper;
+  // SAFETY: we need to provide interfaces that Glint can declaration-merge with
+  // to provide appropriate completions. In each case, the imported item is
+  // currently typed only as `object`, and we are replacing it with a similarly
+  // low-information interface type: these are empty objects which are simply able
+  // to be distinguished so that Glint can provide the relevant extensions.
+  /* eslint-disable @typescript-eslint/no-empty-interface */
+  /**
+   * Using the `{{hash}}` helper, you can pass objects directly from the template
+   * 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).
+   */
+  _exports.invokeHelper = invokeHelper;
+  var hash = _runtime.hash;
+  /**
+   * Using the `{{array}}` helper, you can pass arrays directly from the template
+   * as an argument to your components.
+   *
+   * ```js
+   * import { array } from '@ember/helper';
+   *
+   * <template>
+   *   <ul>
+   *   {{#each (array 'Tom Dale' 'Yehuda Katz' @anotherPerson) as |person|}}
+   *     <li>{{person}}</li>
+   *   {{/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).
+   * ```
+   */
+  _exports.hash = hash;
+  var array = _runtime.array;
+  /**
+   * The `{{concat}}` helper makes it easy to dynamically send a number of
+   * parameters to a component or helper as a single parameter in the format of a
+   * concatenated string.
+   *
+   * For example:
+   *
+   * ```js
+   * import { concat } from '@ember/helper';
+   *
+   * <template>
+   *   {{get @foo (concat "item" @index)}}
+   * </template>
+   * ```
+   *
+   * 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).
+   */
+  _exports.array = array;
+  var concat = _runtime.concat;
+  /**
+   * The `{{get}}` helper makes it easy to dynamically look up a property on an
+   * object or an element in an array. The second argument to `{{get}}` can be a
+   * string or a number, depending on the object being accessed.
+   *
+   * To access a property on an object with a string key:
+   *
+   * ```js
+   * import { get } from '@ember/helper';
+   *
+   * <template>
+   *   {{get @someObject "objectKey"}}
+   * </template>
+   * ```
+   *
+   * To access the first element in an array:
+   *
+   * ```js
+   * import { get } from '@ember/helper';
+   *
+   * <template>
+   *   {{get @someArray 0}}
+   * </template>
+   * ```
+   *
+   * To access a property on an object with a dynamic key:
+   *
+   * ```js
+   * import { get } from '@ember/helper';
+   *
+   * <template>
+   *   {{get @address @field}}
+   * </template>
+   * ```
+   *
+   * 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).
+   */
+  _exports.concat = concat;
+  var get = _runtime.get;
+  /**
+   * `{{fn}}` is a helper that receives a function and some arguments, and returns
+   * a new function that combines. This allows you to pass parameters along to
+   * functions in your templates:
+   *
+   * ```js
+   * import { fn } from '@ember/helper';
+   *
+   * function showAlert(message) {
+   *   alert(`The message is: '${message}'`);
+   * }
+   *
+   * <template>
+   *   <button type="button" {{on "click" (fn showAlert "Hello!")}}>
+   *     Click me!
+   *   </button>
+   * </template>
+   * ```
+   */
+  _exports.get = get;
+  var fn = _runtime.fn;
+  /* eslint-enable @typescript-eslint/no-empty-interface */
+  _exports.fn = fn;
 });
 define("@ember/instrumentation/index", ["exports", "@ember/-internals/environment", "@ember/debug"], function (_exports, _environment, _debug) {
   "use strict";
@@ -16980,7 +17277,7 @@ define("@ember/instrumentation/index", ["exports", "@ember/-internals/environmen
     cache = {};
   }
 });
-define("@ember/modifier/index", ["exports", "@glimmer/manager", "@ember/-internals/glimmer", "@glimmer/runtime"], function (_exports, _manager, _glimmer, _runtime) {
+define("@ember/modifier/index", ["exports", "@glimmer/runtime", "@glimmer/manager", "@ember/-internals/glimmer"], function (_exports, _runtime, _manager, _glimmer) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -16992,18 +17289,17 @@ define("@ember/modifier/index", ["exports", "@glimmer/manager", "@ember/-interna
       return _glimmer.modifierCapabilities;
     }
   });
-  Object.defineProperty(_exports, "on", {
-    enumerable: true,
-    get: function () {
-      return _runtime.on;
-    }
-  });
-  Object.defineProperty(_exports, "setModifierManager", {
-    enumerable: true,
-    get: function () {
-      return _manager.setModifierManager;
-    }
-  });
+  _exports.setModifierManager = _exports.on = void 0;
+  // SAFETY: at the time of writing, the cast here is from `{}` to `OnModifier`,
+  // which makes it strictly safer to use outside this module because it is not
+  // usable as "any non-null item", which is what `{}` means, without loss of any
+  // information from the type itself.
+  var on = _runtime.on;
+  // NOTE: this uses assignment to *require* that the `glimmerSetModifierManager`
+  // is legally assignable to this type, i.e. that variance is properly upheld.
+  _exports.on = on;
+  var setModifierManager = _manager.setModifierManager;
+  _exports.setModifierManager = setModifierManager;
 });
 define("@ember/object/-internals", ["exports", "@ember/-internals/metal", "@ember/-internals/utils", "@ember/debug", "@ember/object"], function (_exports, _metal, _utils, _debug, _object) {
   "use strict";
@@ -17353,6 +17649,9 @@ define("@ember/object/core", ["exports", "@ember/-internals/container", "@ember/
       var mergedProperties = obj.mergedProperties;
       var keyNames = Object.keys(properties);
       for (var keyName of keyNames) {
+        // SAFETY: this cast as a Record is safe because all object types can be
+        // indexed in JS, and we explicitly type it as returning `unknown`, so the
+        // result *must* be checked below.
         var value = properties[keyName];
         (true && !(!(0, _metal.isClassicDecorator)(value)) && (0, _debug.assert)('EmberObject.create no longer supports defining computed ' + 'properties. Define computed properties using extend() or reopen() ' + 'before calling create().', !(0, _metal.isClassicDecorator)(value)));
         (true && !(!(typeof value === 'function' && value.toString().indexOf('._super') !== -1)) && (0, _debug.assert)('EmberObject.create no longer supports defining methods that call _super.', !(typeof value === 'function' && value.toString().indexOf('._super') !== -1)));
@@ -17691,6 +17990,38 @@ define("@ember/object/core", ["exports", "@ember/-internals/container", "@ember/
       reopen.apply(Class.PrototypeMixin, mixins);
       return Class;
     }
+    /**
+      Creates an instance of a class. Accepts either no arguments, or an object
+      containing values to initialize the newly instantiated object with.
+         ```javascript
+      import EmberObject from '@ember/object';
+         const Person = EmberObject.extend({
+        helloWorld() {
+          alert(`Hi, my name is ${this.get('name')}`);
+        }
+      });
+         let tom = Person.create({
+        name: 'Tom Dale'
+      });
+         tom.helloWorld(); // alerts "Hi, my name is Tom Dale".
+      ```
+         `create` will call the `init` function if defined during
+      `AnyObject.extend`
+         If no arguments are passed to `create`, it will not set values to the new
+      instance during initialization:
+         ```javascript
+      let noName = Person.create();
+      noName.helloWorld(); // alerts undefined
+      ```
+         NOTE: For performance reasons, you cannot declare methods or computed
+      properties during `create`. You should instead declare methods and computed
+      properties when using `extend`.
+         @method create
+      @for @ember/object
+      @static
+      @param [arguments]*
+      @public
+    */
     static create() {
       for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
         args[_key3] = arguments[_key3];
@@ -17718,6 +18049,8 @@ define("@ember/object/core", ["exports", "@ember/-internals/container", "@ember/
       } else {
         initialize(instance, flattenProps.apply(this, args));
       }
+      // SAFETY: The `initialize` call is responsible to merge the prototype chain
+      // so that this holds.
       return instance;
     }
     /**
@@ -20334,7 +20667,7 @@ define("@ember/object/mixin", ["exports", "@ember/-internals/container", "@ember
         args[_key3] = arguments[_key3];
       }
       if (args.length === 0) {
-        return;
+        return this;
       }
       if (this.properties) {
         var currentMixin = new Mixin(undefined, this.properties);
@@ -20684,6 +21017,7 @@ define("@ember/object/proxy", ["exports", "@ember/object/-internals", "@ember/-i
   @module @ember/object/proxy
   */
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   class ObjectProxy extends _internals.FrameworkObject {}
   ObjectProxy.PrototypeMixin.reopen(_runtime._ProxyMixin);
   var _default = ObjectProxy;
@@ -21908,7 +22242,6 @@ define("@ember/routing/lib/utils", ["exports", "@ember/-internals/metal", "@embe
       }
       _routeInfo['_names'] = names;
       var route = _routeInfo.route;
-      // SAFETY: This cast should be idential. I don't understand why it is needed.
       route._stashNames(_routeInfo, dynamicParent);
     }
     routeInfos['_namesStashed'] = true;
@@ -22225,6 +22558,11 @@ define("@ember/routing/route", ["exports", "@ember/-internals/container", "@embe
   class Route extends _object.default.extend(_runtime.ActionHandler, _evented.default) {
     constructor(owner) {
       super(owner);
+      // These properties will end up appearing in the public interface because we
+      // `implements IRoute` from `router.js`, which has them as part of *its*
+      // public contract. We mark them as `@internal` so they at least signal to
+      // people subclassing `Route` that they should not use them.
+      /** @internal */
       this.context = {};
       if (owner) {
         var router = owner.lookup('router:main');
@@ -22474,6 +22812,9 @@ define("@ember/routing/route", ["exports", "@ember/-internals/container", "@embe
       @public
     */
     resetController(_controller, _isExiting, _transition) {
+      // We document that subclasses do not have to return *anything* and in fact
+      // do not even have to call super, so whiel we *do* return `this`, we need
+      // to be explicit in the types that our return type is *effectively* `void`.
       return this;
     }
     /**
@@ -23972,7 +24313,6 @@ define("@ember/routing/router-service", ["exports", "@ember/-internals/owner", "
       var owner = (0, _owner.getOwner)(this);
       (true && !(owner) && (0, _debug.assert)('RouterService is unexpectedly missing an owner', owner));
       var pivotRoute = owner.lookup(`route:${pivotRouteName}`);
-      // @ts-expect-error R could be instantiated with a different sub-type
       return this._router._routerMicrolib.refresh(pivotRoute);
     }
   }
@@ -25367,7 +25707,14 @@ define("@ember/routing/transition", ["exports"], function (_exports) {
     value: true
   });
 });
-define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/error-handling", "@ember/-internals/metal", "backburner"], function (_exports, _debug, _errorHandling, _metal, _backburner2) {
+define("@ember/runloop/-private/backburner", ["exports"], function (_exports) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+});
+define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/error-handling", "@ember/-internals/metal", "backburner.js"], function (_exports, _debug, _errorHandling, _metal, _backburner2) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -25428,6 +25775,10 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
   // used to re-throw unhandled RSVP rejection errors specifically in this
   // position to avoid breaking anything rendered in the other sections
   _rsvpErrorQueue];
+  /**
+   * @internal
+   * @private
+   */
   _exports._queues = _queues;
   var _backburner = new _backburner2.default(_queues, {
     defaultQueue: 'actions',
@@ -25625,7 +25976,7 @@ define("@ember/runloop/index", ["exports", "@ember/debug", "@ember/-internals/er
     @method cancel
     @static
     @for @ember/runloop
-    @param {Object} timer Timer object to cancel
+    @param {Object} [timer] Timer object to cancel
     @return {Boolean} true if canceled or false/undefined if it wasn't found
     @public
   */
@@ -25753,9 +26104,11 @@ define("@ember/test/index", ["exports", "require"], function (_exports, _require
   var unregisterWaiter;
   _exports.unregisterWaiter = unregisterWaiter;
   if ((0, _require.has)('ember-testing')) {
-    var {
-      Test
-    } = (0, _require.default)("ember-testing");
+    // SAFETY: since `require` is opaque to TS, we need to inform it that this is
+    // the actual type of what we import. This `require` needs to stay in sync
+    // with the `import type` statement above. (This cast *increases* safety,
+    // because the result of `require` is `any`.)
+    var Test = (0, _require.default)("ember-testing").Test;
     _exports.registerAsyncHelper = registerAsyncHelper = Test.registerAsyncHelper;
     _exports.registerHelper = registerHelper = Test.registerHelper;
     _exports.registerWaiter = registerWaiter = Test.registerWaiter;
@@ -39338,7 +39691,7 @@ define("@simple-dom/document", ["exports"], function (_exports) {
   var _default = createHTMLDocument;
   _exports.default = _default;
 });
-define("backburner", ["exports"], function (_exports) {
+define("backburner.js", ["exports"], function (_exports) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -41921,7 +42274,7 @@ define("ember-testing/lib/test/waiters", ["exports"], function (_exports) {
     return -1;
   }
 });
-define("ember/index", ["exports", "require", "@ember/-internals/environment", "@ember/-internals/utils", "@ember/-internals/container", "@ember/instrumentation", "@ember/-internals/meta", "@ember/-internals/metal", "@ember/canary-features", "@ember/debug", "backburner", "@ember/controller", "@ember/service", "@ember/object", "@ember/object/-internals", "@ember/object/compat", "@ember/object/computed", "@ember/object/events", "@ember/-internals/runtime", "@ember/-internals/glimmer", "ember/version", "@ember/-internals/views", "@ember/debug/container-debug-adapter", "@ember/debug/data-adapter", "@ember/runloop", "@ember/-internals/error-handling", "@ember/array", "@ember/array/mutable", "@ember/array/proxy", "@ember/application", "@ember/application/instance", "@ember/application/namespace", "@ember/component", "@ember/component/helper", "@ember/engine", "@ember/engine/instance", "@ember/enumerable", "@ember/enumerable/mutable", "@ember/object/core", "@ember/object/evented", "@ember/object/mixin", "@ember/object/observable", "@ember/object/observers", "@ember/object/proxy", "@ember/object/promise-proxy-mixin", "@ember/routing/hash-location", "@ember/routing/history-location", "@ember/routing/none-location", "@ember/routing/route", "@ember/routing/router", "@ember/routing/-internals", "@ember/utils", "@glimmer/runtime", "@glimmer/manager", "@ember/destroyable"], function (_exports, _require, _environment, utils, _container, instrumentation, _meta, metal, _canaryFeatures, EmberDebug, _backburner, _controller, _service, _object, _internals, _compat, _computed, _events, _runtime, _glimmer, _version, views, _containerDebugAdapter, _dataAdapter, _runloop, _errorHandling, _array, _mutable, _proxy, _application, _instance, _namespace, _component, _helper, _engine, _instance2, _enumerable, _mutable2, _core, _evented, _mixin, _observable, _observers, _proxy2, _promiseProxyMixin, _hashLocation, _historyLocation, _noneLocation, _route, _router, _internals2, _utils2, glimmerRuntime, _manager, _destroyable) {
+define("ember/index", ["exports", "require", "@ember/-internals/environment", "@ember/-internals/utils", "@ember/-internals/container", "@ember/instrumentation", "@ember/-internals/meta", "@ember/-internals/metal", "@ember/canary-features", "@ember/debug", "backburner.js", "@ember/controller", "@ember/service", "@ember/object", "@ember/object/-internals", "@ember/object/compat", "@ember/object/computed", "@ember/object/events", "@ember/-internals/runtime", "@ember/-internals/glimmer", "ember/version", "@ember/-internals/views", "@ember/debug/container-debug-adapter", "@ember/debug/data-adapter", "@ember/runloop", "@ember/-internals/error-handling", "@ember/array", "@ember/array/mutable", "@ember/array/proxy", "@ember/application", "@ember/application/instance", "@ember/application/namespace", "@ember/component", "@ember/component/helper", "@ember/engine", "@ember/engine/instance", "@ember/enumerable", "@ember/enumerable/mutable", "@ember/object/core", "@ember/object/evented", "@ember/object/mixin", "@ember/object/observable", "@ember/object/observers", "@ember/object/proxy", "@ember/object/promise-proxy-mixin", "@ember/routing/hash-location", "@ember/routing/history-location", "@ember/routing/none-location", "@ember/routing/route", "@ember/routing/router", "@ember/routing/-internals", "@ember/utils", "@glimmer/runtime", "@glimmer/manager", "@ember/destroyable"], function (_exports, _require, _environment, utils, _container, instrumentation, _meta, metal, _canaryFeatures, EmberDebug, _backburner, _controller, _service, _object, _internals, _compat, _computed, _events, _runtime, _glimmer, _version, views, _containerDebugAdapter, _dataAdapter, _runloop, _errorHandling, _array, _mutable, _proxy, _application, _instance, _namespace, _component, _helper, _engine, _instance2, _enumerable, _mutable2, _core, _evented, _mixin, _observable, _observers, _proxy2, _promiseProxyMixin, _hashLocation, _historyLocation, _noneLocation, _route, _router, _internals2, _utils2, glimmerRuntime, _manager, _destroyable) {
   "use strict";
 
   Object.defineProperty(_exports, "__esModule", {
@@ -41932,212 +42285,207 @@ define("ember/index", ["exports", "require", "@ember/-internals/environment", "@
   @module ember
   */
 
-  /**
-    Namespace for injection helper methods.
-  
-    @class inject
-    @namespace Ember
-    @static
-    @public
-  */
-  function inject() {
-    (true && !(false) && (0, EmberDebug.assert)(`Injected properties must be created through helpers, see '${Object.keys(inject).map(k => `'inject.${k}'`).join(' or ')}'`));
-  }
-  // ****@ember/controller****
-  inject.controller = _controller.inject;
-  // ****@ember/service****
-  inject.service = _service.service;
-  var PartialEmber = {
-    isNamespace: true,
-    toString() {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  var Ember;
+  (function (Ember) {
+    Ember.isNamespace = true;
+    function toString() {
       return 'Ember';
-    },
+    }
+    Ember.toString = toString;
     // ****@ember/-internals/container****
-    Container: _container.Container,
-    Registry: _container.Registry,
+    Ember.Container = _container.Container;
+    Ember.Registry = _container.Registry;
     // ****@ember/-internals/glimmer****
     // Partially re-exported from @glimmer/manager
-    _setComponentManager: _glimmer.setComponentManager,
-    _componentManagerCapabilities: _glimmer.componentCapabilities,
-    _modifierManagerCapabilities: _glimmer.modifierCapabilities,
+    Ember._setComponentManager = _glimmer.setComponentManager;
+    Ember._componentManagerCapabilities = _glimmer.componentCapabilities;
+    Ember._modifierManagerCapabilities = _glimmer.modifierCapabilities;
     // ****@ember/-internals/meta****
-    meta: _meta.meta,
+    Ember.meta = _meta.meta;
     // ****@ember/-internals/metal****
-    _createCache: metal.createCache,
-    _cacheGetValue: metal.getValue,
-    _cacheIsConst: metal.isConst,
-    _descriptor: metal.nativeDescDecorator,
-    _getPath: metal._getPath,
-    _setClassicDecorator: metal.setClassicDecorator,
-    _tracked: metal.tracked,
-    beginPropertyChanges: metal.beginPropertyChanges,
-    changeProperties: metal.changeProperties,
-    endPropertyChanges: metal.endPropertyChanges,
-    hasListeners: metal.hasListeners,
-    libraries: metal.libraries,
+    Ember._createCache = metal.createCache; // Also @glimmer/validator
+    Ember._cacheGetValue = metal.getValue; // Also @glimmer/validator
+    Ember._cacheIsConst = metal.isConst; // Also @glimmer/validator
+    Ember._descriptor = metal.nativeDescDecorator;
+    Ember._getPath = metal._getPath;
+    Ember._setClassicDecorator = metal.setClassicDecorator;
+    Ember._tracked = metal.tracked; // Also exported from @glimmer/tracking
+    Ember.beginPropertyChanges = metal.beginPropertyChanges;
+    Ember.changeProperties = metal.changeProperties;
+    Ember.endPropertyChanges = metal.endPropertyChanges;
+    Ember.hasListeners = metal.hasListeners;
+    Ember.libraries = metal.libraries;
     // ****@ember/-internals/runtime****
-    _ContainerProxyMixin: _runtime.ContainerProxyMixin,
-    _ProxyMixin: _runtime._ProxyMixin,
-    _RegistryProxyMixin: _runtime.RegistryProxyMixin,
-    ActionHandler: _runtime.ActionHandler,
-    Comparable: _runtime.Comparable,
-    RSVP: _runtime.RSVP,
+    Ember._ContainerProxyMixin = _runtime.ContainerProxyMixin;
+    Ember._ProxyMixin = _runtime._ProxyMixin;
+    Ember._RegistryProxyMixin = _runtime.RegistryProxyMixin;
+    Ember.ActionHandler = _runtime.ActionHandler;
+    Ember.Comparable = _runtime.Comparable;
+    // This syntax is namespace-specific: `import` in a namespace is aliasing one
+    // namespace to another, while `export` marks the item public on the namespace
+    // (as with the rest of the exported items).
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    Ember.RSVP = _runtime.RSVP;
     // ****@ember/-internals/view****
-    ComponentLookup: views.ComponentLookup,
-    EventDispatcher: views.EventDispatcher,
+    Ember.ComponentLookup = views.ComponentLookup;
+    Ember.EventDispatcher = views.EventDispatcher;
     // ****@ember/-internals/utils****
-    _Cache: utils.Cache,
-    GUID_KEY: utils.GUID_KEY,
-    canInvoke: utils.canInvoke,
-    generateGuid: utils.generateGuid,
-    guidFor: utils.guidFor,
-    uuid: utils.uuid,
-    wrap: utils.wrap,
+    Ember._Cache = utils.Cache;
+    Ember.GUID_KEY = utils.GUID_KEY;
+    Ember.canInvoke = utils.canInvoke;
+    Ember.generateGuid = utils.generateGuid;
+    Ember.guidFor = utils.guidFor;
+    Ember.uuid = utils.uuid;
+    Ember.wrap = utils.wrap;
     // ****@ember/application****
-    getOwner: _application.getOwner,
-    onLoad: _application.onLoad,
-    runLoadHooks: _application.runLoadHooks,
-    setOwner: _application.setOwner,
-    Application: _application.default,
+    Ember.getOwner = _application.getOwner;
+    Ember.onLoad = _application.onLoad;
+    Ember.runLoadHooks = _application.runLoadHooks;
+    Ember.setOwner = _application.setOwner;
+    Ember.Application = _application.default;
     // ****@ember/application/instance****
-    ApplicationInstance: _instance.default,
-    // ****@ember/application/namespace****
-    Namespace: _namespace.default,
+    Ember.ApplicationInstance = _instance.default;
+    // // ****@ember/application/namespace****
+    Ember.Namespace = _namespace.default;
     // ****@ember/array****
-    A: _array.A,
-    Array: _array.default,
-    NativeArray: _array.NativeArray,
-    isArray: _array.isArray,
-    makeArray: _array.makeArray,
+    Ember.A = _array.A;
+    Ember.Array = _array.default;
+    Ember.NativeArray = _array.NativeArray;
+    Ember.isArray = _array.isArray;
+    Ember.makeArray = _array.makeArray;
     // ****@ember/array/mutable****
-    MutableArray: _mutable.default,
+    Ember.MutableArray = _mutable.default;
     // ****@ember/array/proxy****
-    ArrayProxy: _proxy.default,
+    Ember.ArrayProxy = _proxy.default;
     // ****@ember/canary-features****
-    FEATURES: {
+    Ember.FEATURES = {
       isEnabled: _canaryFeatures.isEnabled,
       ..._canaryFeatures.FEATURES
-    },
+    };
     // ****@ember/component****
-    _Input: _component.Input,
-    Component: _component.default,
-    // ****@ember/component/helper****
-    Helper: _helper.default,
+    Ember._Input = _component.Input;
+    Ember.Component = _component.default;
+    // // ****@ember/component/helper****
+    Ember.Helper = _helper.default;
     // ****@ember/controller****
-    Controller: _controller.default,
-    ControllerMixin: _controller.ControllerMixin,
+    Ember.Controller = _controller.default;
+    Ember.ControllerMixin = _controller.ControllerMixin;
     // ****@ember/debug****
-    _captureRenderTree: EmberDebug.captureRenderTree,
-    assert: EmberDebug.assert,
-    warn: EmberDebug.warn,
-    debug: EmberDebug.debug,
-    deprecate: EmberDebug.deprecate,
-    deprecateFunc: EmberDebug.deprecateFunc,
-    runInDebug: EmberDebug.runInDebug,
-    inspect: EmberDebug.inspect,
-    Debug: {
+    Ember._captureRenderTree = EmberDebug.captureRenderTree;
+    Ember.assert = EmberDebug.assert;
+    Ember.warn = EmberDebug.warn;
+    Ember.debug = EmberDebug.debug;
+    Ember.deprecate = EmberDebug.deprecate;
+    Ember.deprecateFunc = EmberDebug.deprecateFunc;
+    Ember.runInDebug = EmberDebug.runInDebug;
+    Ember.inspect = EmberDebug.inspect;
+    Ember.Debug = {
       registerDeprecationHandler: EmberDebug.registerDeprecationHandler,
       registerWarnHandler: EmberDebug.registerWarnHandler,
       // ****@ember/-internals/metal****
       isComputed: metal.isComputed
-    },
+    };
     // ****@ember/debug/container-debug-adapter****
-    ContainerDebugAdapter: _containerDebugAdapter.default,
+    Ember.ContainerDebugAdapter = _containerDebugAdapter.default;
     // ****@ember/debug/data-adapter****
-    DataAdapter: _dataAdapter.default,
+    Ember.DataAdapter = _dataAdapter.default;
     // ****@ember/destroyable****
-    _assertDestroyablesDestroyed: _destroyable.assertDestroyablesDestroyed,
-    _associateDestroyableChild: _destroyable.associateDestroyableChild,
-    _enableDestroyableTracking: _destroyable.enableDestroyableTracking,
-    _isDestroying: _destroyable.isDestroying,
-    _isDestroyed: _destroyable.isDestroyed,
-    _registerDestructor: _destroyable.registerDestructor,
-    _unregisterDestructor: _destroyable.unregisterDestructor,
-    destroy: _destroyable.destroy,
+    Ember._assertDestroyablesDestroyed = _destroyable.assertDestroyablesDestroyed;
+    Ember._associateDestroyableChild = _destroyable.associateDestroyableChild;
+    Ember._enableDestroyableTracking = _destroyable.enableDestroyableTracking;
+    Ember._isDestroying = _destroyable.isDestroying;
+    Ember._isDestroyed = _destroyable.isDestroyed;
+    Ember._registerDestructor = _destroyable.registerDestructor;
+    Ember._unregisterDestructor = _destroyable.unregisterDestructor;
+    Ember.destroy = _destroyable.destroy;
     // ****@ember/engine****
-    Engine: _engine.default,
+    Ember.Engine = _engine.default;
     // ****@ember/engine/instance****
-    EngineInstance: _instance2.default,
+    Ember.EngineInstance = _instance2.default;
     // ****@ember/enumerable****
-    Enumerable: _enumerable.default,
+    Ember.Enumerable = _enumerable.default;
     // ****@ember/enumerable/mutable****
-    MutableEnumerable: _mutable2.default,
+    Ember.MutableEnumerable = _mutable2.default;
     // ****@ember/instrumentation****
-    instrument: instrumentation.instrument,
-    subscribe: instrumentation.subscribe,
-    Instrumentation: {
+    /** @private */
+    Ember.instrument = instrumentation.instrument;
+    /** @private */
+    Ember.subscribe = instrumentation.subscribe;
+    /** @private */
+    Ember.Instrumentation = {
       instrument: instrumentation.instrument,
       subscribe: instrumentation.subscribe,
       unsubscribe: instrumentation.unsubscribe,
       reset: instrumentation.reset
-    },
+    };
     // ****@ember/object****
-    Object: _object.default,
-    _action: _object.action,
-    computed: _object.computed,
-    defineProperty: _object.defineProperty,
-    get: _object.get,
-    getProperties: _object.getProperties,
-    notifyPropertyChange: _object.notifyPropertyChange,
-    observer: _object.observer,
-    set: _object.set,
-    trySet: _object.trySet,
-    setProperties: _object.setProperties,
+    Ember.Object = _object.default;
+    Ember._action = _object.action;
+    Ember.computed = _object.computed;
+    Ember.defineProperty = _object.defineProperty;
+    Ember.get = _object.get;
+    Ember.getProperties = _object.getProperties;
+    Ember.notifyPropertyChange = _object.notifyPropertyChange;
+    Ember.observer = _object.observer;
+    Ember.set = _object.set;
+    Ember.trySet = _object.trySet;
+    Ember.setProperties = _object.setProperties;
     // ****@ember/object/-internals****
-    cacheFor: _internals.cacheFor,
+    Ember.cacheFor = _internals.cacheFor;
     // ****@ember/object/compat****
-    _dependentKeyCompat: _compat.dependentKeyCompat,
+    Ember._dependentKeyCompat = _compat.dependentKeyCompat;
     // ****@ember/object/computed****
-    ComputedProperty: _computed.default,
-    expandProperties: _computed.expandProperties,
+    Ember.ComputedProperty = _computed.default;
+    Ember.expandProperties = _computed.expandProperties;
     // ****@ember/object/core****
-    CoreObject: _core.default,
+    Ember.CoreObject = _core.default;
     // ****@ember/object/evented****
-    Evented: _evented.default,
-    on: _evented.on,
+    Ember.Evented = _evented.default;
+    Ember.on = _evented.on;
     // ****@ember/object/events****
-    addListener: _events.addListener,
-    removeListener: _events.removeListener,
-    sendEvent: _events.sendEvent,
+    Ember.addListener = _events.addListener;
+    Ember.removeListener = _events.removeListener;
+    Ember.sendEvent = _events.sendEvent;
     // ****@ember/object/mixin****
-    Mixin: _mixin.default,
-    mixin: _mixin.mixin,
+    Ember.Mixin = _mixin.default;
+    Ember.mixin = _mixin.mixin;
     // ****@ember/object/observable****
-    Observable: _observable.default,
+    Ember.Observable = _observable.default;
     // ****@ember/object/observers****
-    addObserver: _observers.addObserver,
-    removeObserver: _observers.removeObserver,
+    Ember.addObserver = _observers.addObserver;
+    Ember.removeObserver = _observers.removeObserver;
     // ****@ember/object/promise-proxy-mixin****
-    PromiseProxyMixin: _promiseProxyMixin.default,
+    Ember.PromiseProxyMixin = _promiseProxyMixin.default;
     // ****@ember/object/proxy****
-    ObjectProxy: _proxy2.default,
+    Ember.ObjectProxy = _proxy2.default;
     // ****@ember/routing/-internals****
-    RouterDSL: _internals2.DSL,
-    controllerFor: _internals2.controllerFor,
-    generateController: _internals2.generateController,
-    generateControllerFactory: _internals2.generateControllerFactory,
+    Ember.RouterDSL = _internals2.DSL;
+    Ember.controllerFor = _internals2.controllerFor;
+    Ember.generateController = _internals2.generateController;
+    Ember.generateControllerFactory = _internals2.generateControllerFactory;
     // ****@ember/routing/hash-location****
-    HashLocation: _hashLocation.default,
+    Ember.HashLocation = _hashLocation.default;
     // ****@ember/routing/history-location****
-    HistoryLocation: _historyLocation.default,
+    Ember.HistoryLocation = _historyLocation.default;
     // ****@ember/routing/none-location****
-    NoneLocation: _noneLocation.default,
+    Ember.NoneLocation = _noneLocation.default;
     // ****@ember/routing/route****
-    Route: _route.default,
+    Ember.Route = _route.default;
     // ****@ember/routing/router****
-    Router: _router.default,
-    // ****@ember/runloop****
-    run: _runloop.run,
-    // ****@ember/service****
-    Service: _service.default,
+    Ember.Router = _router.default;
+    // // ****@ember/runloop****
+    Ember.run = _runloop.run;
+    // // ****@ember/service****
+    Ember.Service = _service.default;
     // ****@ember/utils****
-    compare: _utils2.compare,
-    isBlank: _utils2.isBlank,
-    isEmpty: _utils2.isEmpty,
-    isEqual: _utils2.isEqual,
-    isNone: _utils2.isNone,
-    isPresent: _utils2.isPresent,
-    typeOf: _utils2.typeOf,
+    Ember.compare = _utils2.compare;
+    Ember.isBlank = _utils2.isBlank;
+    Ember.isEmpty = _utils2.isEmpty;
+    Ember.isEqual = _utils2.isEqual;
+    Ember.isNone = _utils2.isNone;
+    Ember.isPresent = _utils2.isPresent;
+    Ember.typeOf = _utils2.typeOf;
     // ****@ember/version****
     /**
       The semantic version
@@ -42145,8 +42493,8 @@ define("ember/index", ["exports", "require", "@ember/-internals/environment", "@
       @type String
       @public
     */
-    VERSION: _version.default,
-    ViewUtils: {
+    Ember.VERSION = _version.default;
+    Ember.ViewUtils = {
       // ****@ember/-internals/views****
       getChildViews: views.getChildViews,
       getElementView: views.getElementView,
@@ -42158,34 +42506,48 @@ define("ember/index", ["exports", "require", "@ember/-internals/environment", "@
       isSimpleClick: views.isSimpleClick,
       // ****@ember/-internals/glimmer****
       isSerializationFirstNode: _glimmer.isSerializationFirstNode
-    },
+    };
     // ****@glimmer/manager****
-    _getComponentTemplate: _manager.getComponentTemplate,
-    _helperManagerCapabilities: _manager.helperCapabilities,
-    _setComponentTemplate: _manager.setComponentTemplate,
-    _setHelperManager: _manager.setHelperManager,
-    _setModifierManager: _manager.setModifierManager,
+    Ember._getComponentTemplate = _manager.getComponentTemplate;
+    Ember._helperManagerCapabilities = _manager.helperCapabilities;
+    Ember._setComponentTemplate = _manager.setComponentTemplate;
+    Ember._setHelperManager = _manager.setHelperManager;
+    Ember._setModifierManager = _manager.setModifierManager;
     // ****@glimmer/runtime****
-    _templateOnlyComponent: glimmerRuntime.templateOnlyComponent,
-    _invokeHelper: glimmerRuntime.invokeHelper,
-    _hash: glimmerRuntime.hash,
-    _array: glimmerRuntime.array,
-    _concat: glimmerRuntime.concat,
-    _get: glimmerRuntime.get,
-    _on: glimmerRuntime.on,
-    _fn: glimmerRuntime.fn,
+    Ember._templateOnlyComponent = glimmerRuntime.templateOnlyComponent;
+    Ember._invokeHelper = glimmerRuntime.invokeHelper;
+    Ember._hash = glimmerRuntime.hash;
+    Ember._array = glimmerRuntime.array;
+    Ember._concat = glimmerRuntime.concat;
+    Ember._get = glimmerRuntime.get;
+    Ember._on = glimmerRuntime.on;
+    Ember._fn = glimmerRuntime.fn;
     // Backburner
-    _Backburner: _backburner.default,
-    // ****@ember/controller, @ember/service****
-    inject,
-    __loader: {
+    Ember._Backburner = _backburner.default;
+    // // ****@ember/controller, @ember/service****
+    /**
+      Namespace for injection helper methods.
+         @class inject
+      @namespace Ember
+      @static
+      @public
+    */
+    function inject() {
+      // uses `globalThis` to avoid clobbering with `Ember.Object` in TS namespace
+      (true && !(false) && (0, EmberDebug.assert)(`Injected properties must be created through helpers, see '${globalThis.Object.keys(inject).map(k => `'inject.${k}'`).join(' or ')}'`));
+    }
+    Ember.inject = inject;
+    // ****@ember/controller****
+    inject.controller = _controller.inject;
+    // ****@ember/service****
+    inject.service = _service.service;
+    Ember.__loader = {
       require: _require.default,
       define,
       // @ts-expect-error These properties don't appear as being defined
       registry: typeof requirejs !== 'undefined' ? requirejs.entries : _require.default.entries
-    }
-  };
-  var Ember = PartialEmber;
+    };
+  })(Ember || (Ember = {}));
   Object.defineProperty(Ember, 'ENV', {
     get: _environment.getENV,
     enumerable: false
@@ -42318,7 +42680,7 @@ define("ember/version", ["exports"], function (_exports) {
     value: true
   });
   _exports.default = void 0;
-  var _default = "5.0.0";
+  var _default = "5.1.0-alpha.2";
   _exports.default = _default;
 });
 define("route-recognizer", ["exports"], function (_exports) {