ember-source 5.11.0 → 5.11.1

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

@@ -1,37 +1,41 @@
 export { getEngineParent, setEngineParent } from './lib/engine-parent.js';
-import '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
-import '@embroider/macros';
-import '../../shared-chunks/invoke-BjRgvK2V.js';
-import '../controller/index.js';
-import '../application/namespace.js';
-import '../../shared-chunks/registry-DzfcDwii.js';
-import '../../dag-map/index.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
-import '../debug/container-debug-adapter.js';
-import '../../shared-chunks/index-PYiGj1jp.js';
-export { g as buildInitializerMethod, E as default } from '../../shared-chunks/index-BXPoca1S.js';
+import '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
+import { isDevelopingApp } from '@embroider/macros';
+import { c as canInvoke } from '../../shared-chunks/invoke-BjRgvK2V.js';
+import Controller from '../controller/index.js';
+import Namespace from '../application/namespace.js';
+import { R as Registry } from '../../shared-chunks/registry-B8WARvkP.js';
+import DAG from '../../dag-map/index.js';
+import '../debug/index.js';
+import ContainerDebugAdapter from '../debug/container-debug-adapter.js';
+import '../object/index.js';
+import EngineInstance from './instance.js';
 import '../-internals/meta/lib/meta.js';
 import '../../@glimmer/destroyable/index.js';
 import '../../@glimmer/validator/index.js';
-import '../../shared-chunks/cache-gDE3bkXq.js';
 import '../../@glimmer/manager/index.js';
-import '../../shared-chunks/property_set-CW4q-uo4.js';
+import { g as get } from '../../shared-chunks/cache-BESCGvbE.js';
+import { s as set } from '../../shared-chunks/property_set-BapAkp3X.js';
 import '../../shared-chunks/env-BJLX2Arx.js';
 import '../../route-recognizer/index.js';
 import '../../shared-chunks/rsvp-DaQAFb0W.js';
-import '../../shared-chunks/router-B-Q1aYBn.js';
+import '../../shared-chunks/unrecognized-url-error-zpz-JEoG.js';
+import RoutingService from '../routing/lib/routing-service.js';
 import '../-internals/views/lib/system/action_manager.js';
-import '../-internals/views/lib/component_lookup.js';
-import '../../shared-chunks/core_view-Cxne2_wu.js';
+import ComponentLookup from '../-internals/views/lib/component_lookup.js';
+import '../-internals/views/lib/views/core_view.js';
 import '../-internals/views/lib/mixins/class_names_support.js';
 import '../-internals/views/lib/mixins/child_views_support.js';
 import '../-internals/views/lib/mixins/view_state_support.js';
 import '../-internals/views/lib/mixins/view_support.js';
 import '../-internals/views/lib/mixins/action_support.js';
 import '../../@glimmer/opcode-compiler/index.js';
+import '../../shared-chunks/index-Llq6dmgX.js';
+import { s as setupEngineRegistry } from '../../shared-chunks/setup-registry-du4pSGZi.js';
 import '../../@glimmer/runtime/index.js';
+import '../runloop/index.js';
 import '../../@glimmer/reference/index.js';
-import '../-internals/runtime/lib/mixins/registry_proxy.js';
+import RegistryProxyMixin from '../-internals/runtime/lib/mixins/registry_proxy.js';
 import '../-internals/runtime/lib/mixins/container_proxy.js';
 import '../-internals/runtime/lib/mixins/comparable.js';
 import '../-internals/runtime/lib/mixins/action_handler.js';
@@ -39,3 +43,422 @@ import '../-internals/runtime/lib/mixins/-proxy.js';
 import '../enumerable/mutable.js';
 import '../-internals/runtime/lib/mixins/target_action_support.js';
 import '../-internals/runtime/lib/ext/rsvp.js';
+import { assert } from '../debug/lib/assert.js';
+
+function props(obj) {
+  let properties = [];
+  for (let key in obj) {
+    properties.push(key);
+  }
+  return properties;
+}
+
+/**
+@module @ember/engine
+*/
+
+/**
+  The `Engine` class contains core functionality for both applications and
+  engines.
+
+  Each engine manages a registry that's used for dependency injection and
+  exposed through `RegistryProxy`.
+
+  Engines also manage initializers and instance initializers.
+
+  Engines can spawn `EngineInstance` instances via `buildInstance()`.
+
+  @class Engine
+  @extends Ember.Namespace
+  @uses RegistryProxyMixin
+  @public
+*/
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+
+class Engine extends Namespace.extend(RegistryProxyMixin) {
+  static initializers = Object.create(null);
+  static instanceInitializers = Object.create(null);
+
+  /**
+    The goal of initializers should be to register dependencies and injections.
+    This phase runs once. Because these initializers may load code, they are
+    allowed to defer application readiness and advance it. If you need to access
+    the container or store you should use an InstanceInitializer that will be run
+    after all initializers and therefore after all code is loaded and the app is
+    ready.
+     Initializer receives an object which has the following attributes:
+    `name`, `before`, `after`, `initialize`. The only required attribute is
+    `initialize`, all others are optional.
+     * `name` allows you to specify under which name the initializer is registered.
+    This must be a unique name, as trying to register two initializers with the
+    same name will result in an error.
+     ```app/initializer/named-initializer.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Running namedInitializer!');
+    }
+     export default {
+      name: 'named-initializer',
+      initialize
+    };
+    ```
+     * `before` and `after` are used to ensure that this initializer is ran prior
+    or after the one identified by the value. This value can be a single string
+    or an array of strings, referencing the `name` of other initializers.
+     An example of ordering initializers, we create an initializer named `first`:
+     ```app/initializer/first.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('First initializer!');
+    }
+     export default {
+      name: 'first',
+      initialize
+    };
+    ```
+     ```bash
+    // DEBUG: First initializer!
+    ```
+     We add another initializer named `second`, specifying that it should run
+    after the initializer named `first`:
+     ```app/initializer/second.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Second initializer!');
+    }
+     export default {
+      name: 'second',
+      after: 'first',
+      initialize
+    };
+    ```
+     ```
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    ```
+     Afterwards we add a further initializer named `pre`, this time specifying
+    that it should run before the initializer named `first`:
+     ```app/initializer/pre.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Pre initializer!');
+    }
+     export default {
+      name: 'pre',
+      before: 'first',
+      initialize
+    };
+    ```
+     ```bash
+    // DEBUG: Pre initializer!
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    ```
+     Finally we add an initializer named `post`, specifying it should run after
+    both the `first` and the `second` initializers:
+     ```app/initializer/post.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Post initializer!');
+    }
+     export default {
+      name: 'post',
+      after: ['first', 'second'],
+      initialize
+    };
+    ```
+     ```bash
+    // DEBUG: Pre initializer!
+    // DEBUG: First initializer!
+    // DEBUG: Second initializer!
+    // DEBUG: Post initializer!
+    ```
+     * `initialize` is a callback function that receives one argument,
+      `application`, on which you can operate.
+     Example of using `application` to register an adapter:
+     ```app/initializer/api-adapter.js
+    import ApiAdapter from '../utils/api-adapter';
+     export function initialize(application) {
+      application.register('api-adapter:main', ApiAdapter);
+    }
+     export default {
+      name: 'post',
+      after: ['first', 'second'],
+      initialize
+    };
+    ```
+     @method initializer
+    @param initializer {Object}
+    @public
+  */
+
+  static initializer = buildInitializerMethod('initializers', 'initializer');
+
+  /**
+    Instance initializers run after all initializers have run. Because
+    instance initializers run after the app is fully set up. We have access
+    to the store, container, and other items. However, these initializers run
+    after code has loaded and are not allowed to defer readiness.
+     Instance initializer receives an object which has the following attributes:
+    `name`, `before`, `after`, `initialize`. The only required attribute is
+    `initialize`, all others are optional.
+     * `name` allows you to specify under which name the instanceInitializer is
+    registered. This must be a unique name, as trying to register two
+    instanceInitializer with the same name will result in an error.
+     ```app/initializer/named-instance-initializer.js
+    import { debug } from '@ember/debug';
+     export function initialize() {
+      debug('Running named-instance-initializer!');
+    }
+     export default {
+      name: 'named-instance-initializer',
+      initialize
+    };
+    ```
+     * `before` and `after` are used to ensure that this initializer is ran prior
+    or after the one identified by the value. This value can be a single string
+    or an array of strings, referencing the `name` of other initializers.
+     * See Application.initializer for discussion on the usage of before
+    and after.
+     Example instanceInitializer to preload data into the store.
+     ```app/initializer/preload-data.js
+     export function initialize(application) {
+        var userConfig, userConfigEncoded, store;
+        // We have a HTML escaped JSON representation of the user's basic
+        // configuration generated server side and stored in the DOM of the main
+        // index.html file. This allows the app to have access to a set of data
+        // without making any additional remote calls. Good for basic data that is
+        // needed for immediate rendering of the page. Keep in mind, this data,
+        // like all local models and data can be manipulated by the user, so it
+        // should not be relied upon for security or authorization.
+         // Grab the encoded data from the meta tag
+        userConfigEncoded = document.querySelector('head meta[name=app-user-config]').attr('content');
+         // Unescape the text, then parse the resulting JSON into a real object
+        userConfig = JSON.parse(unescape(userConfigEncoded));
+         // Lookup the store
+        store = application.lookup('service:store');
+         // Push the encoded JSON into the store
+        store.pushPayload(userConfig);
+    }
+     export default {
+      name: 'named-instance-initializer',
+      initialize
+    };
+    ```
+     @method instanceInitializer
+    @param instanceInitializer
+    @public
+  */
+  static instanceInitializer = buildInitializerMethod('instanceInitializers', 'instance initializer');
+
+  /**
+    This creates a registry with the default Ember naming conventions.
+     It also configures the registry:
+     * registered views are created every time they are looked up (they are
+      not singletons)
+    * registered templates are not factories; the registered value is
+      returned directly.
+    * the router receives the application as its `namespace` property
+    * all controllers receive the router as their `target` and `controllers`
+      properties
+    * all controllers receive the application as their `namespace` property
+    * the application view receives the application controller as its
+      `controller` property
+    * the application view receives the application template as its
+      `defaultTemplate` property
+     @method buildRegistry
+    @static
+    @param {Application} namespace the application for which to
+      build the registry
+    @return {Ember.Registry} the built registry
+    @private
+  */
+  static buildRegistry(namespace) {
+    let registry = new Registry({
+      resolver: resolverFor(namespace)
+    });
+    registry.set = set;
+    registry.register('application:main', namespace, {
+      instantiate: false
+    });
+    commonSetupRegistry(registry);
+    setupEngineRegistry(registry);
+    return registry;
+  }
+
+  /**
+    Set this to provide an alternate class to `DefaultResolver`
+     @property resolver
+    @public
+  */
+
+  init(properties) {
+    super.init(properties);
+    this.buildRegistry();
+  }
+
+  /**
+    A private flag indicating whether an engine's initializers have run yet.
+     @private
+    @property _initializersRan
+  */
+  _initializersRan = false;
+
+  /**
+    Ensure that initializers are run once, and only once, per engine.
+     @private
+    @method ensureInitializers
+  */
+  ensureInitializers() {
+    if (!this._initializersRan) {
+      this.runInitializers();
+      this._initializersRan = true;
+    }
+  }
+
+  /**
+    Create an EngineInstance for this engine.
+     @public
+    @method buildInstance
+    @return {EngineInstance} the engine instance
+  */
+  buildInstance(options = {}) {
+    this.ensureInitializers();
+    return EngineInstance.create({
+      ...options,
+      base: this
+    });
+  }
+
+  /**
+    Build and configure the registry for the current engine.
+     @private
+    @method buildRegistry
+    @return {Ember.Registry} the configured registry
+  */
+  buildRegistry() {
+    let registry = this.__registry__ = this.constructor.buildRegistry(this);
+    return registry;
+  }
+
+  /**
+    @private
+    @method initializer
+  */
+  initializer(initializer) {
+    this.constructor.initializer(initializer);
+  }
+
+  /**
+    @private
+    @method instanceInitializer
+  */
+  instanceInitializer(initializer) {
+    this.constructor.instanceInitializer(initializer);
+  }
+
+  /**
+    @private
+    @method runInitializers
+  */
+  runInitializers() {
+    this._runInitializer('initializers', (name, initializer) => {
+      (isDevelopingApp() && !(initializer) && assert(`No application initializer named '${name}'`, initializer));
+      initializer.initialize(this);
+    });
+  }
+
+  /**
+    @private
+    @since 1.12.0
+    @method runInstanceInitializers
+  */
+  runInstanceInitializers(instance) {
+    this._runInitializer('instanceInitializers', (name, initializer) => {
+      (isDevelopingApp() && !(initializer) && assert(`No instance initializer named '${name}'`, initializer));
+      initializer.initialize(instance);
+    });
+  }
+  _runInitializer(bucketName, cb) {
+    let initializersByName = get(this.constructor, bucketName);
+    let initializers = props(initializersByName);
+    let graph = new DAG();
+    let initializer;
+    for (let name of initializers) {
+      initializer = initializersByName[name];
+      (isDevelopingApp() && !(initializer) && assert(`missing ${bucketName}: ${name}`, initializer));
+      graph.add(initializer.name, initializer, initializer.before, initializer.after);
+    }
+    graph.topsort(cb);
+  }
+}
+
+/**
+  This function defines the default lookup rules for container lookups:
+
+  * templates are looked up on `Ember.TEMPLATES`
+  * other names are looked up on the application after classifying the name.
+    For example, `controller:post` looks up `App.PostController` by default.
+  * if the default lookup fails, look for registered classes on the container
+
+  This allows the application to register default injections in the container
+  that could be overridden by the normal naming convention.
+
+  @private
+  @method resolverFor
+  @param {Ember.Enginer} namespace the namespace to look for classes
+  @return {*} the resolved value for a given lookup
+*/
+function resolverFor(namespace) {
+  let ResolverClass = namespace.Resolver;
+  let props = {
+    namespace
+  };
+  return ResolverClass.create(props);
+}
+
+/** @internal */
+function buildInitializerMethod(bucketName, humanName) {
+  return function (initializer) {
+    // If this is the first initializer being added to a subclass, we are going to reopen the class
+    // to make sure we have a new `initializers` object, which extends from the parent class' using
+    // prototypal inheritance. Without this, attempting to add initializers to the subclass would
+    // pollute the parent class as well as other subclasses.
+    // SAFETY: The superclass may be an Engine, we don't call unless we confirmed it was ok.
+    let superclass = this.superclass;
+    if (superclass[bucketName] !== undefined && superclass[bucketName] === this[bucketName]) {
+      let attrs = {
+        [bucketName]: Object.create(this[bucketName])
+      };
+      this.reopenClass(attrs);
+    }
+    (isDevelopingApp() && !(!this[bucketName][initializer.name]) && assert(`The ${humanName} '${initializer.name}' has already been registered`, !this[bucketName][initializer.name]));
+    (isDevelopingApp() && !(canInvoke(initializer, 'initialize')) && assert(`An ${humanName} cannot be registered without an initialize function`, canInvoke(initializer, 'initialize')));
+    (isDevelopingApp() && !(initializer.name !== undefined) && assert(`An ${humanName} cannot be registered without a name property`, initializer.name !== undefined));
+    let initializers = this[bucketName];
+    initializers[initializer.name] = initializer;
+  };
+}
+function commonSetupRegistry(registry) {
+  registry.optionsForType('component', {
+    singleton: false
+  });
+  registry.optionsForType('view', {
+    singleton: false
+  });
+  registry.register('controller:basic', Controller, {
+    instantiate: false
+  });
+
+  // Register the routing service...
+  registry.register('service:-routing', RoutingService);
+
+  // DEBUGGING
+  registry.register('resolver-for-debugging:main', registry.resolver, {
+    instantiate: false
+  });
+  registry.register('container-debug-adapter:main', ContainerDebugAdapter);
+  registry.register('component-lookup:main', ComponentLookup);
+}
+
+export { buildInitializerMethod, Engine as default };

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

@@ -1,17 +1,181 @@
-import '../../shared-chunks/index-PYiGj1jp.js';
-import '../-internals/runtime/lib/mixins/registry_proxy.js';
-import '../-internals/runtime/lib/mixins/container_proxy.js';
+import EmberObject from '../object/index.js';
+import RegistryProxyMixin from '../-internals/runtime/lib/mixins/registry_proxy.js';
+import ContainerProxyMixin from '../-internals/runtime/lib/mixins/container_proxy.js';
 import '../-internals/runtime/lib/mixins/comparable.js';
 import '../-internals/runtime/lib/mixins/action_handler.js';
 import '../-internals/runtime/lib/mixins/-proxy.js';
 import '../enumerable/mutable.js';
 import '../-internals/runtime/lib/mixins/target_action_support.js';
 import '../-internals/runtime/lib/ext/rsvp.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
-import '../../shared-chunks/registry-DzfcDwii.js';
-import '../../shared-chunks/mandatory-setter-1UQhiJOb.js';
-import '@embroider/macros';
-import './lib/engine-parent.js';
-import '../-internals/owner/index.js';
-export { m as default } from '../../shared-chunks/index-BXPoca1S.js';
-import '../../shared-chunks/rsvp-DaQAFb0W.js';
+import '../debug/index.js';
+import { R as Registry, p as privatize } from '../../shared-chunks/registry-B8WARvkP.js';
+import { g as guidFor } from '../../shared-chunks/mandatory-setter-BiXq-dpN.js';
+import { isDevelopingApp } from '@embroider/macros';
+import { ENGINE_PARENT, getEngineParent, setEngineParent } from './lib/engine-parent.js';
+import { isFactory } from '../-internals/owner/index.js';
+import { assert } from '../debug/lib/assert.js';
+import { R as RSVP } from '../../shared-chunks/rsvp-DaQAFb0W.js';
+
+/**
+@module @ember/engine
+*/
+
+class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerProxyMixin) {
+  /**
+   @private
+   @method setupRegistry
+   @param {Registry} registry
+   @param {BootOptions} options
+   */
+  // This is effectively an "abstract" method: it defines the contract a
+  // subclass (e.g. `ApplicationInstance`) must follow to implement this
+  // behavior, but an `EngineInstance` has no behavior of its own here.
+  static setupRegistry(_registry, _options) {}
+
+  /**
+    The base `Engine` for which this is an instance.
+     @property {Engine} engine
+    @private
+  */
+
+  [ENGINE_PARENT];
+  _booted = false;
+  init(properties) {
+    super.init(properties);
+
+    // Ensure the guid gets setup for this instance
+    guidFor(this);
+    this.base ??= this.application;
+
+    // Create a per-instance registry that will use the application's registry
+    // as a fallback for resolving registrations.
+    let registry = this.__registry__ = new Registry({
+      fallback: this.base.__registry__
+    });
+
+    // Create a per-instance container from the instance's registry
+    this.__container__ = registry.container({
+      owner: this
+    });
+    this._booted = false;
+  }
+  _bootPromise = null;
+
+  /**
+    Initialize the `EngineInstance` and return a promise that resolves
+    with the instance itself when the boot process is complete.
+     The primary task here is to run any registered instance initializers.
+     See the documentation on `BootOptions` for the options it takes.
+     @public
+    @method boot
+    @param options {Object}
+    @return {Promise<EngineInstance,Error>}
+  */
+  boot(options) {
+    if (this._bootPromise) {
+      return this._bootPromise;
+    }
+    this._bootPromise = new RSVP.Promise(resolve => {
+      resolve(this._bootSync(options));
+    });
+    return this._bootPromise;
+  }
+
+  /**
+    Unfortunately, a lot of existing code assumes booting an instance is
+    synchronous – specifically, a lot of tests assume the last call to
+    `app.advanceReadiness()` or `app.reset()` will result in a new instance
+    being fully-booted when the current runloop completes.
+     We would like new code (like the `visit` API) to stop making this
+    assumption, so we created the asynchronous version above that returns a
+    promise. But until we have migrated all the code, we would have to expose
+    this method for use *internally* in places where we need to boot an instance
+    synchronously.
+     @private
+  */
+  _bootSync(options) {
+    if (this._booted) {
+      return this;
+    }
+    (isDevelopingApp() && !(getEngineParent(this)) && assert("An engine instance's parent must be set via `setEngineParent(engine, parent)` prior to calling `engine.boot()`.", getEngineParent(this)));
+    this.cloneParentDependencies();
+    this.setupRegistry(options);
+    this.base.runInstanceInitializers(this);
+    this._booted = true;
+    return this;
+  }
+  setupRegistry(options = this.__container__.lookup('-environment:main')) {
+    this.constructor.setupRegistry(this.__registry__, options);
+  }
+
+  /**
+   Unregister a factory.
+    Overrides `RegistryProxy#unregister` in order to clear any cached instances
+   of the unregistered factory.
+    @public
+   @method unregister
+   @param {String} fullName
+   */
+  unregister(fullName) {
+    this.__container__.reset(fullName);
+
+    // We overwrote this method from RegistryProxyMixin.
+    this.__registry__.unregister(fullName);
+  }
+
+  /**
+    Build a new `EngineInstance` that's a child of this instance.
+     Engines must be registered by name with their parent engine
+    (or application).
+     @private
+    @method buildChildEngineInstance
+    @param name {String} the registered name of the engine.
+    @param options {Object} options provided to the engine instance.
+    @return {EngineInstance,Error}
+  */
+  buildChildEngineInstance(name, options = {}) {
+    let ChildEngine = this.lookup(`engine:${name}`);
+    if (!ChildEngine) {
+      throw new Error(`You attempted to mount the engine '${name}', but it is not registered with its parent.`);
+    }
+    let engineInstance = ChildEngine.buildInstance(options);
+    setEngineParent(engineInstance, this);
+    return engineInstance;
+  }
+
+  /**
+    Clone dependencies shared between an engine instance and its parent.
+     @private
+    @method cloneParentDependencies
+  */
+  cloneParentDependencies() {
+    const parent = getEngineParent(this);
+    (isDevelopingApp() && !(parent) && assert('expected parent', parent));
+    let registrations = ['route:basic', 'service:-routing'];
+    registrations.forEach(key => {
+      let registration = parent.resolveRegistration(key);
+      (isDevelopingApp() && !(isFactory(registration)) && assert('expected registration to be a factory', isFactory(registration)));
+      this.register(key, registration);
+    });
+    let env = parent.lookup('-environment:main');
+    this.register('-environment:main', env, {
+      instantiate: false
+    });
+
+    // The type annotation forces TS to (a) validate that these match and (b)
+    // *notice* that they match, e.g. below on the `singletons.push()`.
+    let singletons = ['router:main', privatize`-bucket-cache:main`, '-view-registry:main', `renderer:-dom`, 'service:-document'];
+    if (env['isInteractive']) {
+      singletons.push('event_dispatcher:main');
+    }
+    singletons.forEach(key => {
+      // SAFETY: We already expect this to be a singleton
+      let singleton = parent.lookup(key);
+      this.register(key, singleton, {
+        instantiate: false
+      });
+    });
+  }
+}
+
+export { EngineInstance as default };

package/dist/packages/@ember/engine/parent.js

@@ -0,0 +1 @@
+export { ENGINE_PARENT, getEngineParent, setEngineParent } from './lib/engine-parent.js';

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

@@ -1,10 +1,10 @@
 import { helperCapabilities, setHelperManager as setHelperManager$1 } from '../../@glimmer/manager/index.js';
 import { invokeHelper as invokeHelper$1, hash as hash$1, array as array$1, concat as concat$1, get as get$1, fn as fn$1 } from '../../@glimmer/runtime/index.js';
 import '../../@glimmer/opcode-compiler/index.js';
-import { u as uniqueId$1 } from '../../shared-chunks/index-BXPoca1S.js';
-import '../../shared-chunks/registry-DzfcDwii.js';
-import '../../shared-chunks/index-DTxy4Zgx.js';
-import '../../shared-chunks/cache-gDE3bkXq.js';
+import { u as uniqueId$1 } from '../../shared-chunks/index-Llq6dmgX.js';
+import '../../shared-chunks/registry-B8WARvkP.js';
+import '../debug/index.js';
+import '../runloop/index.js';
 import '../../@glimmer/reference/index.js';
 import '../../@glimmer/validator/index.js';
 import '@embroider/macros';