ember-source 5.11.0 → 5.11.1

package/dist/packages/shared-chunks/{index-BXPoca1S.js → index-Llq6dmgX.js}

@@ -1,70 +1,65 @@
 import { templateFactory, programCompilationContext } from '../@glimmer/opcode-compiler/index.js';
-import { g as getFactoryFor, p as privatize, R as Registry } from './registry-DzfcDwii.js';
-import { a as assert, w as warn, b as inspect, h as debugFreeze, d as deprecate, i as info } from './index-DTxy4Zgx.js';
-import { on as on$1, reifyPositional, normalizeProperty, EMPTY_ARGS, createCapturedArgs, EMPTY_POSITIONAL, curry, hash, array, concat, fn, get as get$1, templateOnlyComponent, TEMPLATE_ONLY_COMPONENT_MANAGER, runtimeContext, DOMTreeConstruction, DOMChanges, clientBuilder, inTransaction, renderMain, rehydrationBuilder } from '../@glimmer/runtime/index.js';
-import { a0 as tracked, g as get, j as join, Q as PROPERTY_DID_CHANGE, t as tagForObject, R as objectAt, a as tagForProperty, _ as _backburner, a6 as _getProp, s as schedule, Z as _getCurrentRunLoop, ac as flushAsyncObservers, N as once, B as descriptorForProperty, d as defineProperty, x as addObserver, c as computed, O as run, ag as scheduleOnce, ah as cancel } from './cache-gDE3bkXq.js';
+import { g as getFactoryFor, p as privatize } from './registry-B8WARvkP.js';
+import { warn, debugFreeze, deprecate } from '../@ember/debug/index.js';
+import { reifyPositional, normalizeProperty, EMPTY_ARGS, createCapturedArgs, EMPTY_POSITIONAL, curry, hash, array, concat, fn, get as get$1, templateOnlyComponent, TEMPLATE_ONLY_COMPONENT_MANAGER, on as on$1, runtimeContext, DOMTreeConstruction, DOMChanges, clientBuilder, inTransaction, renderMain } from '../@glimmer/runtime/index.js';
+import { join, _backburner, schedule, _getCurrentRunLoop } from '../@ember/runloop/index.js';
 import { valueForRef, isConstRef, createConstRef, isUpdatableRef, updateRef, createPrimitiveRef, childRefFor, createComputeRef, childRefFromParts, isInvokableRef, createUnboundRef, createInvokableRef, createReadOnlyRef, createDebugAliasRef, UNDEFINED_REFERENCE } from '../@glimmer/reference/index.js';
 import { untrack, consumeTag, tagFor, createCache, getValue, valueForTag, beginUntrackFrame, endUntrackFrame, beginTrackFrame, endTrackFrame, validateTag, createTag, dirtyTag as DIRTY_TAG$1, CONSTANT_TAG, isTracking, debug, createUpdatableTag, CURRENT_TAG } from '../@glimmer/validator/index.js';
 import { isDevelopingApp } from '@embroider/macros';
-import { setModifierManager as setModifierManager$1, setInternalComponentManager, setComponentTemplate, setInternalHelperManager, setHelperManager, getInternalHelperManager, helperCapabilities, capabilityFlagsFrom, setInternalModifierManager, getInternalComponentManager, getComponentTemplate } from '../@glimmer/manager/index.js';
+import { setInternalComponentManager, setComponentTemplate, setInternalHelperManager, setHelperManager, getInternalHelperManager, helperCapabilities, capabilityFlagsFrom, setInternalModifierManager, getInternalComponentManager, getComponentTemplate } from '../@glimmer/manager/index.js';
 import { h as hasDOM } from './index-BGP1rw3B.js';
-import { b as action$1, i as isArray, E as EmberObject, t as typeOf, A } from './index-PYiGj1jp.js';
-import { isSimpleClick, getViewElement, clearElementView, clearViewElement, addChildView, setViewElement, setElementView, constructStyleDeprecationMessage, getViewId } from '../@ember/-internals/views/lib/system/utils.js';
+import { action as action$1 } from '../@ember/object/index.js';
+import { on } from '../@ember/modifier/on.js';
 import '../@ember/-internals/meta/lib/meta.js';
-import { g as guidFor, a as getDebugName, e as isObject, u as uuid, l as lookupDescriptor } from './mandatory-setter-1UQhiJOb.js';
+import { g as guidFor, a as getDebugName, e as isObject, u as uuid } from './mandatory-setter-BiXq-dpN.js';
 import { registerDestructor, associateDestroyableChild, destroy } from '../@glimmer/destroyable/index.js';
+import { S as tracked, g as get, Q as PROPERTY_DID_CHANGE, t as tagForObject, o as objectAt, a as tagForProperty, V as _getProp } from './cache-BESCGvbE.js';
 import { E as ENV } from './env-BJLX2Arx.js';
+import { setOwner, getOwner, isFactory } from '../@ember/-internals/owner/index.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+import { d as decorateFieldV2, i as initializeDeferredDecorator, a as decorateMethodV2 } from './chunk-3SQBS3Y5-Cj4eryg1.js';
+import { isSimpleClick, getViewElement, clearElementView, clearViewElement, addChildView, setViewElement, setElementView, constructStyleDeprecationMessage, getViewId } from '../@ember/-internals/views/lib/system/utils.js';
 import ActionManager from '../@ember/-internals/views/lib/system/action_manager.js';
-import ComponentLookup from '../@ember/-internals/views/lib/component_lookup.js';
-import { d as decorateFieldV2, i as initializeDeferredDecorator, a as decorateMethodV2, C as CoreView } from './core_view-Cxne2_wu.js';
+import '../@ember/-internals/views/lib/component_lookup.js';
+import CoreView from '../@ember/-internals/views/lib/views/core_view.js';
 import ClassNamesSupport from '../@ember/-internals/views/lib/mixins/class_names_support.js';
 import ChildViewsSupport from '../@ember/-internals/views/lib/mixins/child_views_support.js';
 import ViewStateSupport from '../@ember/-internals/views/lib/mixins/view_state_support.js';
 import ViewMixin from '../@ember/-internals/views/lib/mixins/view_support.js';
 import ActionSupport from '../@ember/-internals/views/lib/mixins/action_support.js';
-import { getEngineParent, ENGINE_PARENT, setEngineParent } from '../@ember/engine/lib/engine-parent.js';
-import { c as canInvoke } from './invoke-BjRgvK2V.js';
-import Controller from '../@ember/controller/index.js';
-import Namespace from '../@ember/application/namespace.js';
-import DAG from '../dag-map/index.js';
-import ContainerDebugAdapter from '../@ember/debug/container-debug-adapter.js';
-import RegistryProxyMixin from '../@ember/-internals/runtime/lib/mixins/registry_proxy.js';
-import ContainerProxyMixin from '../@ember/-internals/runtime/lib/mixins/container_proxy.js';
+import { getEngineParent } from '../@ember/engine/lib/engine-parent.js';
+import { flaggedInstrument, _instrumentStart } from '../@ember/instrumentation/index.js';
+import { service } from '../@ember/service/index.js';
+import inspect from '../@ember/debug/lib/inspect.js';
+import '../@ember/-internals/runtime/lib/mixins/registry_proxy.js';
+import '../@ember/-internals/runtime/lib/mixins/container_proxy.js';
 import '../@ember/-internals/runtime/lib/mixins/comparable.js';
-import ActionHandler from '../@ember/-internals/runtime/lib/mixins/action_handler.js';
+import '../@ember/-internals/runtime/lib/mixins/action_handler.js';
 import { contentFor } from '../@ember/-internals/runtime/lib/mixins/-proxy.js';
 import '../@ember/enumerable/mutable.js';
 import TargetActionSupport from '../@ember/-internals/runtime/lib/mixins/target_action_support.js';
 import '../@ember/-internals/runtime/lib/ext/rsvp.js';
-import { setOwner, getOwner, isFactory } from '../@ember/-internals/owner/index.js';
-import { a as RSVP, R as RSVP$1 } from './rsvp-DaQAFb0W.js';
-import { _ as _setProp, s as set } from './property_set-CW4q-uo4.js';
-import '../route-recognizer/index.js';
-import { S as STATE_SYMBOL, P as PARAMS_SYMBOL, R as Router, l as logAbort } from './router-B-Q1aYBn.js';
-import { readOnly } from '../@ember/object/lib/computed/computed_macros.js';
-import Service, { service } from '../@ember/service/index.js';
-import { getOwner as getOwner$1 } from '../@ember/owner/index.js';
-import BucketCache from '../@ember/routing/lib/cache.js';
-import DSLImpl from '../@ember/routing/lib/dsl.js';
-import Evented from '../@ember/object/evented.js';
-import { i as isProxy } from './is_proxy-Dmis-70B.js';
-import { g as getProperties, s as setProperties } from './set_properties-DvalyQdu.js';
-import generateController, { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
-import { deprecateUntil, DEPRECATIONS } from '../@ember/-internals/deprecations/index.js';
-import { dependentKeyCompat } from '../@ember/object/compat.js';
-import { isTesting } from '../@ember/debug/lib/testing.js';
 import EventDispatcher from '../@ember/-internals/views/lib/system/event_dispatcher.js';
-import { e as enumerableSymbol } from './to-string-D8i3mjEU.js';
-import { flaggedInstrument, _instrumentStart } from '../@ember/instrumentation/index.js';
+import { e as enumerableSymbol } from './to-string-B1BmwUkt.js';
 import { unwrapTemplate, EMPTY_ARRAY as EMPTY_ARRAY$1, dict } from '../@glimmer/util/index.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
 import { MUTABLE_CELL } from '../@ember/-internals/views/lib/compat/attrs.js';
+import { deprecateUntil, DEPRECATIONS } from '../@ember/-internals/deprecations/index.js';
 import { FrameworkObject } from '../@ember/object/-internals.js';
 import { CurriedType as CurriedTypes } from '../@glimmer/vm/index.js';
 import { RuntimeOpImpl, artifacts } from '../@glimmer/program/index.js';
-import { NodeDOMTreeConstruction, serializeBuilder } from '../@glimmer/node/index.js';
+import { a as RSVP } from './rsvp-DaQAFb0W.js';
+import EngineInstance from '../@ember/engine/instance.js';
+import { NodeDOMTreeConstruction } from '../@glimmer/node/index.js';
+import { _ as _setProp, s as set } from './property_set-BapAkp3X.js';
 import setGlobalContext from '../@glimmer/global-context/index.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
+import { i as isProxy } from './is_proxy-DjvCKvd5.js';
+import { isArray } from '../@ember/array/index.js';
+import '../route-recognizer/index.js';
+import './unrecognized-url-error-zpz-JEoG.js';
+import '../@ember/routing/lib/routing-service.js';
+import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
 
 const RootTemplate = templateFactory(
 /*
@@ -77,22 +72,6 @@ const RootTemplate = templateFactory(
   "isStrictMode": true
 });
 
-// In normal TypeScript, this modifier is essentially an opaque token that just
-// needs to be importable. Declaring it with a unique interface like this,
-// however, gives tools like Glint (that *do* have a richer notion of what it
-// is) a place to install more detailed type information.
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-
-// 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.
-const on = on$1;
-
-// NOTE: this uses assignment to *require* that the `glimmerSetModifierManager`
-// is legally assignable to this type, i.e. that variance is properly upheld.
-const setModifierManager = setModifierManager$1;
-
 const InputTemplate = templateFactory(
 /*
   <input
@@ -1059,11 +1038,11 @@ class _LinkTo extends InternalComponent {
   }
   get isEngine() {
     let owner = this.owner;
-    return owner instanceof EmberEngineInstance && getEngineParent(owner) !== undefined;
+    return getEngineParent(owner) !== undefined;
   }
   get engineMountPoint() {
     let owner = this.owner;
-    return owner instanceof EmberEngineInstance ? owner.mountPoint : undefined;
+    return owner.mountPoint;
   }
   classFor(state) {
     let className = this.named(`${state}Class`);
@@ -1800,7 +1779,6 @@ function invokeRef(value) {
 function processComponentArgs(namedArgs) {
   let attrs = Object.create(null);
   let props = Object.create(null);
-  props[ARGS] = namedArgs;
   for (let name in namedArgs) {
     let ref = namedArgs[name];
     (isDevelopingApp() && !(ref) && assert('expected ref', ref));
@@ -1980,6 +1958,7 @@ class CurlyComponentManager {
     let capturedArgs = args.named.capture();
     beginTrackFrame();
     let props = processComponentArgs(capturedArgs);
+    props[ARGS] = capturedArgs;
     let argsTag = endTrackFrame();
 
     // Alias `id` argument to `elementId` property on the component instance.
@@ -3652,7 +3631,7 @@ class OutletComponentManager {
       let parentOwner = parentState && parentState.render && parentState.render.owner;
       let currentOwner = valueForRef(currentStateRef).render.owner;
       if (parentOwner && parentOwner !== currentOwner) {
-        (isDevelopingApp() && !(currentOwner instanceof EmberEngineInstance) && assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EmberEngineInstance));
+        (isDevelopingApp() && !(currentOwner instanceof EngineInstance) && assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance));
         let mountPoint = currentOwner.mountPoint;
         state.engine = currentOwner;
         if (mountPoint) {
@@ -4595,7 +4574,7 @@ class MountManager {
     // mount is a runtime helper, this shouldn't use dynamic layout
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
-    (isDevelopingApp() && !(owner instanceof EmberEngineInstance) && assert('Expected owner to be an EngineInstance', owner instanceof EmberEngineInstance));
+    (isDevelopingApp() && !(owner instanceof EngineInstance) && assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance));
     let engine = owner.buildChildEngineInstance(name);
     engine.boot();
     let applicationFactory = engine.factoryFor(`controller:application`);
@@ -5515,4603 +5494,4 @@ const OutletTemplate = templateFactory(
   "isStrictMode": true
 });
 
-function setupApplicationRegistry(registry) {
-  // because we are using injections we can't use instantiate false
-  // we need to use bind() to copy the function so factory for
-  // association won't leak
-  registry.register('service:-dom-builder', {
-    // Additionally, we *must* constrain this to require `props` on create, else
-    // we *know* it cannot have an owner.
-    create(props) {
-      let owner = getOwner(props);
-      (isDevelopingApp() && !(owner) && assert('DomBuilderService is unexpectedly missing an owner', owner));
-      let env = owner.lookup('-environment:main');
-      switch (env._renderMode) {
-        case 'serialize':
-          return serializeBuilder.bind(null);
-        case 'rehydrate':
-          return rehydrationBuilder.bind(null);
-        default:
-          return clientBuilder.bind(null);
-      }
-    }
-  });
-  registry.register(privatize`template:-root`, RootTemplate);
-  registry.register('renderer:-dom', Renderer);
-}
-function setupEngineRegistry(registry) {
-  registry.optionsForType('template', {
-    instantiate: false
-  });
-  registry.register('view:-outlet', OutletView);
-  registry.register('template:-outlet', OutletTemplate);
-  registry.optionsForType('helper', {
-    instantiate: false
-  });
-  registry.register('component:input', Input);
-  registry.register('component:link-to', LinkTo);
-  registry.register('component:textarea', Textarea);
-}
-
-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 EmberEngineInstance.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);
-}
-
-/**
-@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$1.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.`);
-    }
-    (isDevelopingApp() && !(ChildEngine instanceof Engine) && assert('expected an Engine', ChildEngine instanceof Engine));
-    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
-      });
-    });
-  }
-}
-const EmberEngineInstance = EngineInstance;
-
-const ALL_PERIODS_REGEX = /\./g;
-function extractRouteArgs(args) {
-  // SAFETY: This should just be the same thing
-  args = args.slice();
-  let possibleOptions = args[args.length - 1];
-  let queryParams;
-  if (isRouteOptions(possibleOptions)) {
-    args.pop(); // Remove options
-    queryParams = possibleOptions.queryParams;
-  } else {
-    queryParams = {};
-  }
-  let routeName;
-  if (typeof args[0] === 'string') {
-    routeName = args.shift();
-    // We just checked this!
-    (isDevelopingApp() && !(typeof routeName === 'string') && assert('routeName is a string', typeof routeName === 'string'));
-  }
-
-  // SAFTEY: We removed the name and options if they existed, only models left.
-  let models = args;
-  return {
-    routeName,
-    models,
-    queryParams
-  };
-}
-function getActiveTargetName(router) {
-  let routeInfos = router.activeTransition ? router.activeTransition[STATE_SYMBOL].routeInfos : router.state.routeInfos;
-  let lastRouteInfo = routeInfos[routeInfos.length - 1];
-  (isDevelopingApp() && !(lastRouteInfo) && assert('has last route info', lastRouteInfo));
-  return lastRouteInfo.name;
-}
-function stashParamNames(router, routeInfos) {
-  if (routeInfos['_namesStashed']) {
-    return;
-  }
-
-  // This helper exists because router.js/route-recognizer.js awkwardly
-  // keeps separate a routeInfo's list of parameter names depending
-  // on whether a URL transition or named transition is happening.
-  // Hopefully we can remove this in the future.
-  let routeInfo = routeInfos[routeInfos.length - 1];
-  (isDevelopingApp() && !(routeInfo) && assert('has route info', routeInfo));
-  let targetRouteName = routeInfo.name;
-  let recogHandlers = router._routerMicrolib.recognizer.handlersFor(targetRouteName);
-  let dynamicParent;
-  for (let i = 0; i < routeInfos.length; ++i) {
-    let routeInfo = routeInfos[i];
-    (isDevelopingApp() && !(routeInfo) && assert('has route info', routeInfo));
-    let names = recogHandlers[i].names;
-    if (names.length) {
-      dynamicParent = routeInfo;
-    }
-    routeInfo['_names'] = names;
-    let route = routeInfo.route;
-    route._stashNames(routeInfo, dynamicParent);
-  }
-  routeInfos['_namesStashed'] = true;
-}
-function _calculateCacheValuePrefix(prefix, part) {
-  // calculates the dot separated sections from prefix that are also
-  // at the start of part - which gives us the route name
-
-  // given : prefix = site.article.comments, part = site.article.id
-  //      - returns: site.article (use get(values[site.article], 'id') to get the dynamic part - used below)
-
-  // given : prefix = site.article, part = site.article.id
-  //      - returns: site.article. (use get(values[site.article], 'id') to get the dynamic part - used below)
-
-  let prefixParts = prefix.split('.');
-  let currPrefix = '';
-  for (let i = 0; i < prefixParts.length; i++) {
-    let currPart = prefixParts.slice(0, i + 1).join('.');
-    if (part.indexOf(currPart) !== 0) {
-      break;
-    }
-    currPrefix = currPart;
-  }
-  return currPrefix;
-}
-
-/*
-  Stolen from Controller
-*/
-function calculateCacheKey(prefix, parts = [], values) {
-  let suffixes = '';
-  for (let part of parts) {
-    let cacheValuePrefix = _calculateCacheValuePrefix(prefix, part);
-    let value;
-    if (values) {
-      if (cacheValuePrefix && cacheValuePrefix in values) {
-        let partRemovedPrefix = part.indexOf(cacheValuePrefix) === 0 ? part.substring(cacheValuePrefix.length + 1) : part;
-        value = get(values[cacheValuePrefix], partRemovedPrefix);
-      } else {
-        value = get(values, part);
-      }
-    }
-    suffixes += `::${part}:${value}`;
-  }
-  return prefix + suffixes.replace(ALL_PERIODS_REGEX, '-');
-}
-
-/*
-  Controller-defined query parameters can come in three shapes:
-
-  Array
-    queryParams: ['foo', 'bar']
-  Array of simple objects where value is an alias
-    queryParams: [
-      {
-        'foo': 'rename_foo_to_this'
-      },
-      {
-        'bar': 'call_bar_this_instead'
-      }
-    ]
-  Array of fully defined objects
-    queryParams: [
-      {
-        'foo': {
-          as: 'rename_foo_to_this'
-        },
-      }
-      {
-        'bar': {
-          as: 'call_bar_this_instead',
-          scope: 'controller'
-        }
-      }
-    ]
-
-  This helper normalizes all three possible styles into the
-  'Array of fully defined objects' style.
-*/
-function normalizeControllerQueryParams(queryParams) {
-  let qpMap = {};
-  for (let queryParam of queryParams) {
-    accumulateQueryParamDescriptors(queryParam, qpMap);
-  }
-  return qpMap;
-}
-function accumulateQueryParamDescriptors(_desc, accum) {
-  let desc = typeof _desc === 'string' ? {
-    [_desc]: {
-      as: null
-    }
-  } : _desc;
-  for (let key in desc) {
-    if (!Object.prototype.hasOwnProperty.call(desc, key)) {
-      return;
-    }
-    let _singleDesc = desc[key];
-    let singleDesc = typeof _singleDesc === 'string' ? {
-      as: _singleDesc
-    } : _singleDesc;
-    let partialVal = accum[key] || {
-      as: null,
-      scope: 'model'
-    };
-    let val = {
-      ...partialVal,
-      ...singleDesc
-    };
-    accum[key] = val;
-  }
-}
-
-/*
-  Check if a routeName resembles a url instead
-
-  @private
-*/
-function resemblesURL(str) {
-  return typeof str === 'string' && (str === '' || str[0] === '/');
-}
-
-/*
-  Returns an arguments array where the route name arg is prefixed based on the mount point
-
-  @private
-*/
-function prefixRouteNameArg(route, args) {
-  let routeName;
-  let owner = getOwner(route);
-  (isDevelopingApp() && !(owner instanceof EmberEngineInstance) && assert('Expected route to have EngineInstance as owner', owner instanceof EmberEngineInstance));
-  let prefix = owner.mountPoint;
-
-  // only alter the routeName if it's actually referencing a route.
-  if (owner.routable && typeof args[0] === 'string') {
-    routeName = args[0];
-    if (resemblesURL(routeName)) {
-      throw new Error('Programmatic transitions by URL cannot be used within an Engine. Please use the route name instead.');
-    } else {
-      routeName = `${prefix}.${routeName}`;
-      args[0] = routeName;
-    }
-  }
-  return args;
-}
-function shallowEqual(a, b) {
-  let aCount = 0;
-  let bCount = 0;
-  for (let kA in a) {
-    if (Object.prototype.hasOwnProperty.call(a, kA)) {
-      if (a[kA] !== b[kA]) {
-        return false;
-      }
-      aCount++;
-    }
-  }
-  for (let kB in b) {
-    if (Object.prototype.hasOwnProperty.call(b, kB)) {
-      bCount++;
-    }
-  }
-  return aCount === bCount;
-}
-function isRouteOptions(value) {
-  if (value && typeof value === 'object') {
-    let qps = value.queryParams;
-    if (qps && typeof qps === 'object') {
-      return Object.keys(qps).every(k => typeof k === 'string');
-    }
-  }
-  return false;
-}
-
-class RouterState {
-  router;
-  emberRouter;
-  routerJsState;
-  constructor(emberRouter, router, routerJsState) {
-    this.emberRouter = emberRouter;
-    this.router = router;
-    this.routerJsState = routerJsState;
-  }
-  isActiveIntent(routeName, models, queryParams) {
-    let state = this.routerJsState;
-    if (!this.router.isActiveIntent(routeName, models, undefined, state)) {
-      return false;
-    }
-    if (queryParams !== undefined && Object.keys(queryParams).length > 0) {
-      let visibleQueryParams = Object.assign({}, queryParams);
-      this.emberRouter._prepareQueryParams(routeName, models, visibleQueryParams);
-      return shallowEqual(visibleQueryParams, state.queryParams);
-    }
-    return true;
-  }
-}
-
-function isStoreLike(store) {
-  return typeof store === 'object' && store !== null && typeof store.find === 'function';
-}
-const RENDER = Symbol('render');
-const RENDER_STATE = Symbol('render-state');
-
-/**
-@module @ember/routing/route
-*/
-
-/**
-  The `Route` class is used to define individual routes. Refer to
-  the [routing guide](https://guides.emberjs.com/release/routing/) for documentation.
-
-  @class Route
-  @extends EmberObject
-  @uses ActionHandler
-  @uses Evented
-  @since 1.0.0
-  @public
-*/
-
-class Route extends EmberObject.extend(ActionHandler, Evented) {
-  static isRouteFactory = true;
-
-  // 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 */
-  context = {};
-  /** @internal */
-
-  /** @internal */
-  _bucketCache;
-  /** @internal */
-  _internalName;
-  _names;
-  _router;
-  constructor(owner) {
-    super(owner);
-    if (owner) {
-      let router = owner.lookup('router:main');
-      let bucketCache = owner.lookup(privatize`-bucket-cache:main`);
-      (isDevelopingApp() && !(router instanceof EmberRouter$1 && bucketCache instanceof BucketCache) && assert('ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!', router instanceof EmberRouter$1 && bucketCache instanceof BucketCache));
-      this._router = router;
-      this._bucketCache = bucketCache;
-      this._topLevelViewTemplate = owner.lookup('template:-outlet');
-      this._environment = owner.lookup('-environment:main');
-    }
-  }
-
-  /**
-    A hook you can implement to convert the route's model into parameters
-    for the URL.
-     ```app/router.js
-    // ...
-     Router.map(function() {
-      this.route('post', { path: '/posts/:post_id' });
-    });
-     ```
-     ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
-      model({ post_id }) {
-        // the server returns `{ id: 12 }`
-        return fetch(`/posts/${post_id}`;
-      }
-       serialize(model) {
-        // this will make the URL `/posts/12`
-        return { post_id: model.id };
-      }
-    }
-    ```
-     The default `serialize` method will insert the model's `id` into the
-    route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
-    If the route has multiple dynamic segments or does not contain '_id', `serialize`
-    will return `getProperties(model, params)`
-     This method is called when `transitionTo` is called with a context
-    in order to populate the URL.
-     @method serialize
-    @param {Object} model the routes model
-    @param {Array} params an Array of parameter names for the current
-      route (in the example, `['post_id']`.
-    @return {Object} the serialized parameters
-    @since 1.0.0
-    @public
-  */
-  serialize(model, params) {
-    if (params.length < 1 || !model) {
-      return;
-    }
-    let object = {};
-    if (params.length === 1) {
-      let [name] = params;
-      (isDevelopingApp() && !(name) && assert('has name', name));
-      if (typeof model === 'object' && name in model) {
-        object[name] = get(model, name);
-      } else if (/_id$/.test(name)) {
-        object[name] = get(model, 'id');
-      } else if (isProxy(model)) {
-        object[name] = get(model, name);
-      }
-    } else {
-      object = getProperties(model, params);
-    }
-    return object;
-  }
-
-  /**
-    Configuration hash for this route's queryParams. The possible
-    configuration options and their defaults are as follows
-    (assuming a query param whose controller property is `page`):
-     ```javascript
-    queryParams = {
-      page: {
-        // By default, controller query param properties don't
-        // cause a full transition when they are changed, but
-        // rather only cause the URL to update. Setting
-        // `refreshModel` to true will cause an "in-place"
-        // transition to occur, whereby the model hooks for
-        // this route (and any child routes) will re-fire, allowing
-        // you to reload models (e.g., from the server) using the
-        // updated query param values.
-        refreshModel: false,
-         // By default, changes to controller query param properties
-        // cause the URL to update via `pushState`, which means an
-        // item will be added to the browser's history, allowing
-        // you to use the back button to restore the app to the
-        // previous state before the query param property was changed.
-        // Setting `replace` to true will use `replaceState` (or its
-        // hash location equivalent), which causes no browser history
-        // item to be added. This options name and default value are
-        // the same as the `link-to` helper's `replace` option.
-        replace: false,
-         // By default, the query param URL key is the same name as
-        // the controller property name. Use `as` to specify a
-        // different URL key.
-        as: 'page'
-      }
-    };
-    ```
-     @property queryParams
-    @for Route
-    @type Object
-    @since 1.6.0
-    @public
-  */
-  // Set in reopen so it can be overriden with extend
-
-  /**
-    The name of the template to use by default when rendering this route's
-    template.
-     ```app/routes/posts/list.js
-    import Route from '@ember/routing/route';
-     export default class PostsListRoute extends Route {
-      templateName = 'posts/list';
-    }
-    ```
-     ```app/routes/posts/index.js
-    import PostsListRoute from '../posts/list';
-     export default class PostsIndexRoute extends PostsListRoute {};
-    ```
-     ```app/routes/posts/archived.js
-    import PostsListRoute from '../posts/list';
-     export default class PostsArchivedRoute extends PostsListRoute {};
-    ```
-     @property templateName
-    @type String
-    @default null
-    @since 1.4.0
-    @public
-  */
-  // Set in reopen so it can be overriden with extend
-
-  /**
-    The name of the controller to associate with this route.
-     By default, Ember will lookup a route's controller that matches the name
-    of the route (i.e. `posts.new`). However,
-    if you would like to define a specific controller to use, you can do so
-    using this property.
-     This is useful in many ways, as the controller specified will be:
-     * passed to the `setupController` method.
-    * used as the controller for the template being rendered by the route.
-    * returned from a call to `controllerFor` for the route.
-     @property controllerName
-    @type String
-    @default null
-    @since 1.4.0
-    @public
-  */
-  // Set in reopen so it can be overriden with extend
-
-  /**
-    The controller associated with this route.
-     Example
-     ```app/routes/form.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-     export default class FormRoute extends Route {
-      @action
-      willTransition(transition) {
-        if (this.controller.get('userHasEnteredData') &&
-            !confirm('Are you sure you want to abandon progress?')) {
-          transition.abort();
-        } else {
-          // Bubble the `willTransition` action so that
-          // parent routes can decide whether or not to abort.
-          return true;
-        }
-      }
-    }
-    ```
-     @property controller
-    @type Controller
-    @since 1.6.0
-    @public
-  */
-
-  /**
-    The name of the route, dot-delimited.
-     For example, a route found at `app/routes/posts/post.js` will have
-    a `routeName` of `posts.post`.
-     @property routeName
-    @for Route
-    @type String
-    @since 1.0.0
-    @public
-  */
-
-  /**
-    The name of the route, dot-delimited, including the engine prefix
-    if applicable.
-     For example, a route found at `addon/routes/posts/post.js` within an
-    engine named `admin` will have a `fullRouteName` of `admin.posts.post`.
-     @property fullRouteName
-    @for Route
-    @type String
-    @since 2.10.0
-    @public
-  */
-
-  /**
-    Sets the name for this route, including a fully resolved name for routes
-    inside engines.
-     @private
-    @method _setRouteName
-    @param {String} name
-  */
-  _setRouteName(name) {
-    this.routeName = name;
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner instanceof EmberEngineInstance) && assert('Expected route to have EngineInstance as owner', owner instanceof EmberEngineInstance));
-    this.fullRouteName = getEngineRouteName(owner, name);
-  }
-
-  /**
-    @private
-     @method _stashNames
-  */
-  _stashNames(routeInfo, dynamicParent) {
-    if (this._names) {
-      return;
-    }
-    let names = this._names = routeInfo['_names'];
-    if (!names.length) {
-      routeInfo = dynamicParent;
-      names = routeInfo && routeInfo['_names'] || [];
-    }
-
-    // SAFETY: Since `_qp` is protected we can't infer the type
-    let qps = get(this, '_qp').qps;
-    let namePaths = new Array(names.length);
-    for (let a = 0; a < names.length; ++a) {
-      namePaths[a] = `${routeInfo.name}.${names[a]}`;
-    }
-    for (let qp of qps) {
-      if (qp.scope === 'model') {
-        qp.parts = namePaths;
-      }
-    }
-  }
-
-  /**
-    @private
-     @property _activeQPChanged
-  */
-  _activeQPChanged(qp, value) {
-    this._router._activeQPChanged(qp.scopedPropertyName, value);
-  }
-
-  /**
-    @private
-    @method _updatingQPChanged
-  */
-  _updatingQPChanged(qp) {
-    this._router._updatingQPChanged(qp.urlKey);
-  }
-
-  /**
-    Returns a hash containing the parameters of an ancestor route.
-     You may notice that `this.paramsFor` sometimes works when referring to a
-    child route, but this behavior should not be relied upon as only ancestor
-    routes are certain to be loaded in time.
-     Example
-     ```app/router.js
-    // ...
-     Router.map(function() {
-      this.route('member', { path: ':name' }, function() {
-        this.route('interest', { path: ':interest' });
-      });
-    });
-    ```
-     ```app/routes/member.js
-    import Route from '@ember/routing/route';
-     export default class MemberRoute extends Route {
-      queryParams = {
-        memberQp: { refreshModel: true }
-      }
-    }
-    ```
-     ```app/routes/member/interest.js
-    import Route from '@ember/routing/route';
-     export default class MemberInterestRoute extends Route {
-      queryParams = {
-        interestQp: { refreshModel: true }
-      }
-       model() {
-        return this.paramsFor('member');
-      }
-    }
-    ```
-     If we visit `/turing/maths?memberQp=member&interestQp=interest` the model for
-    the `member.interest` route is a hash with:
-     * `name`: `turing`
-    * `memberQp`: `member`
-     @method paramsFor
-    @param {String} name
-    @return {Object} hash containing the parameters of the route `name`
-    @since 1.4.0
-    @public
-  */
-  paramsFor(name) {
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-    let route = owner.lookup(`route:${name}`);
-    if (route === undefined) {
-      return {};
-    }
-    let transition = this._router._routerMicrolib.activeTransition;
-    let state = transition ? transition[STATE_SYMBOL] : this._router._routerMicrolib.state;
-    let fullName = route.fullRouteName;
-    let params = {
-      ...state.params[fullName]
-    };
-    let queryParams = getQueryParamsFor(route, state);
-    return Object.entries(queryParams).reduce((params, [key, value]) => {
-      (isDevelopingApp() && !(!params[key]) && assert(`The route '${this.routeName}' has both a dynamic segment and query param with name '${key}'. Please rename one to avoid collisions.`, !params[key]));
-      params[key] = value;
-      return params;
-    }, params);
-  }
-
-  /**
-    Serializes the query parameter key
-     @method serializeQueryParamKey
-    @param {String} controllerPropertyName
-    @private
-  */
-  serializeQueryParamKey(controllerPropertyName) {
-    return controllerPropertyName;
-  }
-
-  /**
-    Serializes value of the query parameter based on defaultValueType
-     @method serializeQueryParam
-    @param {Object} value
-    @param {String} urlKey
-    @param {String} defaultValueType
-    @private
-  */
-  serializeQueryParam(value, _urlKey, defaultValueType) {
-    // urlKey isn't used here, but anyone overriding
-    // can use it to provide serialization specific
-    // to a certain query param.
-    return this._router._serializeQueryParam(value, defaultValueType);
-  }
-
-  /**
-    Deserializes value of the query parameter based on defaultValueType
-     @method deserializeQueryParam
-    @param {Object} value
-    @param {String} urlKey
-    @param {String} defaultValueType
-    @private
-  */
-  deserializeQueryParam(value, _urlKey, defaultValueType) {
-    // urlKey isn't used here, but anyone overriding
-    // can use it to provide deserialization specific
-    // to a certain query param.
-    return this._router._deserializeQueryParam(value, defaultValueType);
-  }
-
-  /**
-    @private
-     @property _optionsForQueryParam
-  */
-  _optionsForQueryParam(qp) {
-    const queryParams = get(this, 'queryParams');
-    return get(queryParams, qp.urlKey) || get(queryParams, qp.prop) || queryParams[qp.urlKey] || queryParams[qp.prop] || {};
-  }
-
-  /**
-    A hook you can use to reset controller values either when the model
-    changes or the route is exiting.
-     ```app/routes/articles.js
-    import Route from '@ember/routing/route';
-     export default class ArticlesRoute extends Route {
-      resetController(controller, isExiting, transition) {
-        if (isExiting && transition.targetName !== 'error') {
-          controller.set('page', 1);
-        }
-      }
-    }
-    ```
-     @method resetController
-    @param {Controller} controller instance
-    @param {Boolean} isExiting
-    @param {Object} transition
-    @since 1.7.0
-    @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;
-  }
-
-  /**
-    @private
-     @method exit
-  */
-  exit(transition) {
-    this.deactivate(transition);
-    this.trigger('deactivate', transition);
-    this.teardownViews();
-  }
-
-  /**
-    @private
-     @method _internalReset
-    @since 3.6.0
-  */
-  _internalReset(isExiting, transition) {
-    let controller = this.controller;
-    // SAFETY: Since `_qp` is protected we can't infer the type
-    controller['_qpDelegate'] = get(this, '_qp').states.inactive;
-    this.resetController(controller, isExiting, transition);
-  }
-
-  /**
-    @private
-     @method enter
-  */
-  enter(transition) {
-    this[RENDER_STATE] = undefined;
-    this.activate(transition);
-    this.trigger('activate', transition);
-  }
-
-  /**
-    This event is triggered when the router enters the route. It is
-    not executed when the model for the route changes.
-     ```app/routes/application.js
-    import { on } from '@ember/object/evented';
-    import Route from '@ember/routing/route';
-     export default Route.extend({
-      collectAnalytics: on('activate', function(){
-        collectAnalytics();
-      })
-    });
-    ```
-     @event activate
-    @since 1.9.0
-    @public
-  */
-
-  /**
-    This event is triggered when the router completely exits this
-    route. It is not executed when the model for the route changes.
-     ```app/routes/index.js
-    import { on } from '@ember/object/evented';
-    import Route from '@ember/routing/route';
-     export default Route.extend({
-      trackPageLeaveAnalytics: on('deactivate', function(){
-        trackPageLeaveAnalytics();
-      })
-    });
-    ```
-     @event deactivate
-    @since 1.9.0
-    @public
-  */
-
-  /**
-    This hook is executed when the router completely exits this route. It is
-    not executed when the model for the route changes.
-     @method deactivate
-    @param {Transition} transition
-    @since 1.0.0
-    @public
-  */
-  deactivate(_transition) {}
-
-  /**
-    This hook is executed when the router enters the route. It is not executed
-    when the model for the route changes.
-     @method activate
-    @param {Transition} transition
-    @since 1.0.0
-    @public
-  */
-  activate(_transition) {}
-
-  /**
-    Perform a synchronous transition into another route without attempting
-    to resolve promises, update the URL, or abort any currently active
-    asynchronous transitions (i.e. regular transitions caused by
-    `transitionTo` or URL changes).
-     This method is handy for performing intermediate transitions on the
-    way to a final destination route, and is called internally by the
-    default implementations of the `error` and `loading` handlers.
-     @method intermediateTransitionTo
-    @param {String} name the name of the route
-    @param {...Object} models the model(s) to be used while transitioning
-    to the route.
-    @since 1.2.0
-    @public
-   */
-  intermediateTransitionTo(...args) {
-    let [name, ...preparedArgs] = prefixRouteNameArg(this, args);
-    this._router.intermediateTransitionTo(name, ...preparedArgs);
-  }
-
-  /**
-    Refresh the model on this route and any child routes, firing the
-    `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
-    to how routes are entered when transitioning in from other route.
-    The current route params (e.g. `article_id`) will be passed in
-    to the respective model hooks, and if a different model is returned,
-    `setupController` and associated route hooks will re-fire as well.
-     An example usage of this method is re-querying the server for the
-    latest information using the same parameters as when the route
-    was first entered.
-     Note that this will cause `model` hooks to fire even on routes
-    that were provided a model object when the route was initially
-    entered.
-     @method refresh
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @since 1.4.0
-    @public
-   */
-  refresh() {
-    return this._router._routerMicrolib.refresh(this);
-  }
-
-  /**
-    This hook is the entry point for router.js
-     @private
-    @method setup
-  */
-  setup(context, transition) {
-    let controllerName = this.controllerName || this.routeName;
-    let definedController = this.controllerFor(controllerName, true);
-    let controller = definedController ?? this.generateController(controllerName);
-
-    // SAFETY: Since `_qp` is protected we can't infer the type
-    let queryParams = get(this, '_qp');
-
-    // Assign the route's controller so that it can more easily be
-    // referenced in action handlers. Side effects. Side effects everywhere.
-    if (!this.controller) {
-      let propNames = queryParams.propertyNames;
-      addQueryParamsObservers(controller, propNames);
-      this.controller = controller;
-    }
-    let states = queryParams.states;
-    controller._qpDelegate = states.allowOverrides;
-    if (transition) {
-      // Update the model dep values used to calculate cache keys.
-      stashParamNames(this._router, transition[STATE_SYMBOL].routeInfos);
-      let cache = this._bucketCache;
-      let params = transition[PARAMS_SYMBOL];
-      let allParams = queryParams.propertyNames;
-      allParams.forEach(prop => {
-        let aQp = queryParams.map[prop];
-        (isDevelopingApp() && !(aQp) && assert('expected aQp', aQp));
-        aQp.values = params;
-        let cacheKey = calculateCacheKey(aQp.route.fullRouteName, aQp.parts, aQp.values);
-        let value = cache.lookup(cacheKey, prop, aQp.undecoratedDefaultValue);
-        set(controller, prop, value);
-      });
-      let qpValues = getQueryParamsFor(this, transition[STATE_SYMBOL]);
-      setProperties(controller, qpValues);
-    }
-    this.setupController(controller, context, transition);
-    if (this._environment.options.shouldRender) {
-      this[RENDER]();
-    }
-
-    // Setup can cause changes to QPs which need to be propogated immediately in
-    // some situations. Eventually, we should work on making these async somehow.
-    flushAsyncObservers(false);
-  }
-
-  /*
-    Called when a query parameter for this route changes, regardless of whether the route
-    is currently part of the active route hierarchy. This will update the query parameter's
-    value in the cache so if this route becomes active, the cache value has been updated.
-  */
-  _qpChanged(prop, value, qp) {
-    if (!qp) {
-      return;
-    }
-
-    // Update model-dep cache
-    let cache = this._bucketCache;
-    let cacheKey = calculateCacheKey(qp.route.fullRouteName, qp.parts, qp.values);
-    cache.stash(cacheKey, prop, value);
-  }
-
-  /**
-    This hook is the first of the route entry validation hooks
-    called when an attempt is made to transition into a route
-    or one of its children. It is called before `model` and
-    `afterModel`, and is appropriate for cases when:
-     1) A decision can be made to redirect elsewhere without
-       needing to resolve the model first.
-    2) Any async operations need to occur first before the
-       model is attempted to be resolved.
-     This hook is provided the current `transition` attempt
-    as a parameter, which can be used to `.abort()` the transition,
-    save it for a later `.retry()`, or retrieve values set
-    on it from a previous hook. You can also just call
-    `router.transitionTo` to another route to implicitly
-    abort the `transition`.
-     You can return a promise from this hook to pause the
-    transition until the promise resolves (or rejects). This could
-    be useful, for instance, for retrieving async code from
-    the server that is required to enter a route.
-     @method beforeModel
-    @param {Transition} transition
-    @return {any | Promise<any>} if the value returned from this hook is
-      a promise, the transition will pause until the transition
-      resolves. Otherwise, non-promise return values are not
-      utilized in any way.
-    @since 1.0.0
-    @public
-  */
-
-  beforeModel(_transition) {}
-
-  /**
-    This hook is called after this route's model has resolved.
-    It follows identical async/promise semantics to `beforeModel`
-    but is provided the route's resolved model in addition to
-    the `transition`, and is therefore suited to performing
-    logic that can only take place after the model has already
-    resolved.
-     ```app/routes/posts.js
-    import Route from '@ember/routing/route';
-    import { service } from '@ember/service';
-     export default class PostsRoute extends Route {
-      @service router;
-       afterModel(posts, transition) {
-        if (posts.get('length') === 1) {
-          this.router.transitionTo('post.show', posts.get('firstObject'));
-        }
-      }
-    }
-    ```
-     Refer to documentation for `beforeModel` for a description
-    of transition-pausing semantics when a promise is returned
-    from this hook.
-     @method afterModel
-    @param {Object} resolvedModel the value returned from `model`,
-      or its resolved value if it was a promise
-    @param {Transition} transition
-    @return {any | Promise<any>} if the value returned from this hook is
-      a promise, the transition will pause until the transition
-      resolves. Otherwise, non-promise return values are not
-      utilized in any way.
-    @since 1.0.0
-    @public
-   */
-
-  afterModel(_resolvedModel, _transition) {}
-
-  /**
-    A hook you can implement to optionally redirect to another route.
-     Calling `this.router.transitionTo` from inside of the `redirect` hook will
-    abort the current transition (into the route that has implemented `redirect`).
-     `redirect` and `afterModel` behave very similarly and are
-    called almost at the same time, but they have an important
-    distinction when calling `this.router.transitionTo` to a child route
-    of the current route. From `afterModel`, this new transition
-    invalidates the current transition, causing `beforeModel`,
-    `model`, and `afterModel` hooks to be called again. But the
-    same transition started from `redirect` does _not_ invalidate
-    the current transition. In other words, by the time the `redirect`
-    hook has been called, both the resolved model and the attempted
-    entry into this route are considered fully validated.
-     @method redirect
-    @param {Object} model the model for this route
-    @param {Transition} transition the transition object associated with the current transition
-    @since 1.0.0
-    @public
-  */
-  redirect(_model, _transition) {}
-
-  /**
-    Called when the context is changed by router.js.
-     @private
-    @method contextDidChange
-  */
-  contextDidChange() {
-    this.currentModel = this.context;
-  }
-
-  /**
-    A hook you can implement to convert the URL into the model for
-    this route.
-     ```app/router.js
-    // ...
-     Router.map(function() {
-      this.route('post', { path: '/posts/:post_id' });
-    });
-     export default Router;
-    ```
-     Note that for routes with dynamic segments, this hook is not always
-    executed. If the route is entered through a transition (e.g. when
-    using the `link-to` Handlebars helper or the `transitionTo` method
-    of routes), and a model context is already provided this hook
-    is not called.
-     A model context does not include a primitive string or number,
-    which does cause the model hook to be called.
-     Routes without dynamic segments will always execute the model hook.
-     ```javascript
-    // no dynamic segment, model hook always called
-    this.router.transitionTo('posts');
-     // model passed in, so model hook not called
-    thePost = store.findRecord('post', 1);
-    this.router.transitionTo('post', thePost);
-     // integer passed in, model hook is called
-    this.router.transitionTo('post', 1);
-     // model id passed in, model hook is called
-    // useful for forcing the hook to execute
-    thePost = store.findRecord('post', 1);
-    this.router.transitionTo('post', thePost.id);
-    ```
-     This hook follows the asynchronous/promise semantics
-    described in the documentation for `beforeModel`. In particular,
-    if a promise returned from `model` fails, the error will be
-    handled by the `error` hook on `Route`.
-     Note that the legacy behavior of automatically defining a model
-    hook when a dynamic segment ending in `_id` is present is
-    [deprecated](https://deprecations.emberjs.com/v5.x#toc_deprecate-implicit-route-model).
-    You should explicitly define a model hook whenever any segments are
-    present.
-     Example
-     ```app/routes/post.js
-    import Route from '@ember/routing/route';
-    import { service } from '@ember/service';
-     export default class PostRoute extends Route {
-      @service store;
-       model(params) {
-        return this.store.findRecord('post', params.post_id);
-      }
-    }
-    ```
-     @method model
-    @param {Object} params the parameters extracted from the URL
-    @param {Transition} transition
-    @return {any | Promise<any>} the model for this route. If
-      a promise is returned, the transition will pause until
-      the promise resolves, and the resolved value of the promise
-      will be used as the model for this route.
-    @since 1.0.0
-    @public
-  */
-  model(params, transition) {
-    let name, sawParams, value;
-    // SAFETY: Since `_qp` is protected we can't infer the type
-    let queryParams = get(this, '_qp').map;
-    for (let prop in params) {
-      if (prop === 'queryParams' || queryParams && prop in queryParams) {
-        continue;
-      }
-      let match = prop.match(/^(.*)_id$/);
-      if (match !== null) {
-        name = match[1];
-        value = params[prop];
-      }
-      sawParams = true;
-    }
-    if (!name) {
-      if (sawParams) {
-        // SAFETY: This should be equivalent
-        return Object.assign({}, params);
-      } else {
-        if (transition.resolveIndex < 1) {
-          return;
-        }
-        // SAFETY: This should be correct, but TS is unable to infer this.
-        return transition[STATE_SYMBOL].routeInfos[transition.resolveIndex - 1].context;
-      }
-    }
-    return this.findModel(name, value);
-  }
-
-  /**
-    @private
-    @method deserialize
-    @param {Object} params the parameters extracted from the URL
-    @param {Transition} transition
-    @return {any | Promise<any>} the model for this route.
-     Router.js hook.
-   */
-  deserialize(_params, transition) {
-    return this.model(this._paramsFor(this.routeName, _params), transition);
-  }
-
-  /**
-     @method findModel
-    @param {String} type the model type
-    @param {Object} value the value passed to find
-    @private
-  */
-  findModel(type, value) {
-    if (ENV._NO_IMPLICIT_ROUTE_MODEL) {
-      return;
-    }
-    deprecateUntil(`The implicit model loading behavior for routes is deprecated. ` + `Please define an explicit model hook for ${this.fullRouteName}.`, DEPRECATIONS.DEPRECATE_IMPLICIT_ROUTE_MODEL);
-    const store = 'store' in this ? this.store : get(this, '_store');
-    (isDevelopingApp() && !(isStoreLike(store)) && assert('Expected route to have a store with a find method', isStoreLike(store))); // SAFETY: We don't actually know it will return this, but this code path is also deprecated.
-    return store.find(type, value);
-  }
-
-  /**
-    A hook you can use to setup the controller for the current route.
-     This method is called with the controller for the current route and the
-    model supplied by the `model` hook.
-     By default, the `setupController` hook sets the `model` property of
-    the controller to the specified `model` when it is not `undefined`.
-     If you implement the `setupController` hook in your Route, it will
-    prevent this default behavior. If you want to preserve that behavior
-    when implementing your `setupController` function, make sure to call
-    `super`:
-     ```app/routes/photos.js
-    import Route from '@ember/routing/route';
-    import { service } from '@ember/service';
-     export default class PhotosRoute extends Route {
-      @service store;
-       model() {
-        return this.store.findAll('photo');
-      }
-       setupController(controller, model) {
-        super.setupController(controller, model);
-         this.controllerFor('application').set('showingPhotos', true);
-      }
-    }
-    ```
-     The provided controller will be one resolved based on the name
-    of this route.
-     If no explicit controller is defined, Ember will automatically create one.
-     As an example, consider the router:
-     ```app/router.js
-    // ...
-     Router.map(function() {
-      this.route('post', { path: '/posts/:post_id' });
-    });
-     export default Router;
-    ```
-     If you have defined a file for the post controller,
-    the framework will use it.
-    If it is not defined, a basic `Controller` instance would be used.
-     @example Behavior of a basic Controller
-     ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
-      setupController(controller, model) {
-        controller.set('model', model);
-      }
-    });
-    ```
-     @method setupController
-    @param {Controller} controller instance
-    @param {Object} model
-    @param {Transition} [transition]
-    @since 1.0.0
-    @public
-  */
-  setupController(controller, context, _transition) {
-    if (controller && context !== undefined) {
-      set(controller, 'model', context);
-    }
-  }
-
-  /**
-    Returns the controller of the current route, or a parent (or any ancestor)
-    route in a route hierarchy.
-     The controller instance must already have been created, either through entering the
-    associated route or using `generateController`.
-     ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class PostRoute extends Route {
-      setupController(controller, post) {
-        super.setupController(controller, post);
-         this.controllerFor('posts').set('currentPost', post);
-      }
-    }
-    ```
-     @method controllerFor
-    @param {String} name the name of the route or controller
-    @return {Controller | undefined}
-    @since 1.0.0
-    @public
-  */
-
-  controllerFor(name, _skipAssert = false) {
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-    let route = owner.lookup(`route:${name}`);
-    if (route && route.controllerName) {
-      name = route.controllerName;
-    }
-    let controller = owner.lookup(`controller:${name}`);
-
-    // NOTE: We're specifically checking that skipAssert is true, because according
-    //   to the old API the second parameter was model. We do not want people who
-    //   passed a model to skip the assertion.
-    (isDevelopingApp() && !(controller !== undefined || _skipAssert === true) && assert(`The controller named '${name}' could not be found. Make sure that this route exists and has already been entered at least once. If you are accessing a controller not associated with a route, make sure the controller class is explicitly defined.`, controller !== undefined || _skipAssert === true));
-    (isDevelopingApp() && !(controller === undefined || controller instanceof Controller) && assert(`Expected controller:${name} to be an instance of Controller`, controller === undefined || controller instanceof Controller));
-    return controller;
-  }
-
-  /**
-    Generates a controller for a route.
-     Example
-     ```app/routes/post.js
-    import Route from '@ember/routing/route';
-     export default class Post extends Route {
-      setupController(controller, post) {
-        super.setupController(controller, post);
-         this.generateController('posts');
-      }
-    }
-    ```
-     @method generateController
-    @param {String} name the name of the controller
-    @private
-  */
-  generateController(name) {
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-    return generateController(owner, name);
-  }
-
-  /**
-    Returns the resolved model of a parent (or any ancestor) route
-    in a route hierarchy.  During a transition, all routes
-    must resolve a model object, and if a route
-    needs access to a parent route's model in order to
-    resolve a model (or just reuse the model from a parent),
-    it can call `this.modelFor(theNameOfParentRoute)` to
-    retrieve it. If the ancestor route's model was a promise,
-    its resolved result is returned.
-     Example
-     ```app/router.js
-    // ...
-     Router.map(function() {
-      this.route('post', { path: '/posts/:post_id' }, function() {
-        this.route('comments');
-      });
-    });
-     export default Router;
-    ```
-     ```app/routes/post/comments.js
-    import Route from '@ember/routing/route';
-     export default class PostCommentsRoute extends Route {
-      model() {
-        let post = this.modelFor('post');
-         return post.comments;
-      }
-    }
-    ```
-     @method modelFor
-    @param {String} name the name of the route
-    @return {Object} the model object
-    @since 1.0.0
-    @public
-  */
-  modelFor(_name) {
-    let name;
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner instanceof EmberEngineInstance) && assert('Expected router owner to be an EngineInstance', owner instanceof EmberEngineInstance));
-    let transition = this._router && this._router._routerMicrolib ? this._router._routerMicrolib.activeTransition : undefined;
-
-    // Only change the route name when there is an active transition.
-    // Otherwise, use the passed in route name.
-    if (owner.routable && transition !== undefined) {
-      name = getEngineRouteName(owner, _name);
-    } else {
-      name = _name;
-    }
-    let route = owner.lookup(`route:${name}`);
-    // If we are mid-transition, we want to try and look up
-    // resolved parent contexts on the current transitionEvent.
-    if (transition !== undefined && transition !== null) {
-      let modelLookupName = route && route.routeName || name;
-      if (Object.prototype.hasOwnProperty.call(transition.resolvedModels, modelLookupName)) {
-        return transition.resolvedModels[modelLookupName];
-      }
-    }
-    return route?.currentModel;
-  }
-  [RENDER_STATE] = undefined;
-
-  /**
-    `this[RENDER]` is used to set up the rendering option for the outlet state.
-    @method this[RENDER]
-    @private
-   */
-  [RENDER]() {
-    this[RENDER_STATE] = buildRenderState(this);
-    once(this._router, '_setOutlets');
-  }
-  willDestroy() {
-    this.teardownViews();
-  }
-
-  /**
-    @private
-     @method teardownViews
-  */
-  teardownViews() {
-    if (this[RENDER_STATE]) {
-      this[RENDER_STATE] = undefined;
-      once(this._router, '_setOutlets');
-    }
-  }
-
-  /**
-    Allows you to produce custom metadata for the route.
-    The return value of this method will be attached to
-    its corresponding RouteInfoWithAttributes object.
-     Example
-     ```app/routes/posts/index.js
-    import Route from '@ember/routing/route';
-     export default class PostsIndexRoute extends Route {
-      buildRouteInfoMetadata() {
-        return { title: 'Posts Page' }
-      }
-    }
-    ```
-     ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { service } from '@ember/service';
-     export default class ApplicationRoute extends Route {
-      @service router
-       constructor() {
-        super(...arguments);
-         this.router.on('routeDidChange', transition => {
-          document.title = transition.to.metadata.title;
-          // would update document's title to "Posts Page"
-        });
-      }
-    }
-    ```
-    @method buildRouteInfoMetadata
-    @return any
-    @since 3.10.0
-    @public
-   */
-
-  buildRouteInfoMetadata() {}
-  _paramsFor(routeName, params) {
-    let transition = this._router._routerMicrolib.activeTransition;
-    if (transition !== undefined) {
-      return this.paramsFor(routeName);
-    }
-    return params;
-  }
-
-  /** @deprecated Manually define your own store, such as with `@service store` */
-  get _store() {
-    const owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-    let routeName = this.routeName;
-    return {
-      find(name, value) {
-        let modelClass = owner.factoryFor(`model:${name}`);
-        (isDevelopingApp() && !(Boolean(modelClass)) && assert(`You used the dynamic segment \`${name}_id\` in your route ` + `\`${routeName}\` for which Ember requires you provide a ` + `data-loading implementation. Commonly, that is done by ` + `adding a model hook implementation on the route ` + `(\`model({${name}_id}) {\`) or by injecting an implemention of ` + `a data store: \`@service store;\`.`, Boolean(modelClass)));
-        if (!modelClass) {
-          return;
-        }
-        modelClass = modelClass.class;
-        (isDevelopingApp() && !(typeof modelClass.find === 'function') && assert(`You used the dynamic segment \`${name}_id\` in your route ` + `\`${routeName}\` for which Ember requires you provide a ` + `data-loading implementation. Commonly, that is done by ` + `adding a model hook implementation on the route ` + `(\`model({${name}_id}) {\`) or by injecting an implemention of ` + `a data store: \`@service store;\`.\n\n` + `Rarely, applications may attempt to use a legacy behavior where ` + `the model class (in this case \`${name}\`) is resolved and the ` + `\`find\` method on that class is invoked to load data. In this ` + `application, a model of \`${name}\` was found but it did not ` + `provide a \`find\` method. You should not add a \`find\` ` + `method to your model. Instead, please implement an appropriate ` + `\`model\` hook on the \`${routeName}\` route.`, typeof modelClass.find === 'function'));
-        return modelClass.find(value);
-      }
-    };
-  }
-
-  /**
-    @private
-    @property _qp
-    */
-  static {
-    decorateMethodV2(this.prototype, "_store", [computed]);
-  }
-  get _qp() {
-    let combinedQueryParameterConfiguration = {};
-    let controllerName = this.controllerName || this.routeName;
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-    let controller = owner.lookup(`controller:${controllerName}`);
-    let queryParameterConfiguraton = get(this, 'queryParams');
-    let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
-    if (controller) {
-      (isDevelopingApp() && !(controller instanceof Controller) && assert('Expected an instance of controller', controller instanceof Controller)); // the developer has authored a controller class in their application for
-      // this route find its query params and normalize their object shape them
-      // merge in the query params for the route. As a mergedProperty,
-      // Route#queryParams is always at least `{}`
-      let controllerDefinedQueryParameterConfiguration = get(controller, 'queryParams') || [];
-      let normalizedControllerQueryParameterConfiguration = normalizeControllerQueryParams(controllerDefinedQueryParameterConfiguration);
-      combinedQueryParameterConfiguration = mergeEachQueryParams(normalizedControllerQueryParameterConfiguration, queryParameterConfiguraton);
-    } else if (hasRouterDefinedQueryParams) {
-      // the developer has not defined a controller but *has* supplied route query params.
-      // Generate a class for them so we can later insert default values
-      controller = generateController(owner, controllerName);
-      combinedQueryParameterConfiguration = queryParameterConfiguraton;
-    }
-    let qps = [];
-    let map = {};
-    let propertyNames = [];
-    for (let propName in combinedQueryParameterConfiguration) {
-      if (!Object.prototype.hasOwnProperty.call(combinedQueryParameterConfiguration, propName)) {
-        continue;
-      }
-
-      // to support the dubious feature of using unknownProperty
-      // on queryParams configuration
-      if (propName === 'unknownProperty' || propName === '_super') {
-        // possible todo: issue deprecation warning?
-        continue;
-      }
-      let desc = combinedQueryParameterConfiguration[propName];
-      (isDevelopingApp() && !(desc) && assert(`[BUG] missing query parameter configuration for ${propName}`, desc));
-      let scope = desc.scope || 'model';
-      let parts = undefined;
-      if (scope === 'controller') {
-        parts = [];
-      }
-      let urlKey = desc.as || this.serializeQueryParamKey(propName);
-      let defaultValue = get(controller, propName);
-      defaultValue = copyDefaultValue(defaultValue);
-      let type = desc.type || typeOf(defaultValue);
-      let defaultValueSerialized = this.serializeQueryParam(defaultValue, urlKey, type);
-      let scopedPropertyName = `${controllerName}:${propName}`;
-      let qp = {
-        undecoratedDefaultValue: get(controller, propName),
-        defaultValue,
-        serializedDefaultValue: defaultValueSerialized,
-        serializedValue: defaultValueSerialized,
-        type,
-        urlKey,
-        prop: propName,
-        scopedPropertyName,
-        controllerName,
-        route: this,
-        parts,
-        // provided later when stashNames is called if 'model' scope
-        values: null,
-        // provided later when setup is called. no idea why.
-        scope
-      };
-      map[propName] = map[urlKey] = map[scopedPropertyName] = qp;
-      qps.push(qp);
-      propertyNames.push(propName);
-    }
-    return {
-      qps,
-      map,
-      propertyNames,
-      states: {
-        /*
-          Called when a query parameter changes in the URL, this route cares
-          about that query parameter, but the route is not currently
-          in the active route hierarchy.
-        */
-        inactive: (prop, value) => {
-          let qp = map[prop];
-          (isDevelopingApp() && !(qp) && assert('expected inactive callback to only be called for registered qps', qp));
-          this._qpChanged(prop, value, qp);
-        },
-        /*
-          Called when a query parameter changes in the URL, this route cares
-          about that query parameter, and the route is currently
-          in the active route hierarchy.
-        */
-        active: (prop, value) => {
-          let qp = map[prop];
-          (isDevelopingApp() && !(qp) && assert('expected active callback to only be called for registered qps', qp));
-          this._qpChanged(prop, value, qp);
-          return this._activeQPChanged(qp, value);
-        },
-        /*
-          Called when a value of a query parameter this route handles changes in a controller
-          and the route is currently in the active route hierarchy.
-        */
-        allowOverrides: (prop, value) => {
-          let qp = map[prop];
-          (isDevelopingApp() && !(qp) && assert('expected allowOverrides callback to only be called for registered qps', qp));
-          this._qpChanged(prop, value, qp);
-          return this._updatingQPChanged(qp);
-        }
-      }
-    };
-  }
-
-  // Set in reopen
-  static {
-    decorateMethodV2(this.prototype, "_qp", [computed]);
-  }
-  /**
-    Sends an action to the router, which will delegate it to the currently
-    active route hierarchy per the bubbling rules explained under `actions`.
-     Example
-     ```app/router.js
-    // ...
-     Router.map(function() {
-      this.route('index');
-    });
-     export default Router;
-    ```
-     ```app/routes/application.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-     export default class ApplicationRoute extends Route {
-      @action
-      track(arg) {
-        console.log(arg, 'was clicked');
-      }
-    }
-    ```
-     ```app/routes/index.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-     export default class IndexRoute extends Route {
-      @action
-      trackIfDebug(arg) {
-        if (debug) {
-          this.send('track', arg);
-        }
-      }
-    }
-    ```
-     @method send
-    @param {String} name the name of the action to trigger
-    @param {...*} args
-    @since 1.0.0
-    @public
-  */
-  // Set with reopen to override parent behavior
-}
-function getRenderState(route) {
-  return route[RENDER_STATE];
-}
-function buildRenderState(route) {
-  let owner = getOwner(route);
-  (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-  let name = route.routeName;
-  let controller = owner.lookup(`controller:${route.controllerName || name}`);
-  (isDevelopingApp() && !(controller instanceof Controller) && assert('Expected an instance of controller', controller instanceof Controller));
-  let model = route.currentModel;
-  let template = owner.lookup(`template:${route.templateName || name}`);
-  let render = {
-    owner,
-    into: undefined,
-    outlet: 'main',
-    name,
-    controller,
-    model,
-    template: template?.(owner) ?? route._topLevelViewTemplate(owner)
-  };
-  if (isDevelopingApp()) {
-    let LOG_VIEW_LOOKUPS = get(route._router, 'namespace.LOG_VIEW_LOOKUPS');
-    if (LOG_VIEW_LOOKUPS && !template) {
-      info(`Could not find "${name}" template. Nothing will be rendered`, {
-        fullName: `template:${name}`
-      });
-    }
-  }
-  return render;
-}
-function getFullQueryParams(router, state) {
-  if (state.fullQueryParams) {
-    return state.fullQueryParams;
-  }
-  let haveAllRouteInfosResolved = state.routeInfos.every(routeInfo => routeInfo.route);
-  let fullQueryParamsState = {
-    ...state.queryParams
-  };
-  router._deserializeQueryParams(state.routeInfos, fullQueryParamsState);
-
-  // only cache query params state if all routeinfos have resolved; it's possible
-  // for lazy routes to not have resolved when `getFullQueryParams` is called, so
-  // we wait until all routes have resolved prior to caching query params state
-  if (haveAllRouteInfosResolved) {
-    state.fullQueryParams = fullQueryParamsState;
-  }
-  return fullQueryParamsState;
-}
-function getQueryParamsFor(route, state) {
-  state.queryParamsFor = state.queryParamsFor || {};
-  let name = route.fullRouteName;
-  let existing = state.queryParamsFor[name];
-  if (existing) {
-    return existing;
-  }
-  let fullQueryParams = getFullQueryParams(route._router, state);
-  let params = state.queryParamsFor[name] = {};
-
-  // Copy over all the query params for this route/controller into params hash.
-  // SAFETY: Since `_qp` is protected we can't infer the type
-  let qps = get(route, '_qp').qps;
-  for (let qp of qps) {
-    // Put deserialized qp on params hash.
-    let qpValueWasPassedIn = (qp.prop in fullQueryParams);
-    params[qp.prop] = qpValueWasPassedIn ? fullQueryParams[qp.prop] : copyDefaultValue(qp.defaultValue);
-  }
-  return params;
-}
-
-// FIXME: This should probably actually return a `NativeArray` if the passed in value is an Array.
-function copyDefaultValue(value) {
-  if (Array.isArray(value)) {
-    // SAFETY: We lost the type data about the array if we don't cast.
-    return A(value.slice());
-  }
-  return value;
-}
-
-/*
-  Merges all query parameters from a controller with those from
-  a route, returning a new object and avoiding any mutations to
-  the existing objects.
-*/
-function mergeEachQueryParams(controllerQP, routeQP) {
-  let qps = {};
-  let keysAlreadyMergedOrSkippable = {
-    defaultValue: true,
-    type: true,
-    scope: true,
-    as: true
-  };
-
-  // first loop over all controller qps, merging them with any matching route qps
-  // into a new empty object to avoid mutating.
-  for (let cqpName in controllerQP) {
-    if (!Object.prototype.hasOwnProperty.call(controllerQP, cqpName)) {
-      continue;
-    }
-    qps[cqpName] = {
-      ...controllerQP[cqpName],
-      ...routeQP[cqpName]
-    };
-
-    // allows us to skip this QP when we check route QPs.
-    keysAlreadyMergedOrSkippable[cqpName] = true;
-  }
-
-  // loop over all route qps, skipping those that were merged in the first pass
-  // because they also appear in controller qps
-  for (let rqpName in routeQP) {
-    if (!Object.prototype.hasOwnProperty.call(routeQP, rqpName) || keysAlreadyMergedOrSkippable[rqpName]) {
-      continue;
-    }
-    qps[rqpName] = {
-      ...routeQP[rqpName],
-      ...controllerQP[rqpName]
-    };
-  }
-  return qps;
-}
-function addQueryParamsObservers(controller, propNames) {
-  propNames.forEach(prop => {
-    if (descriptorForProperty(controller, prop) === undefined) {
-      let desc = lookupDescriptor(controller, prop);
-      if (desc !== null && (typeof desc.get === 'function' || typeof desc.set === 'function')) {
-        defineProperty(controller, prop, dependentKeyCompat({
-          get: desc.get,
-          set: desc.set
-        }));
-      }
-    }
-    addObserver(controller, `${prop}.[]`, controller, controller._qpChanged, false);
-  });
-}
-function getEngineRouteName(engine, routeName) {
-  if (engine.routable) {
-    let prefix = engine.mountPoint;
-    if (routeName === 'application') {
-      return prefix;
-    } else {
-      return `${prefix}.${routeName}`;
-    }
-  }
-  return routeName;
-}
-const defaultSerialize = Route.prototype.serialize;
-function hasDefaultSerialize(route) {
-  return route.serialize === defaultSerialize;
-}
-
-// Set these here so they can be overridden with extend
-Route.reopen({
-  mergedProperties: ['queryParams'],
-  queryParams: {},
-  templateName: null,
-  controllerName: null,
-  send(...args) {
-    (isDevelopingApp() && !(!this.isDestroying && !this.isDestroyed) && assert(`Attempted to call .send() with the action '${args[0]}' on the destroyed route '${this.routeName}'.`, !this.isDestroying && !this.isDestroyed));
-    if (this._router && this._router._routerMicrolib || !isTesting()) {
-      this._router.send(...args);
-    } else {
-      let name = args.shift();
-      let action = this.actions[name];
-      if (action) {
-        return action.apply(this, args);
-      }
-    }
-  },
-  /**
-    The controller associated with this route.
-     Example
-     ```app/routes/form.js
-    import Route from '@ember/routing/route';
-    import { action } from '@ember/object';
-     export default class FormRoute extends Route {
-      @action
-      willTransition(transition) {
-        if (this.controller.get('userHasEnteredData') &&
-            !confirm('Are you sure you want to abandon progress?')) {
-          transition.abort();
-        } else {
-          // Bubble the `willTransition` action so that
-          // parent routes can decide whether or not to abort.
-          return true;
-        }
-      }
-    }
-    ```
-     @property controller
-    @type Controller
-    @since 1.6.0
-    @public
-  */
-
-  actions: {
-    /**
-    This action is called when one or more query params have changed. Bubbles.
-     @method queryParamsDidChange
-    @param changed {Object} Keys are names of query params that have changed.
-    @param totalPresent {Object} Keys are names of query params that are currently set.
-    @param removed {Object} Keys are names of query params that have been removed.
-    @returns {boolean}
-    @private
-    */
-    queryParamsDidChange(changed, _totalPresent, removed) {
-      // SAFETY: Since `_qp` is protected we can't infer the type
-      let qpMap = get(this, '_qp').map;
-      let totalChanged = Object.keys(changed).concat(Object.keys(removed));
-      for (let change of totalChanged) {
-        let qp = qpMap[change];
-        if (qp) {
-          let options = this._optionsForQueryParam(qp);
-          (isDevelopingApp() && !(options && typeof options === 'object') && assert('options exists', options && typeof options === 'object'));
-          if (get(options, 'refreshModel') && this._router.currentState) {
-            this.refresh();
-            break;
-          }
-        }
-      }
-      return true;
-    },
-    finalizeQueryParamChange(params, finalParams, transition) {
-      if (this.fullRouteName !== 'application') {
-        return true;
-      }
-
-      // Transition object is absent for intermediate transitions.
-      if (!transition) {
-        return;
-      }
-      let routeInfos = transition[STATE_SYMBOL].routeInfos;
-      let router = this._router;
-      let qpMeta = router._queryParamsFor(routeInfos);
-      let changes = router._qpUpdates;
-      let qpUpdated = false;
-      let replaceUrl;
-      stashParamNames(router, routeInfos);
-      for (let qp of qpMeta.qps) {
-        let route = qp.route;
-        let controller = route.controller;
-        let presentKey = qp.urlKey in params && qp.urlKey;
-
-        // Do a reverse lookup to see if the changed query
-        // param URL key corresponds to a QP property on
-        // this controller.
-        let value;
-        let svalue;
-        if (changes.has(qp.urlKey)) {
-          // Value updated in/before setupController
-          value = get(controller, qp.prop);
-          svalue = route.serializeQueryParam(value, qp.urlKey, qp.type);
-        } else {
-          if (presentKey) {
-            svalue = params[presentKey];
-            if (svalue !== undefined) {
-              value = route.deserializeQueryParam(svalue, qp.urlKey, qp.type);
-            }
-          } else {
-            // No QP provided; use default value.
-            svalue = qp.serializedDefaultValue;
-            value = copyDefaultValue(qp.defaultValue);
-          }
-        }
-
-        // SAFETY: Since `_qp` is protected we can't infer the type
-        controller._qpDelegate = get(route, '_qp').states.inactive;
-        let thisQueryParamChanged = svalue !== qp.serializedValue;
-        if (thisQueryParamChanged) {
-          if (transition.queryParamsOnly && replaceUrl !== false) {
-            let options = route._optionsForQueryParam(qp);
-            let replaceConfigValue = get(options, 'replace');
-            if (replaceConfigValue) {
-              replaceUrl = true;
-            } else if (replaceConfigValue === false) {
-              // Explicit pushState wins over any other replaceStates.
-              replaceUrl = false;
-            }
-          }
-          set(controller, qp.prop, value);
-          qpUpdated = true;
-        }
-
-        // Stash current serialized value of controller.
-        qp.serializedValue = svalue;
-        let thisQueryParamHasDefaultValue = qp.serializedDefaultValue === svalue;
-        if (!thisQueryParamHasDefaultValue) {
-          finalParams.push({
-            value: svalue,
-            visible: true,
-            key: presentKey || qp.urlKey
-          });
-        }
-      }
-
-      // Some QPs have been updated, and those changes need to be propogated
-      // immediately. Eventually, we should work on making this async somehow.
-      if (qpUpdated === true) {
-        flushAsyncObservers(false);
-      }
-      if (replaceUrl) {
-        transition.method('replace');
-      }
-      qpMeta.qps.forEach(qp => {
-        // SAFETY: Since `_qp` is protected we can't infer the type
-        let routeQpMeta = get(qp.route, '_qp');
-        let finalizedController = qp.route.controller;
-        finalizedController['_qpDelegate'] = get(routeQpMeta, 'states.active');
-      });
-      router._qpUpdates.clear();
-      return;
-    }
-  }
-});
-
-/**
-@module @ember/routing/router
-*/
-
-function defaultDidTransition(infos) {
-  updatePaths(this);
-  this._cancelSlowTransitionTimer();
-  this.notifyPropertyChange('url');
-  this.set('currentState', this.targetState);
-  if (isDevelopingApp()) {
-    // @ts-expect-error namespace isn't public
-    if (this.namespace.LOG_TRANSITIONS) {
-      // eslint-disable-next-line no-console
-      console.log(`Transitioned into '${EmberRouter._routePath(infos)}'`);
-    }
-  }
-}
-function defaultWillTransition(oldInfos, newInfos) {
-  if (isDevelopingApp()) {
-    // @ts-expect-error namespace isn't public
-    if (this.namespace.LOG_TRANSITIONS) {
-      // eslint-disable-next-line no-console
-      console.log(`Preparing to transition from '${EmberRouter._routePath(oldInfos)}' to '${EmberRouter._routePath(newInfos)}'`);
-    }
-  }
-}
-let freezeRouteInfo;
-if (isDevelopingApp()) {
-  freezeRouteInfo = transition => {
-    if (transition.from !== null && !Object.isFrozen(transition.from)) {
-      Object.freeze(transition.from);
-    }
-    if (transition.to !== null && !Object.isFrozen(transition.to)) {
-      Object.freeze(transition.to);
-    }
-  };
-}
-function K() {
-  return this;
-}
-const {
-  slice
-} = Array.prototype;
-
-/**
-  The `EmberRouter` class manages the application state and URLs. Refer to
-  the [routing guide](https://guides.emberjs.com/release/routing/) for documentation.
-
-  @class EmberRouter
-  @extends EmberObject
-  @uses Evented
-  @public
-*/
-class EmberRouter extends EmberObject.extend(Evented) {
-  /**
-   Represents the URL of the root of the application, often '/'. This prefix is
-    assumed on all routes defined on this router.
-     @property rootURL
-    @default '/'
-    @public
-  */
-  // Set with reopen to allow overriding via extend
-
-  /**
-   The `location` property determines the type of URL's that your
-    application will use.
-     The following location types are currently available:
-     * `history` - use the browser's history API to make the URLs look just like any standard URL
-    * `hash` - use `#` to separate the server part of the URL from the Ember part: `/blog/#/posts/new`
-    * `none` - do not store the Ember URL in the actual browser URL (mainly used for testing)
-    * `auto` - use the best option based on browser capabilities: `history` if possible, then `hash` if possible, otherwise `none`
-     This value is defaulted to `history` by the `locationType` setting of `/config/environment.js`
-     @property location
-    @default 'hash'
-    @see {Location}
-    @public
-  */
-  // Set with reopen to allow overriding via extend
-
-  _routerMicrolib;
-  _didSetupRouter = false;
-  _initialTransitionStarted = false;
-  currentURL = null;
-  currentRouteName = null;
-  currentPath = null;
-  currentRoute = null;
-  _qpCache = Object.create(null);
-
-  // Set of QueryParam['urlKey']
-  _qpUpdates = new Set();
-  _queuedQPChanges = {};
-  _bucketCache;
-  _toplevelView = null;
-  _handledErrors = new Set();
-  _engineInstances = Object.create(null);
-  _engineInfoByRoute = Object.create(null);
-  _routerService;
-  _slowTransitionTimer = null;
-  namespace;
-
-  // Begin Evented
-
-  // End Evented
-
-  // Set with reopenClass
-  static dslCallbacks;
-
-  /**
-    The `Router.map` function allows you to define mappings from URLs to routes
-    in your application. These mappings are defined within the
-    supplied callback function using `this.route`.
-     The first parameter is the name of the route which is used by default as the
-    path name as well.
-     The second parameter is the optional options hash. Available options are:
-       * `path`: allows you to provide your own path as well as mark dynamic
-        segments.
-      * `resetNamespace`: false by default; when nesting routes, ember will
-        combine the route names to form the fully-qualified route name, which is
-        used with `{{link-to}}` or manually transitioning to routes. Setting
-        `resetNamespace: true` will cause the route not to inherit from its
-        parent route's names. This is handy for preventing extremely long route names.
-        Keep in mind that the actual URL path behavior is still retained.
-     The third parameter is a function, which can be used to nest routes.
-    Nested routes, by default, will have the parent route tree's route name and
-    path prepended to it's own.
-     ```app/router.js
-    Router.map(function(){
-      this.route('post', { path: '/post/:post_id' }, function() {
-        this.route('edit');
-        this.route('comments', { resetNamespace: true }, function() {
-          this.route('new');
-        });
-      });
-    });
-    ```
-     @method map
-    @param callback
-    @public
-  */
-  static map(callback) {
-    if (!this.dslCallbacks) {
-      this.dslCallbacks = [];
-      // FIXME: Can we remove this?
-      this.reopenClass({
-        dslCallbacks: this.dslCallbacks
-      });
-    }
-    this.dslCallbacks.push(callback);
-    return this;
-  }
-  static _routePath(routeInfos) {
-    let path = [];
-
-    // We have to handle coalescing resource names that
-    // are prefixed with their parent's names, e.g.
-    // ['foo', 'foo.bar.baz'] => 'foo.bar.baz', not 'foo.foo.bar.baz'
-
-    function intersectionMatches(a1, a2) {
-      for (let i = 0; i < a1.length; ++i) {
-        if (a1[i] !== a2[i]) {
-          return false;
-        }
-      }
-      return true;
-    }
-    let name, nameParts, oldNameParts;
-    for (let i = 1; i < routeInfos.length; i++) {
-      let routeInfo = routeInfos[i];
-      (isDevelopingApp() && !(routeInfo) && assert('has routeInfo', routeInfo));
-      name = routeInfo.name;
-      nameParts = name.split('.');
-      oldNameParts = slice.call(path);
-      while (oldNameParts.length) {
-        if (intersectionMatches(oldNameParts, nameParts)) {
-          break;
-        }
-        oldNameParts.shift();
-      }
-      path.push(...nameParts.slice(oldNameParts.length));
-    }
-    return path.join('.');
-  }
-
-  // Note that owner is actually required in this scenario, but since it is strictly
-  // optional in other contexts trying to make it required here confuses TS.
-  constructor(owner) {
-    super(owner);
-    (isDevelopingApp() && !(owner) && assert('BUG: Missing owner', owner));
-    this._resetQueuedQueryParameterChanges();
-    this.namespace = owner.lookup('application:main');
-    let bucketCache = owner.lookup(privatize`-bucket-cache:main`);
-    (isDevelopingApp() && !(bucketCache instanceof BucketCache) && assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache));
-    this._bucketCache = bucketCache;
-    let routerService = owner.lookup('service:router');
-    (isDevelopingApp() && !(routerService !== undefined) && assert('BUG: RouterService should always be present', routerService !== undefined));
-    this._routerService = routerService;
-  }
-  _initRouterJs() {
-    let location = get(this, 'location');
-    let router = this;
-    const owner = getOwner$1(this);
-    (isDevelopingApp() && !(owner) && assert('Router is unexpectedly missing an owner', owner));
-    let seen = Object.create(null);
-    class PrivateRouter extends Router {
-      getRoute(name) {
-        let routeName = name;
-        let routeOwner = owner;
-        let engineInfo = router._engineInfoByRoute[routeName];
-        if (engineInfo) {
-          let engineInstance = router._getEngineInstance(engineInfo);
-          routeOwner = engineInstance;
-          routeName = engineInfo.localFullName;
-        }
-        let fullRouteName = `route:${routeName}`;
-        (isDevelopingApp() && !(routeOwner) && assert('Route is unexpectedly missing an owner', routeOwner));
-        let route = routeOwner.lookup(fullRouteName);
-        if (seen[name]) {
-          (isDevelopingApp() && !(route) && assert('seen routes should exist', route));
-          return route;
-        }
-        seen[name] = true;
-        if (!route) {
-          // SAFETY: this is configured in `commonSetupRegistry` in the
-          // `@ember/application/lib` package.
-          let DefaultRoute = routeOwner.factoryFor('route:basic').class;
-          routeOwner.register(fullRouteName, DefaultRoute.extend());
-          route = routeOwner.lookup(fullRouteName);
-          if (isDevelopingApp()) {
-            if (router.namespace.LOG_ACTIVE_GENERATION) {
-              info(`generated -> ${fullRouteName}`, {
-                fullName: fullRouteName
-              });
-            }
-          }
-        }
-        route._setRouteName(routeName);
-        if (engineInfo && !hasDefaultSerialize(route)) {
-          throw new Error('Defining a custom serialize method on an Engine route is not supported.');
-        }
-        return route;
-      }
-      getSerializer(name) {
-        let engineInfo = router._engineInfoByRoute[name];
-
-        // If this is not an Engine route, we fall back to the handler for serialization
-        if (!engineInfo) {
-          return;
-        }
-        return engineInfo.serializeMethod || defaultSerialize;
-      }
-      updateURL(path) {
-        once(() => {
-          location.setURL(path);
-          set(router, 'currentURL', path);
-        });
-      }
-
-      // TODO: merge into routeDidChange
-      didTransition(infos) {
-        (isDevelopingApp() && !(router.didTransition === defaultDidTransition) && assert('You attempted to override the "didTransition" method which has been deprecated. Please inject the router service and listen to the "routeDidChange" event.', router.didTransition === defaultDidTransition));
-        router.didTransition(infos);
-      }
-
-      // TODO: merge into routeWillChange
-      willTransition(oldInfos, newInfos) {
-        (isDevelopingApp() && !(router.willTransition === defaultWillTransition) && assert('You attempted to override the "willTransition" method which has been deprecated. Please inject the router service and listen to the "routeWillChange" event.', router.willTransition === defaultWillTransition));
-        router.willTransition(oldInfos, newInfos);
-      }
-      triggerEvent(routeInfos, ignoreFailure, name, args) {
-        return triggerEvent.bind(router)(routeInfos, ignoreFailure, name, args);
-      }
-      routeWillChange(transition) {
-        router.trigger('routeWillChange', transition);
-        if (isDevelopingApp()) {
-          freezeRouteInfo(transition);
-        }
-        router._routerService.trigger('routeWillChange', transition);
-
-        // in case of intermediate transition we update the current route
-        // to make router.currentRoute.name consistent with router.currentRouteName
-        // see https://github.com/emberjs/ember.js/issues/19449
-        if (transition.isIntermediate) {
-          router.set('currentRoute', transition.to);
-        }
-      }
-      routeDidChange(transition) {
-        router.set('currentRoute', transition.to);
-        once(() => {
-          router.trigger('routeDidChange', transition);
-          if (isDevelopingApp()) {
-            freezeRouteInfo(transition);
-          }
-          router._routerService.trigger('routeDidChange', transition);
-        });
-      }
-      transitionDidError(error, transition) {
-        if (error.wasAborted || transition.isAborted) {
-          // If the error was a transition erorr or the transition aborted
-          // log the abort.
-          return logAbort(transition);
-        } else {
-          // Otherwise trigger the "error" event to attempt an intermediate
-          // transition into an error substate
-          transition.trigger(false, 'error', error.error, transition, error.route);
-          if (router._isErrorHandled(error.error)) {
-            // If we handled the error with a substate just roll the state back on
-            // the transition and send the "routeDidChange" event for landing on
-            // the error substate and return the error.
-            transition.rollback();
-            this.routeDidChange(transition);
-            return error.error;
-          } else {
-            // If it was not handled, abort the transition completely and return
-            // the error.
-            transition.abort();
-            return error.error;
-          }
-        }
-      }
-      replaceURL(url) {
-        if (location.replaceURL) {
-          let doReplaceURL = () => {
-            location.replaceURL(url);
-            set(router, 'currentURL', url);
-          };
-          once(doReplaceURL);
-        } else {
-          this.updateURL(url);
-        }
-      }
-    }
-    let routerMicrolib = this._routerMicrolib = new PrivateRouter();
-    let dslCallbacks = this.constructor.dslCallbacks || [K];
-    let dsl = this._buildDSL();
-    dsl.route('application', {
-      path: '/',
-      resetNamespace: true,
-      overrideNameAssertion: true
-    }, function () {
-      for (let i = 0; i < dslCallbacks.length; i++) {
-        dslCallbacks[i].call(this);
-      }
-    });
-    if (isDevelopingApp()) {
-      if (this.namespace.LOG_TRANSITIONS_INTERNAL) {
-        routerMicrolib.log = console.log.bind(console); // eslint-disable-line no-console
-      }
-    }
-    routerMicrolib.map(dsl.generate());
-  }
-  _buildDSL() {
-    let enableLoadingSubstates = this._hasModuleBasedResolver();
-    let router = this;
-    const owner = getOwner$1(this);
-    (isDevelopingApp() && !(owner) && assert('Router is unexpectedly missing an owner', owner));
-    let options = {
-      enableLoadingSubstates,
-      resolveRouteMap(name) {
-        return owner.factoryFor(`route-map:${name}`);
-      },
-      addRouteForEngine(name, engineInfo) {
-        if (!router._engineInfoByRoute[name]) {
-          router._engineInfoByRoute[name] = engineInfo;
-        }
-      }
-    };
-    return new DSLImpl(null, options);
-  }
-
-  /*
-    Resets all pending query parameter changes.
-    Called after transitioning to a new route
-    based on query parameter changes.
-  */
-  _resetQueuedQueryParameterChanges() {
-    this._queuedQPChanges = {};
-  }
-  _hasModuleBasedResolver() {
-    let owner = getOwner$1(this);
-    (isDevelopingApp() && !(owner) && assert('Router is unexpectedly missing an owner', owner));
-    let resolver = get(owner, 'application.__registry__.resolver.moduleBasedResolver');
-    return Boolean(resolver);
-  }
-
-  /**
-    Initializes the current router instance and sets up the change handling
-    event listeners used by the instances `location` implementation.
-     A property named `initialURL` will be used to determine the initial URL.
-    If no value is found `/` will be used.
-     @method startRouting
-    @private
-  */
-  startRouting() {
-    if (this.setupRouter()) {
-      let initialURL = get(this, 'initialURL');
-      if (initialURL === undefined) {
-        initialURL = get(this, 'location').getURL();
-      }
-      let initialTransition = this.handleURL(initialURL);
-      if (initialTransition && initialTransition.error) {
-        throw initialTransition.error;
-      }
-    }
-  }
-  setupRouter() {
-    if (this._didSetupRouter) {
-      return false;
-    }
-    this._didSetupRouter = true;
-    this._setupLocation();
-    let location = get(this, 'location');
-
-    // Allow the Location class to cancel the router setup while it refreshes
-    // the page
-    if (get(location, 'cancelRouterSetup')) {
-      return false;
-    }
-    this._initRouterJs();
-    location.onUpdateURL(url => {
-      this.handleURL(url);
-    });
-    return true;
-  }
-  _setOutlets() {
-    // This is triggered async during Route#willDestroy.
-    // If the router is also being destroyed we do not want to
-    // to create another this._toplevelView (and leak the renderer)
-    if (this.isDestroying || this.isDestroyed) {
-      return;
-    }
-    let routeInfos = this._routerMicrolib.currentRouteInfos;
-    if (!routeInfos) {
-      return;
-    }
-    let root = null;
-    let parent = null;
-    for (let routeInfo of routeInfos) {
-      let route = routeInfo.route;
-      let render = getRenderState(route);
-      if (render) {
-        let state = {
-          render,
-          outlets: {
-            main: undefined
-          }
-        };
-        if (parent) {
-          parent.outlets.main = state;
-        } else {
-          root = state;
-        }
-        parent = state;
-      } else {
-        // It used to be that we would create a stub entry and keep traversing,
-        // but I don't think that is necessary anymore – if a parent route did
-        // not render, then the child routes have nowhere to render into these
-        // days. That wasn't always the case since in the past any route can
-        // render into any other route's outlets.
-        break;
-      }
-    }
-
-    // when a transitionTo happens after the validation phase
-    // during the initial transition _setOutlets is called
-    // when no routes are active. However, it will get called
-    // again with the correct values during the next turn of
-    // the runloop
-    if (root === null) {
-      return;
-    }
-    if (!this._toplevelView) {
-      let owner = getOwner$1(this);
-      (isDevelopingApp() && !(owner) && assert('Router is unexpectedly missing an owner', owner)); // SAFETY: we don't presently have any type registries internally to make
-      // this safe, so in each of these cases we assume that nothing *else* is
-      // registered at this `FullName`, and simply check to make sure that
-      // *something* is.
-      let OutletView = owner.factoryFor('view:-outlet');
-      (isDevelopingApp() && !(OutletView !== undefined) && assert('[BUG] unexpectedly missing `view:-outlet`', OutletView !== undefined));
-      let application = owner.lookup('application:main');
-      (isDevelopingApp() && !(application !== undefined) && assert('[BUG] unexpectedly missing `application:-main`', application !== undefined));
-      let environment = owner.lookup('-environment:main');
-      (isDevelopingApp() && !(environment !== undefined) && assert('[BUG] unexpectedly missing `-environment:main`', environment !== undefined));
-      let template = owner.lookup('template:-outlet');
-      (isDevelopingApp() && !(template !== undefined) && assert('[BUG] unexpectedly missing `template:-outlet`', template !== undefined));
-      this._toplevelView = OutletView.create({
-        environment,
-        template,
-        application
-      });
-      this._toplevelView.setOutletState(root);
-
-      // TODO(SAFETY): At least one test runs without this set correctly. At a
-      // later time, update the test to configure this correctly. The test ID:
-      // `Router Service - non application test:  RouterService#transitionTo with basic route`
-      let instance = owner.lookup('-application-instance:main');
-      // let instance = owner.lookup('-application-instance:main') as ApplicationInstance | undefined;
-      // assert('[BUG] unexpectedly missing `-application-instance:main`', instance !== undefined);
-
-      if (instance) {
-        // SAFETY: LOL. This is calling a deprecated API with a type that we
-        // cannot actually confirm at a type level *is* a `ViewMixin`. Seems:
-        // not great on multiple fronts!
-        instance.didCreateRootView(this._toplevelView);
-      }
-    } else {
-      this._toplevelView.setOutletState(root);
-    }
-  }
-  handleURL(url) {
-    // Until we have an ember-idiomatic way of accessing #hashes, we need to
-    // remove it because router.js doesn't know how to handle it.
-    let _url = url.split(/#(.+)?/)[0];
-    return this._doURLTransition('handleURL', _url);
-  }
-  _doURLTransition(routerJsMethod, url) {
-    this._initialTransitionStarted = true;
-    let transition = this._routerMicrolib[routerJsMethod](url || '/');
-    didBeginTransition(transition, this);
-    return transition;
-  }
-
-  /**
-    Transition the application into another route. The route may
-    be either a single route or route path:
-     @method transitionTo
-    @param {String} [name] the name of the route or a URL
-    @param {...Object} models the model(s) or identifier(s) to be used while
-      transitioning to the route.
-    @param {Object} [options] optional hash with a queryParams property
-      containing a mapping of query parameters
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @public
-  */
-  transitionTo(...args) {
-    if (resemblesURL(args[0])) {
-      (isDevelopingApp() && !(!this.isDestroying && !this.isDestroyed) && assert(`A transition was attempted from '${this.currentRouteName}' to '${args[0]}' but the application instance has already been destroyed.`, !this.isDestroying && !this.isDestroyed));
-      return this._doURLTransition('transitionTo', args[0]);
-    }
-    let {
-      routeName,
-      models,
-      queryParams
-    } = extractRouteArgs(args);
-    (isDevelopingApp() && !(!this.isDestroying && !this.isDestroyed) && assert(`A transition was attempted from '${this.currentRouteName}' to '${routeName}' but the application instance has already been destroyed.`, !this.isDestroying && !this.isDestroyed));
-    return this._doTransition(routeName, models, queryParams);
-  }
-  intermediateTransitionTo(name, ...args) {
-    this._routerMicrolib.intermediateTransitionTo(name, ...args);
-    updatePaths(this);
-    if (isDevelopingApp()) {
-      let infos = this._routerMicrolib.currentRouteInfos;
-      if (this.namespace.LOG_TRANSITIONS) {
-        (isDevelopingApp() && !(infos) && assert('expected infos to be set', infos)); // eslint-disable-next-line no-console
-        console.log(`Intermediate-transitioned into '${EmberRouter._routePath(infos)}'`);
-      }
-    }
-  }
-
-  /**
-    Similar to `transitionTo`, but instead of adding the destination to the browser's URL history,
-    it replaces the entry for the current route.
-    When the user clicks the "back" button in the browser, there will be fewer steps.
-    This is most commonly used to manage redirects in a way that does not cause confusing additions
-    to the user's browsing history.
-     @method replaceWith
-    @param {String} [name] the name of the route or a URL
-    @param {...Object} models the model(s) or identifier(s) to be used while
-      transitioning to the route.
-    @param {Object} [options] optional hash with a queryParams property
-      containing a mapping of query parameters
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @public
-  */
-  replaceWith(...args) {
-    return this.transitionTo(...args).method('replace');
-  }
-  generate(name, ...args) {
-    let url = this._routerMicrolib.generate(name, ...args);
-    (isDevelopingApp() && !(typeof this.location !== 'string') && assert('expected non-string location', typeof this.location !== 'string'));
-    return this.location.formatURL(url);
-  }
-
-  /**
-    Determines if the supplied route is currently active.
-     @method isActive
-    @param routeName
-    @return {Boolean}
-    @private
-  */
-  isActive(routeName) {
-    return this._routerMicrolib.isActive(routeName);
-  }
-
-  /**
-    An alternative form of `isActive` that doesn't require
-    manual concatenation of the arguments into a single
-    array.
-     @method isActiveIntent
-    @param routeName
-    @param models
-    @param queryParams
-    @return {Boolean}
-    @private
-    @since 1.7.0
-  */
-  isActiveIntent(routeName, models, queryParams) {
-    return this.currentState.isActiveIntent(routeName, models, queryParams);
-  }
-  send(name, ...args) {
-    /*name, context*/
-    this._routerMicrolib.trigger(name, ...args);
-  }
-
-  /**
-    Does this router instance have the given route.
-     @method hasRoute
-    @return {Boolean}
-    @private
-  */
-  hasRoute(route) {
-    return this._routerMicrolib.hasRoute(route);
-  }
-
-  /**
-    Resets the state of the router by clearing the current route
-    handlers and deactivating them.
-     @private
-    @method reset
-   */
-  reset() {
-    this._didSetupRouter = false;
-    this._initialTransitionStarted = false;
-    if (this._routerMicrolib) {
-      this._routerMicrolib.reset();
-    }
-  }
-  willDestroy() {
-    if (this._toplevelView) {
-      this._toplevelView.destroy();
-      this._toplevelView = null;
-    }
-    super.willDestroy();
-    this.reset();
-    let instances = this._engineInstances;
-    for (let name in instances) {
-      let instanceMap = instances[name];
-      (isDevelopingApp() && !(instanceMap) && assert('has instanceMap', instanceMap));
-      for (let id in instanceMap) {
-        let instance = instanceMap[id];
-        (isDevelopingApp() && !(instance) && assert('has instance', instance));
-        run(instance, 'destroy');
-      }
-    }
-  }
-
-  /*
-    Called when an active route's query parameter has changed.
-    These changes are batched into a runloop run and trigger
-    a single transition.
-  */
-  _activeQPChanged(queryParameterName, newValue) {
-    this._queuedQPChanges[queryParameterName] = newValue;
-    once(this, this._fireQueryParamTransition);
-  }
-
-  // The queryParameterName is QueryParam['urlKey']
-  _updatingQPChanged(queryParameterName) {
-    this._qpUpdates.add(queryParameterName);
-  }
-
-  /*
-    Triggers a transition to a route based on query parameter changes.
-    This is called once per runloop, to batch changes.
-     e.g.
-     if these methods are called in succession:
-    this._activeQPChanged('foo', '10');
-      // results in _queuedQPChanges = { foo: '10' }
-    this._activeQPChanged('bar', false);
-      // results in _queuedQPChanges = { foo: '10', bar: false }
-     _queuedQPChanges will represent both of these changes
-    and the transition using `transitionTo` will be triggered
-    once.
-  */
-  _fireQueryParamTransition() {
-    this.transitionTo({
-      queryParams: this._queuedQPChanges
-    });
-    this._resetQueuedQueryParameterChanges();
-  }
-  _setupLocation() {
-    let location = this.location;
-    let rootURL = this.rootURL;
-    let owner = getOwner$1(this);
-    (isDevelopingApp() && !(owner) && assert('Router is unexpectedly missing an owner', owner));
-    if ('string' === typeof location) {
-      let resolvedLocation = owner.lookup(`location:${location}`);
-      (isDevelopingApp() && !(resolvedLocation) && assert(`Could not resolve a location class at 'location:${location}'`, resolvedLocation));
-      location = set(this, 'location', resolvedLocation);
-    }
-    if (location !== null && typeof location === 'object') {
-      if (rootURL) {
-        set(location, 'rootURL', rootURL);
-      }
-
-      // ensure that initState is called AFTER the rootURL is set on
-      // the location instance
-      if (typeof location.initState === 'function') {
-        location.initState();
-      }
-    }
-  }
-
-  /**
-    Serializes the given query params according to their QP meta information.
-     @private
-    @method _serializeQueryParams
-    @param {Arrray<RouteInfo>} routeInfos
-    @param {Object} queryParams
-    @return {Void}
-  */
-  _serializeQueryParams(routeInfos, queryParams) {
-    forEachQueryParam(this, routeInfos, queryParams, (key, value, qp) => {
-      if (qp) {
-        delete queryParams[key];
-        queryParams[qp.urlKey] = qp.route.serializeQueryParam(value, qp.urlKey, qp.type);
-      } else if (value === undefined) {
-        return; // We don't serialize undefined values
-      } else {
-        queryParams[key] = this._serializeQueryParam(value, typeOf(value));
-      }
-    });
-  }
-
-  /**
-    Serializes the value of a query parameter based on a type
-     @private
-    @method _serializeQueryParam
-    @param {Object} value
-    @param {String} type
-  */
-  _serializeQueryParam(value, type) {
-    if (value === null || value === undefined) {
-      return value;
-    } else if (type === 'array') {
-      return JSON.stringify(value);
-    }
-    return `${value}`;
-  }
-
-  /**
-    Deserializes the given query params according to their QP meta information.
-     @private
-    @method _deserializeQueryParams
-    @param {Array<RouteInfo>} routeInfos
-    @param {Object} queryParams
-    @return {Void}
-  */
-  _deserializeQueryParams(routeInfos, queryParams) {
-    forEachQueryParam(this, routeInfos, queryParams, (key, value, qp) => {
-      // If we don't have QP meta info for a given key, then we do nothing
-      // because all values will be treated as strings
-      if (qp) {
-        delete queryParams[key];
-        queryParams[qp.prop] = qp.route.deserializeQueryParam(value, qp.urlKey, qp.type);
-      }
-    });
-  }
-
-  /**
-    Deserializes the value of a query parameter based on a default type
-     @private
-    @method _deserializeQueryParam
-    @param {Object} value
-    @param {String} defaultType
-  */
-  _deserializeQueryParam(value, defaultType) {
-    if (value === null || value === undefined) {
-      return value;
-    } else if (defaultType === 'boolean') {
-      return value === 'true';
-    } else if (defaultType === 'number') {
-      return Number(value).valueOf();
-    } else if (defaultType === 'array') {
-      return A(JSON.parse(value));
-    }
-    return value;
-  }
-
-  /**
-    Removes (prunes) any query params with default values from the given QP
-    object. Default values are determined from the QP meta information per key.
-     @private
-    @method _pruneDefaultQueryParamValues
-    @param {Array<RouteInfo>} routeInfos
-    @param {Object} queryParams
-    @return {Void}
-  */
-  _pruneDefaultQueryParamValues(routeInfos, queryParams) {
-    let qps = this._queryParamsFor(routeInfos);
-    for (let key in queryParams) {
-      let qp = qps.map[key];
-      if (qp && qp.serializedDefaultValue === queryParams[key]) {
-        delete queryParams[key];
-      }
-    }
-  }
-  _doTransition(_targetRouteName, models, _queryParams, _fromRouterService) {
-    let targetRouteName = _targetRouteName || getActiveTargetName(this._routerMicrolib);
-    (isDevelopingApp() && !(Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName)) && assert(`The route ${targetRouteName} was not found`, Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName)));
-    this._initialTransitionStarted = true;
-    let queryParams = {};
-    this._processActiveTransitionQueryParams(targetRouteName, models, queryParams, _queryParams);
-    Object.assign(queryParams, _queryParams);
-    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_fromRouterService));
-    let transition = this._routerMicrolib.transitionTo(targetRouteName, ...models, {
-      queryParams
-    });
-    didBeginTransition(transition, this);
-    return transition;
-  }
-  _processActiveTransitionQueryParams(targetRouteName, models, queryParams, _queryParams) {
-    // merge in any queryParams from the active transition which could include
-    // queryParams from the url on initial load.
-    if (!this._routerMicrolib.activeTransition) {
-      return;
-    }
-    let unchangedQPs = {};
-    let qpUpdates = this._qpUpdates;
-    let params = getFullQueryParams(this, this._routerMicrolib.activeTransition[STATE_SYMBOL]);
-    for (let key in params) {
-      if (!qpUpdates.has(key)) {
-        unchangedQPs[key] = params[key];
-      }
-    }
-
-    // We need to fully scope queryParams so that we can create one object
-    // that represents both passed-in queryParams and ones that aren't changed
-    // from the active transition.
-    this._fullyScopeQueryParams(targetRouteName, models, _queryParams);
-    this._fullyScopeQueryParams(targetRouteName, models, unchangedQPs);
-    Object.assign(queryParams, unchangedQPs);
-  }
-
-  /**
-    Prepares the query params for a URL or Transition. Restores any undefined QP
-    keys/values, serializes all values, and then prunes any default values.
-     @private
-    @method _prepareQueryParams
-    @param {String} targetRouteName
-    @param {Array<Object>} models
-    @param {Object} queryParams
-    @param {boolean} keepDefaultQueryParamValues
-    @return {Void}
-  */
-  _prepareQueryParams(targetRouteName, models, queryParams, _fromRouterService) {
-    let state = calculatePostTransitionState(this, targetRouteName, models);
-    this._hydrateUnsuppliedQueryParams(state, queryParams, Boolean(_fromRouterService));
-    this._serializeQueryParams(state.routeInfos, queryParams);
-    if (!_fromRouterService) {
-      this._pruneDefaultQueryParamValues(state.routeInfos, queryParams);
-    }
-  }
-
-  /**
-    Returns the meta information for the query params of a given route. This
-    will be overridden to allow support for lazy routes.
-     @private
-    @method _getQPMeta
-    @param {RouteInfo} routeInfo
-    @return {Object}
-  */
-  _getQPMeta(routeInfo) {
-    let route = routeInfo.route;
-    return route && get(route, '_qp');
-  }
-
-  /**
-    Returns a merged query params meta object for a given set of routeInfos.
-    Useful for knowing what query params are available for a given route hierarchy.
-     @private
-    @method _queryParamsFor
-    @param {Array<RouteInfo>} routeInfos
-    @return {Object}
-   */
-  _queryParamsFor(routeInfos) {
-    let routeInfoLength = routeInfos.length;
-    let leafRouteName = routeInfos[routeInfoLength - 1].name;
-    let cached = this._qpCache[leafRouteName];
-    if (cached !== undefined) {
-      return cached;
-    }
-    let shouldCache = true;
-    let map = {};
-    let qps = [];
-    let qpsByUrlKey = isDevelopingApp() ? {} : null;
-    let qpMeta;
-    let urlKey;
-    let qpOther;
-    for (let routeInfo of routeInfos) {
-      qpMeta = this._getQPMeta(routeInfo);
-      if (!qpMeta) {
-        shouldCache = false;
-        continue;
-      }
-
-      // Loop over each QP to make sure we don't have any collisions by urlKey
-      for (let qp of qpMeta.qps) {
-        if (isDevelopingApp()) {
-          urlKey = qp.urlKey;
-          qpOther = qpsByUrlKey[urlKey];
-          if (qpOther && qpOther.controllerName !== qp.controllerName) {
-            (isDevelopingApp() && !(false) && assert(`You're not allowed to have more than one controller property map to the same query param key, but both \`${qpOther.scopedPropertyName}\` and \`${qp.scopedPropertyName}\` map to \`${urlKey}\`. You can fix this by mapping one of the controller properties to a different query param key via the \`as\` config option, e.g. \`${qpOther.prop}: { as: 'other-${qpOther.prop}' }\``, false));
-          }
-          qpsByUrlKey[urlKey] = qp;
-        }
-        qps.push(qp);
-      }
-      Object.assign(map, qpMeta.map);
-    }
-    let finalQPMeta = {
-      qps,
-      map
-    };
-    if (shouldCache) {
-      this._qpCache[leafRouteName] = finalQPMeta;
-    }
-    return finalQPMeta;
-  }
-
-  /**
-    Maps all query param keys to their fully scoped property name of the form
-    `controllerName:propName`.
-     @private
-    @method _fullyScopeQueryParams
-    @param {String} leafRouteName
-    @param {Array<Object>} contexts
-    @param {Object} queryParams
-    @return {Void}
-  */
-  _fullyScopeQueryParams(leafRouteName, contexts, queryParams) {
-    let state = calculatePostTransitionState(this, leafRouteName, contexts);
-    let routeInfos = state.routeInfos;
-    let qpMeta;
-    for (let routeInfo of routeInfos) {
-      qpMeta = this._getQPMeta(routeInfo);
-      if (!qpMeta) {
-        continue;
-      }
-      for (let qp of qpMeta.qps) {
-        let presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
-        if (presentProp) {
-          if (presentProp !== qp.scopedPropertyName) {
-            queryParams[qp.scopedPropertyName] = queryParams[presentProp];
-            delete queryParams[presentProp];
-          }
-        }
-      }
-    }
-  }
-
-  /**
-    Hydrates (adds/restores) any query params that have pre-existing values into
-    the given queryParams hash. This is what allows query params to be "sticky"
-    and restore their last known values for their scope.
-     @private
-    @method _hydrateUnsuppliedQueryParams
-    @param {TransitionState} state
-    @param {Object} queryParams
-    @return {Void}
-  */
-  _hydrateUnsuppliedQueryParams(state, queryParams, _fromRouterService) {
-    let routeInfos = state.routeInfos;
-    let appCache = this._bucketCache;
-    let qpMeta;
-    let qp;
-    let presentProp;
-    for (let routeInfo of routeInfos) {
-      qpMeta = this._getQPMeta(routeInfo);
-      if (!qpMeta) {
-        continue;
-      }
-
-      // Needs to stay for index loop to avoid throwIfClosureRequired
-      for (let j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
-        qp = qpMeta.qps[j];
-        (isDevelopingApp() && !(qp) && assert('expected qp', qp));
-        presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
-        (isDevelopingApp() && !(function () {
-          if (qp.urlKey === presentProp || qp.scopedPropertyName === presentProp) {
-            return true;
-          }
-          if (_fromRouterService && presentProp !== false && qp.urlKey !== qp.prop) {
-            // assumptions (mainly from current transitionTo_test):
-            // - this is only supposed to be run when there is an alias to a query param and the alias is used to set the param
-            // - when there is no alias: qp.urlKey == qp.prop
-            return false;
-          }
-          return true;
-        }()) && assert(`You passed the \`${presentProp}\` query parameter during a transition into ${qp.route.routeName}, please update to ${qp.urlKey}`, function () {
-          if (qp.urlKey === presentProp || qp.scopedPropertyName === presentProp) {
-            return true;
-          }
-          if (_fromRouterService && presentProp !== false && qp.urlKey !== qp.prop) {
-            return false;
-          }
-          return true;
-        }()));
-        if (presentProp) {
-          if (presentProp !== qp.scopedPropertyName) {
-            queryParams[qp.scopedPropertyName] = queryParams[presentProp];
-            delete queryParams[presentProp];
-          }
-        } else {
-          let cacheKey = calculateCacheKey(qp.route.fullRouteName, qp.parts, state.params);
-          (isDevelopingApp() && !(appCache) && assert('ROUTER BUG: expected appCache to be defined. This is an internal bug, please open an issue on Github if you see this message!', appCache));
-          queryParams[qp.scopedPropertyName] = appCache.lookup(cacheKey, qp.prop, qp.defaultValue);
-        }
-      }
-    }
-  }
-  _scheduleLoadingEvent(transition, originRoute) {
-    this._cancelSlowTransitionTimer();
-    this._slowTransitionTimer = scheduleOnce('routerTransitions', this, this._handleSlowTransition, transition, originRoute);
-  }
-  currentState = null;
-  targetState = null;
-  _handleSlowTransition(transition, originRoute) {
-    if (!this._routerMicrolib.activeTransition) {
-      // Don't fire an event if we've since moved on from
-      // the transition that put us in a loading state.
-      return;
-    }
-    let targetState = new RouterState(this, this._routerMicrolib, this._routerMicrolib.activeTransition[STATE_SYMBOL]);
-    this.set('targetState', targetState);
-    transition.trigger(true, 'loading', transition, originRoute);
-  }
-  _cancelSlowTransitionTimer() {
-    if (this._slowTransitionTimer) {
-      cancel(this._slowTransitionTimer);
-    }
-    this._slowTransitionTimer = null;
-  }
-
-  // These three helper functions are used to ensure errors aren't
-  // re-raised if they're handled in a route's error action.
-  _markErrorAsHandled(error) {
-    this._handledErrors.add(error);
-  }
-  _isErrorHandled(error) {
-    return this._handledErrors.has(error);
-  }
-  _clearHandledError(error) {
-    this._handledErrors.delete(error);
-  }
-  _getEngineInstance({
-    name,
-    instanceId,
-    mountPoint
-  }) {
-    let engineInstances = this._engineInstances;
-    let namedInstances = engineInstances[name];
-    if (!namedInstances) {
-      namedInstances = Object.create(null);
-      engineInstances[name] = namedInstances;
-    }
-
-    // We just set these!
-    (isDevelopingApp() && !(namedInstances) && assert('has namedInstances', namedInstances));
-    let engineInstance = namedInstances[instanceId];
-    if (!engineInstance) {
-      let owner = getOwner$1(this);
-      (isDevelopingApp() && !(owner instanceof EmberEngineInstance) && assert('Expected router to have EngineInstance as owner', owner instanceof EmberEngineInstance));
-      (isDevelopingApp() && !(owner.hasRegistration(`engine:${name}`)) && assert(`You attempted to mount the engine '${name}' in your router map, but the engine can not be found.`, owner.hasRegistration(`engine:${name}`)));
-      engineInstance = owner.buildChildEngineInstance(name, {
-        routable: true,
-        mountPoint
-      });
-      engineInstance.boot();
-      namedInstances[instanceId] = engineInstance;
-    }
-    return engineInstance;
-  }
-
-  /**
-    Handles updating the paths and notifying any listeners of the URL
-    change.
-     Triggers the router level `didTransition` hook.
-     For example, to notify google analytics when the route changes,
-    you could use this hook.  (Note: requires also including GA scripts, etc.)
-     ```javascript
-    import config from './config/environment';
-    import EmberRouter from '@ember/routing/router';
-    import { service } from '@ember/service';
-     let Router = EmberRouter.extend({
-      location: config.locationType,
-       router: service(),
-       didTransition: function() {
-        this._super(...arguments);
-         ga('send', 'pageview', {
-          page: this.router.currentURL,
-          title: this.router.currentRouteName,
-        });
-      }
-    });
-    ```
-     @method didTransition
-    @private
-    @since 1.2.0
-  */
-  // Set with reopen to allow overriding via extend
-
-  /**
-    Handles notifying any listeners of an impending URL
-    change.
-     Triggers the router level `willTransition` hook.
-     @method willTransition
-    @private
-    @since 1.11.0
-  */
-  // Set with reopen to allow overriding via extend
-
-  /**
-   Represents the current URL.
-     @property url
-    @type {String}
-    @private
-  */
-  // Set with reopen to allow overriding via extend
-}
-
-/*
-  Helper function for iterating over routes in a set of routeInfos that are
-  at or above the given origin route. Example: if `originRoute` === 'foo.bar'
-  and the routeInfos given were for 'foo.bar.baz', then the given callback
-  will be invoked with the routes for 'foo.bar', 'foo', and 'application'
-  individually.
-
-  If the callback returns anything other than `true`, then iteration will stop.
-
-  @private
-  @param {Route} originRoute
-  @param {Array<RouteInfo>} routeInfos
-  @param {Function} callback
-  @return {Void}
- */
-function forEachRouteAbove(routeInfos, callback) {
-  for (let i = routeInfos.length - 1; i >= 0; --i) {
-    let routeInfo = routeInfos[i];
-    (isDevelopingApp() && !(routeInfo) && assert('has routeInfo', routeInfo));
-    let route = routeInfo.route;
-
-    // routeInfo.handler being `undefined` generally means either:
-    //
-    // 1. an error occurred during creation of the route in question
-    // 2. the route is across an async boundary (e.g. within an engine)
-    //
-    // In both of these cases, we cannot invoke the callback on that specific
-    // route, because it just doesn't exist...
-    if (route === undefined) {
-      continue;
-    }
-    if (callback(route, routeInfo) !== true) {
-      return;
-    }
-  }
-}
-
-// These get invoked when an action bubbles above ApplicationRoute
-// and are not meant to be overridable.
-let defaultActionHandlers = {
-  willResolveModel(_routeInfos, transition, originRoute) {
-    this._scheduleLoadingEvent(transition, originRoute);
-  },
-  // Attempt to find an appropriate error route or substate to enter.
-  error(routeInfos, error, transition) {
-    let router = this;
-    let routeInfoWithError = routeInfos[routeInfos.length - 1];
-    forEachRouteAbove(routeInfos, (route, routeInfo) => {
-      // We don't check the leaf most routeInfo since that would
-      // technically be below where we're at in the route hierarchy.
-      if (routeInfo !== routeInfoWithError) {
-        // Check for the existence of an 'error' route.
-        let errorRouteName = findRouteStateName(route, 'error');
-        if (errorRouteName) {
-          router._markErrorAsHandled(error);
-          router.intermediateTransitionTo(errorRouteName, error);
-          return false;
-        }
-      }
-
-      // Check for an 'error' substate route
-      let errorSubstateName = findRouteSubstateName(route, 'error');
-      if (errorSubstateName) {
-        router._markErrorAsHandled(error);
-        router.intermediateTransitionTo(errorSubstateName, error);
-        return false;
-      }
-      return true;
-    });
-    logError(error, `Error while processing route: ${transition.targetName}`);
-  },
-  // Attempt to find an appropriate loading route or substate to enter.
-  loading(routeInfos, transition) {
-    let router = this;
-    let routeInfoWithSlowLoading = routeInfos[routeInfos.length - 1];
-    forEachRouteAbove(routeInfos, (route, routeInfo) => {
-      // We don't check the leaf most routeInfos since that would
-      // technically be below where we're at in the route hierarchy.
-      if (routeInfo !== routeInfoWithSlowLoading) {
-        // Check for the existence of a 'loading' route.
-        let loadingRouteName = findRouteStateName(route, 'loading');
-        if (loadingRouteName) {
-          router.intermediateTransitionTo(loadingRouteName);
-          return false;
-        }
-      }
-
-      // Check for loading substate
-      let loadingSubstateName = findRouteSubstateName(route, 'loading');
-      if (loadingSubstateName) {
-        router.intermediateTransitionTo(loadingSubstateName);
-        return false;
-      }
-
-      // Don't bubble above pivot route.
-      return transition.pivotHandler !== route;
-    });
-  }
-};
-function logError(_error, initialMessage) {
-  let errorArgs = [];
-  let error;
-  if (_error && typeof _error === 'object' && typeof _error.errorThrown === 'object') {
-    error = _error.errorThrown;
-  } else {
-    error = _error;
-  }
-  if (initialMessage) {
-    errorArgs.push(initialMessage);
-  }
-  if (error) {
-    if (error.message) {
-      errorArgs.push(error.message);
-    }
-    if (error.stack) {
-      errorArgs.push(error.stack);
-    }
-    if (typeof error === 'string') {
-      errorArgs.push(error);
-    }
-  }
-  console.error(...errorArgs); //eslint-disable-line no-console
-}
-
-/**
-  Finds the name of the substate route if it exists for the given route. A
-  substate route is of the form `route_state`, such as `foo_loading`.
-
-  @private
-  @param {Route} route
-  @param {String} state
-  @return {String}
-*/
-function findRouteSubstateName(route, state) {
-  let owner = getOwner$1(route);
-  (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-  let {
-    routeName,
-    fullRouteName,
-    _router: router
-  } = route;
-  let substateName = `${routeName}_${state}`;
-  let substateNameFull = `${fullRouteName}_${state}`;
-  return routeHasBeenDefined(owner, router, substateName, substateNameFull) ? substateNameFull : '';
-}
-
-/**
-  Finds the name of the state route if it exists for the given route. A state
-  route is of the form `route.state`, such as `foo.loading`. Properly Handles
-  `application` named routes.
-
-  @private
-  @param {Route} route
-  @param {String} state
-  @return {String}
-*/
-function findRouteStateName(route, state) {
-  let owner = getOwner$1(route);
-  (isDevelopingApp() && !(owner) && assert('Route is unexpectedly missing an owner', owner));
-  let {
-    routeName,
-    fullRouteName,
-    _router: router
-  } = route;
-  let stateName = routeName === 'application' ? state : `${routeName}.${state}`;
-  let stateNameFull = fullRouteName === 'application' ? state : `${fullRouteName}.${state}`;
-  return routeHasBeenDefined(owner, router, stateName, stateNameFull) ? stateNameFull : '';
-}
-
-/**
-  Determines whether or not a route has been defined by checking that the route
-  is in the Router's map and the owner has a registration for that route.
-
-  @private
-  @param {Owner} owner
-  @param {Router} router
-  @param {String} localName
-  @param {String} fullName
-  @return {Boolean}
-*/
-function routeHasBeenDefined(owner, router, localName, fullName) {
-  let routerHasRoute = router.hasRoute(fullName);
-  let ownerHasRoute = owner.factoryFor(`template:${localName}`) || owner.factoryFor(`route:${localName}`);
-  return routerHasRoute && ownerHasRoute;
-}
-function triggerEvent(routeInfos, ignoreFailure, name, args) {
-  if (!routeInfos) {
-    if (ignoreFailure) {
-      return;
-    }
-    // TODO: update?
-    throw new Error(`Can't trigger action '${name}' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call \`.send()\` on the \`Transition\` object passed to the \`model/beforeModel/afterModel\` hooks.`);
-  }
-  let eventWasHandled = false;
-  let routeInfo, handler, actionHandler;
-  for (let i = routeInfos.length - 1; i >= 0; i--) {
-    routeInfo = routeInfos[i];
-    (isDevelopingApp() && !(routeInfo) && assert('[BUG] Missing routeInfo', routeInfo));
-    handler = routeInfo.route;
-    actionHandler = handler && handler.actions && handler.actions[name];
-    if (actionHandler) {
-      if (actionHandler.apply(handler, args) === true) {
-        eventWasHandled = true;
-      } else {
-        // Should only hit here if a non-bubbling error action is triggered on a route.
-        if (name === 'error') {
-          (isDevelopingApp() && !(handler) && assert('[BUG] Missing handler', handler));
-          handler._router._markErrorAsHandled(args[0]);
-        }
-        return;
-      }
-    }
-  }
-  let defaultHandler = defaultActionHandlers[name];
-  if (defaultHandler) {
-    defaultHandler.call(this, routeInfos, ...args);
-    return;
-  }
-  if (!eventWasHandled && !ignoreFailure) {
-    throw new Error(`Nothing handled the action '${name}'. If you did handle the action, this error can be caused by returning true from an action handler in a controller, causing the action to bubble.`);
-  }
-}
-function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {
-  let state = emberRouter._routerMicrolib.applyIntent(leafRouteName, contexts);
-  let {
-    routeInfos,
-    params
-  } = state;
-  for (let routeInfo of routeInfos) {
-    // If the routeInfo is not resolved, we serialize the context into params
-    if (!routeInfo.isResolved) {
-      params[routeInfo.name] = routeInfo.serialize(routeInfo.context);
-    } else {
-      params[routeInfo.name] = routeInfo.params;
-    }
-  }
-  return state;
-}
-function updatePaths(router) {
-  let infos = router._routerMicrolib.currentRouteInfos;
-  if (infos.length === 0) {
-    return;
-  }
-  let path = EmberRouter._routePath(infos);
-  let info = infos[infos.length - 1];
-  (isDevelopingApp() && !(info) && assert('expected info', info));
-  let currentRouteName = info.name;
-  let location = router.location;
-  (isDevelopingApp() && !(typeof location !== 'string') && assert('expected location to not be a string', typeof location !== 'string'));
-  let currentURL = location.getURL();
-  set(router, 'currentPath', path);
-  set(router, 'currentRouteName', currentRouteName);
-  set(router, 'currentURL', currentURL);
-}
-function didBeginTransition(transition, router) {
-  let routerState = new RouterState(router, router._routerMicrolib, transition[STATE_SYMBOL]);
-  if (!router.currentState) {
-    router.set('currentState', routerState);
-  }
-  router.set('targetState', routerState);
-  transition.promise = transition.catch(error => {
-    if (router._isErrorHandled(error)) {
-      router._clearHandledError(error);
-    } else {
-      throw error;
-    }
-  }, 'Transition Error');
-}
-function forEachQueryParam(router, routeInfos, queryParams, callback) {
-  let qpCache = router._queryParamsFor(routeInfos);
-  for (let key in queryParams) {
-    if (!Object.prototype.hasOwnProperty.call(queryParams, key)) {
-      continue;
-    }
-    let value = queryParams[key];
-    let qp = qpCache.map[key];
-    callback(key, value, qp);
-  }
-}
-EmberRouter.reopen({
-  didTransition: defaultDidTransition,
-  willTransition: defaultWillTransition,
-  rootURL: '/',
-  location: 'hash',
-  // FIXME: Does this need to be overrideable via extend?
-  url: computed(function () {
-    let location = get(this, 'location');
-    if (typeof location === 'string') {
-      return undefined;
-    }
-    return location.getURL();
-  })
-});
-const EmberRouter$1 = EmberRouter;
-
-/**
- * @module @ember/routing/router-service
- */
-const ROUTER = Symbol('ROUTER');
-function cleanURL(url, rootURL) {
-  if (rootURL === '/') {
-    return url;
-  }
-  return url.substring(rootURL.length);
-}
-
-/**
-   The Router service is the public API that provides access to the router.
-
-   The immediate benefit of the Router service is that you can inject it into components,
-   giving them a friendly way to initiate transitions and ask questions about the current
-   global router state.
-
-   In this example, the Router service is injected into a component to initiate a transition
-   to a dedicated route:
-
-   ```app/components/example.js
-   import Component from '@glimmer/component';
-   import { action } from '@ember/object';
-   import { service } from '@ember/service';
-
-   export default class ExampleComponent extends Component {
-     @service router;
-
-     @action
-     next() {
-       this.router.transitionTo('other.route');
-     }
-   }
-   ```
-
-   Like any service, it can also be injected into helpers, routes, etc.
-
-   @public
-   @extends Service
-   @class RouterService
- */
-
-class RouterService extends Service.extend(Evented) {
-  [ROUTER];
-  get _router() {
-    let router = this[ROUTER];
-    if (router !== undefined) {
-      return router;
-    }
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('RouterService is unexpectedly missing an owner', owner));
-    let _router = owner.lookup('router:main');
-    (isDevelopingApp() && !(_router instanceof EmberRouter$1) && assert('ROUTER SERVICE BUG: Expected router to be an instance of EmberRouter', _router instanceof EmberRouter$1));
-    return this[ROUTER] = _router;
-  }
-  willDestroy() {
-    super.willDestroy();
-    this[ROUTER] = undefined;
-  }
-
-  /**
-     Transition the application into another route. The route may
-     be either a single route or route path:
-      Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
-     This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
-     See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
-      In the following example we use the Router service to navigate to a route with a
-     specific model from a Component in the first action, and in the second we trigger
-     a query-params only transition.
-      ```app/components/example.js
-     import Component from '@glimmer/component';
-     import { action } from '@ember/object';
-     import { service } from '@ember/service';
-      export default class extends Component {
-       @service router;
-        @action
-       goToComments(post) {
-         this.router.transitionTo('comments', post);
-       }
-        @action
-       fetchMoreComments(latestComment) {
-         this.router.transitionTo({
-           queryParams: { commentsAfter: latestComment }
-         });
-       }
-     }
-     ```
-      @method transitionTo
-     @param {String} [routeNameOrUrl] the name of the route or a URL
-     @param {...Object} [models] the model(s) or identifier(s) to be used while
-       transitioning to the route.
-     @param {Object} [options] optional hash with a queryParams property
-       containing a mapping of query parameters. May be supplied as the only
-      parameter to trigger a query-parameter-only transition.
-     @return {Transition} the transition object associated with this
-       attempted transition
-     @public
-   */
-  transitionTo(...args) {
-    if (resemblesURL(args[0])) {
-      // NOTE: this `args[0] as string` cast is safe and TS correctly infers it
-      // in 3.6+, so it can be removed when TS is upgraded.
-      return this._router._doURLTransition('transitionTo', args[0]);
-    }
-    let {
-      routeName,
-      models,
-      queryParams
-    } = extractRouteArgs(args);
-    let transition = this._router._doTransition(routeName, models, queryParams, true);
-    return transition;
-  }
-
-  /**
-     Similar to `transitionTo`, but instead of adding the destination to the browser's URL history,
-     it replaces the entry for the current route.
-     When the user clicks the "back" button in the browser, there will be fewer steps.
-     This is most commonly used to manage redirects in a way that does not cause confusing additions
-     to the user's browsing history.
-      Calling `replaceWith` from the Router service will cause default query parameter values to be included in the URL.
-     This behavior is different from calling `replaceWith` on a route.
-     See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
-      Usage example:
-      ```app/routes/application.js
-     import Route from '@ember/routing/route';
-     import { service } from '@ember/service';
-      export default class extends Route {
-       @service router;
-       beforeModel() {
-         if (!authorized()){
-           this.router.replaceWith('unauthorized');
-         }
-       }
-     });
-     ```
-      @method replaceWith
-     @param {String} routeNameOrUrl the name of the route or a URL of the desired destination
-     @param {...Object} models the model(s) or identifier(s) to be used while
-       transitioning to the route i.e. an object of params to pass to the destination route
-     @param {Object} [options] optional hash with a queryParams property
-       containing a mapping of query parameters
-     @return {Transition} the transition object associated with this
-       attempted transition
-     @public
-   */
-  replaceWith(...args) {
-    return this.transitionTo(...args).method('replace');
-  }
-
-  /**
-    Generate a URL based on the supplied route name and optionally a model. The
-    URL is returned as a string that can be used for any purpose.
-     In this example, the URL for the `author.books` route for a given author
-    is copied to the clipboard.
-     ```app/templates/application.hbs
-    <CopyLink @author={{hash id="tomster" name="Tomster"}} />
-    ```
-     ```app/components/copy-link.js
-    import Component from '@glimmer/component';
-    import { service } from '@ember/service';
-    import { action } from '@ember/object';
-     export default class CopyLinkComponent extends Component {
-      @service router;
-      @service clipboard;
-       @action
-      copyBooksURL() {
-        if (this.author) {
-          const url = this.router.urlFor('author.books', this.args.author);
-          this.clipboard.set(url);
-          // Clipboard now has /author/tomster/books
-        }
-      }
-    }
-    ```
-     Just like with `transitionTo` and `replaceWith`, `urlFor` can also handle
-    query parameters.
-     ```app/templates/application.hbs
-    <CopyLink @author={{hash id="tomster" name="Tomster"}} />
-    ```
-     ```app/components/copy-link.js
-    import Component from '@glimmer/component';
-    import { service } from '@ember/service';
-    import { action } from '@ember/object';
-     export default class CopyLinkComponent extends Component {
-      @service router;
-      @service clipboard;
-       @action
-      copyOnlyEmberBooksURL() {
-        if (this.author) {
-          const url = this.router.urlFor('author.books', this.author, {
-            queryParams: { filter: 'emberjs' }
-          });
-          this.clipboard.set(url);
-          // Clipboard now has /author/tomster/books?filter=emberjs
-        }
-      }
-    }
-    ```
-      @method urlFor
-     @param {String} routeName the name of the route
-     @param {...Object} models the model(s) for the route.
-     @param {Object} [options] optional hash with a queryParams property
-       containing a mapping of query parameters
-     @return {String} the string representing the generated URL
-     @public
-   */
-  urlFor(routeName, ...args) {
-    this._router.setupRouter();
-    return this._router.generate(routeName, ...args);
-  }
-
-  /**
-     Returns `true` if `routeName/models/queryParams` is the active route, where `models` and `queryParams` are optional.
-     See [model](api/ember/release/classes/Route/methods/model?anchor=model) and
-     [queryParams](/api/ember/3.7/classes/Route/properties/queryParams?anchor=queryParams) for more information about these arguments.
-      In the following example, `isActive` will return `true` if the current route is `/posts`.
-      ```app/components/posts.js
-     import Component from '@glimmer/component';
-     import { service } from '@ember/service';
-      export default class extends Component {
-       @service router;
-        displayComments() {
-         return this.router.isActive('posts');
-       }
-     });
-     ```
-      The next example includes a dynamic segment, and will return `true` if the current route is `/posts/1`,
-     assuming the post has an id of 1:
-      ```app/components/posts.js
-     import Component from '@glimmer/component';
-     import { service } from '@ember/service';
-      export default class extends Component {
-       @service router;
-        displayComments(post) {
-         return this.router.isActive('posts', post.id);
-       }
-     });
-     ```
-      Where `post.id` is the id of a specific post, which is represented in the route as /posts/[post.id].
-     If `post.id` is equal to 1, then isActive will return true if the current route is /posts/1, and false if the route is anything else.
-      @method isActive
-     @param {String} routeName the name of the route
-     @param {...Object} models the model(s) or identifier(s) to be used when determining the active route.
-     @param {Object} [options] optional hash with a queryParams property
-       containing a mapping of query parameters
-     @return {boolean} true if the provided routeName/models/queryParams are active
-     @public
-   */
-  isActive(...args) {
-    let {
-      routeName,
-      models,
-      queryParams
-    } = extractRouteArgs(args);
-    let routerMicrolib = this._router._routerMicrolib;
-
-    // When using isActive() in a getter, we want to entagle with the auto-tracking system
-    // for example,
-    // in
-    // get isBarActive() {
-    //   return isActive('foo.bar');
-    // }
-    //
-    // you'd expect isBarActive to be dirtied when the route changes.
-    //
-    // https://github.com/emberjs/ember.js/issues/19004
-    consumeTag(tagFor(this._router, 'currentURL'));
-
-    // UNSAFE: casting `routeName as string` here encodes the existing
-    // assumption but may be wrong: `extractRouteArgs` correctly returns it as
-    // `string | undefined`. There may be bugs if `isActiveIntent` does
-    // not correctly account for `undefined` values for `routeName`. Spoilers:
-    // it *does not* account for this being `undefined`.
-    if (!routerMicrolib.isActiveIntent(routeName, models)) {
-      return false;
-    }
-    let hasQueryParams = Object.keys(queryParams).length > 0;
-    if (hasQueryParams) {
-      // UNSAFE: casting `routeName as string` here encodes the existing
-      // assumption but may be wrong: `extractRouteArgs` correctly returns it
-      // as `string | undefined`. There may be bugs if `_prepareQueryParams`
-      // does not correctly account for `undefined` values for `routeName`.
-      //  Spoilers: under the hood this currently uses router.js APIs which
-      // *do not* account for this being `undefined`.
-      let targetRouteName = routeName;
-      queryParams = Object.assign({}, queryParams);
-      this._router._prepareQueryParams(targetRouteName, models, queryParams, true /* fromRouterService */);
-      let currentQueryParams = Object.assign({}, routerMicrolib.state.queryParams);
-      this._router._prepareQueryParams(targetRouteName, models, currentQueryParams, true /* fromRouterService */);
-      return shallowEqual(queryParams, currentQueryParams);
-    }
-    return true;
-  }
-
-  /**
-     Takes a string URL and returns a `RouteInfo` for the leafmost route represented
-     by the URL. Returns `null` if the URL is not recognized. This method expects to
-     receive the actual URL as seen by the browser including the app's `rootURL`.
-      See [RouteInfo](/ember/release/classes/RouteInfo) for more info.
-      In the following example `recognize` is used to verify if a path belongs to our
-     application before transitioning to it.
-      ```
-     import Component from '@ember/component';
-     import { service } from '@ember/service';
-      export default class extends Component {
-       @service router;
-       path = '/';
-        click() {
-         if (this.router.recognize(this.path)) {
-           this.router.transitionTo(this.path);
-         }
-       }
-     }
-     ```
-       @method recognize
-      @param {String} url
-      @return {RouteInfo | null}
-      @public
-    */
-  recognize(url) {
-    (isDevelopingApp() && !(url.indexOf(this.rootURL) === 0) && assert(`You must pass a url that begins with the application's rootURL "${this.rootURL}"`, url.indexOf(this.rootURL) === 0));
-    this._router.setupRouter();
-    let internalURL = cleanURL(url, this.rootURL);
-    return this._router._routerMicrolib.recognize(internalURL);
-  }
-
-  /**
-    Takes a string URL and returns a promise that resolves to a
-    `RouteInfoWithAttributes` for the leafmost route represented by the URL.
-    The promise rejects if the URL is not recognized or an unhandled exception
-    is encountered. This method expects to receive the actual URL as seen by
-    the browser including the app's `rootURL`.
-       @method recognizeAndLoad
-      @param {String} url
-      @return {RouteInfo}
-      @public
-   */
-  recognizeAndLoad(url) {
-    (isDevelopingApp() && !(url.indexOf(this.rootURL) === 0) && assert(`You must pass a url that begins with the application's rootURL "${this.rootURL}"`, url.indexOf(this.rootURL) === 0));
-    this._router.setupRouter();
-    let internalURL = cleanURL(url, this.rootURL);
-    return this._router._routerMicrolib.recognizeAndLoad(internalURL);
-  }
-
-  /**
-    You can register a listener for events emitted by this service with `.on()`:
-     ```app/routes/contact-form.js
-    import Route from '@ember/routing';
-    import { service } from '@ember/service';
-     export default class extends Route {
-      @service router;
-       activate() {
-        this.router.on('routeWillChange', (transition) => {
-          if (!transition.to.find(route => route.name === this.routeName)) {
-            alert("Please save or cancel your changes.");
-            transition.abort();
-          }
-        })
-      }
-    }
-    ```
-     @method on
-    @param {String} eventName
-    @param {Function} callback
-    @public
-  */
-
-  /**
-    You can unregister a listener for events emitted by this service with `.off()`:
-     ```app/routes/contact-form.js
-    import Route from '@ember/routing';
-    import { service } from '@ember/service';
-     export default class ContactFormRoute extends Route {
-      @service router;
-       callback = (transition) => {
-        if (!transition.to.find(route => route.name === this.routeName)) {
-          alert('Please save or cancel your changes.');
-          transition.abort();
-        }
-      };
-       activate() {
-        this.router.on('routeWillChange', this.callback);
-      }
-       deactivate() {
-        this.router.off('routeWillChange', this.callback);
-      }
-    }
-    ```
-     @method off
-    @param {String} eventName
-    @param {Function} callback
-    @public
-  */
-
-  /**
-    The `routeWillChange` event is fired at the beginning of any
-    attempted transition with a `Transition` object as the sole
-    argument. This action can be used for aborting, redirecting,
-    or decorating the transition from the currently active routes.
-     A good example is preventing navigation when a form is
-    half-filled out:
-     ```app/routes/contact-form.js
-    import Route from '@ember/routing';
-    import { service } from '@ember/service';
-     export default class extends Route {
-      @service router;
-       activate() {
-        this.router.on('routeWillChange', (transition) => {
-          if (!transition.to.find(route => route.name === this.routeName)) {
-            alert("Please save or cancel your changes.");
-            transition.abort();
-          }
-        })
-      }
-    }
-    ```
-     The `routeWillChange` event fires whenever a new route is chosen as the desired target of a transition. This includes `transitionTo`, `replaceWith`, all redirection for any reason including error handling, and abort. Aborting implies changing the desired target back to where you already were. Once a transition has completed, `routeDidChange` fires.
-     @event routeWillChange
-    @param {Transition} transition
-    @public
-  */
-
-  /**
-    The `routeDidChange` event only fires once a transition has settled.
-    This includes aborts and error substates. Like the `routeWillChange` event
-    it receives a Transition as the sole argument.
-     A good example is sending some analytics when the route has transitioned:
-     ```app/routes/contact-form.js
-    import Route from '@ember/routing';
-    import { service } from '@ember/service';
-     export default class extends Route {
-      @service router;
-       activate() {
-        this.router.on('routeDidChange', (transition) => {
-          ga.send('pageView', {
-            current: transition.to.name,
-            from: transition.from.name
-          });
-        })
-      }
-    }
-    ```
-     `routeDidChange` will be called after any `Route`'s
-    [didTransition](/ember/release/classes/Route/events/didTransition?anchor=didTransition)
-    action has been fired.
-    The updates of properties
-    [currentURL](/ember/release/classes/RouterService/properties/currentURL?anchor=currentURL),
-    [currentRouteName](/ember/release/classes/RouterService/properties/currentURL?anchor=currentRouteName)
-    and
-    [currentRoute](/ember/release/classes/RouterService/properties/currentURL?anchor=currentRoute)
-    are completed at the time `routeDidChange` is called.
-     @event routeDidChange
-    @param {Transition} transition
-    @public
-  */
-
-  /**
-   * Refreshes all currently active routes, doing a full transition.
-   * If a route name is provided and refers to a currently active route,
-   * it will refresh only that route and its descendents.
-   * Returns a promise that will be resolved once the refresh is complete.
-   * All resetController, beforeModel, model, afterModel, redirect, and setupController
-   * hooks will be called again. You will get new data from the model hook.
-   *
-   * @method refresh
-   * @param {String} [routeName] the route to refresh (along with all child routes)
-   * @return Transition
-   * @public
-   */
-  refresh(pivotRouteName) {
-    if (!pivotRouteName) {
-      return this._router._routerMicrolib.refresh();
-    }
-    (isDevelopingApp() && !(this._router.hasRoute(pivotRouteName)) && assert(`The route "${pivotRouteName}" was not found`, this._router.hasRoute(pivotRouteName)));
-    (isDevelopingApp() && !(this.isActive(pivotRouteName)) && assert(`The route "${pivotRouteName}" is currently not active`, this.isActive(pivotRouteName)));
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('RouterService is unexpectedly missing an owner', owner));
-    let pivotRoute = owner.lookup(`route:${pivotRouteName}`);
-    return this._router._routerMicrolib.refresh(pivotRoute);
-  }
-
-  /**
-   Name of the current route.
-     This property represents the logical name of the route,
-    which is dot separated.
-    For the following router:
-     ```app/router.js
-    Router.map(function() {
-      this.route('about');
-      this.route('blog', function () {
-        this.route('post', { path: ':post_id' });
-      });
-    });
-    ```
-     It will return:
-     * `index` when you visit `/`
-    * `about` when you visit `/about`
-    * `blog.index` when you visit `/blog`
-    * `blog.post` when you visit `/blog/some-post-id`
-     @property currentRouteName
-    @type {String | null}
-    @public
-  */
-  static {
-    decorateFieldV2(this.prototype, "currentRouteName", [readOnly('_router.currentRouteName')]);
-  }
-  #currentRouteName = (initializeDeferredDecorator(this, "currentRouteName"), void 0);
-  static {
-    decorateFieldV2(this.prototype, "currentURL", [readOnly('_router.currentURL')]);
-  }
-  #currentURL = (initializeDeferredDecorator(this, "currentURL"), void 0);
-  /**
-   Current URL for the application.
-   This property represents the URL path for this route.
-  For the following router:
-     ```app/router.js
-    Router.map(function() {
-      this.route('about');
-      this.route('blog', function () {
-        this.route('post', { path: ':post_id' });
-      });
-    });
-    ```
-     It will return:
-     * `/` when you visit `/`
-    * `/about` when you visit `/about`
-    * `/blog` when you visit `/blog`
-    * `/blog/some-post-id` when you visit `/blog/some-post-id`
-     @property currentURL
-    @type String
-    @public
-  */
-  static {
-    decorateFieldV2(this.prototype, "location", [readOnly('_router.location')]);
-  }
-  #location = (initializeDeferredDecorator(this, "location"), void 0);
-  /**
-    The `location` property returns what implementation of the `location` API
-    your application is using, which determines what type of URL is being used.
-     See [Location](/ember/release/classes/Location) for more information.
-     To force a particular `location` API implementation to be used in your
-    application you can set a location type on your `config/environment`.
-    For example, to set the `history` type:
-     ```config/environment.js
-    'use strict';
-     module.exports = function(environment) {
-      let ENV = {
-        modulePrefix: 'router-service',
-        environment,
-        rootURL: '/',
-        locationType: 'history',
-        ...
-      }
-    }
-    ```
-     The following location types are available by default:
-    `hash`, `history`, `none`.
-     See [HashLocation](/ember/release/classes/HashLocation).
-    See [HistoryLocation](/ember/release/classes/HistoryLocation).
-    See [NoneLocation](/ember/release/classes/NoneLocation).
-     @property location
-    @default 'hash'
-    @see {Location}
-    @public
-  */
-  static {
-    decorateFieldV2(this.prototype, "rootURL", [readOnly('_router.rootURL')]);
-  }
-  #rootURL = (initializeDeferredDecorator(this, "rootURL"), void 0);
-  /**
-    The `rootURL` property represents the URL of the root of
-    the application, '/' by default.
-    This prefix is assumed on all routes defined on this app.
-     If you change the `rootURL` in your environment configuration
-    like so:
-     ```config/environment.js
-    'use strict';
-     module.exports = function(environment) {
-      let ENV = {
-        modulePrefix: 'router-service',
-        environment,
-        rootURL: '/my-root',
-      …
-      }
-    ]
-    ```
-     This property will return `/my-root`.
-     @property rootURL
-    @default '/'
-    @public
-  */
-  static {
-    decorateFieldV2(this.prototype, "currentRoute", [readOnly('_router.currentRoute')]);
-  }
-  #currentRoute = (initializeDeferredDecorator(this, "currentRoute"), void 0);
-  /**
-    The `currentRoute` property contains metadata about the current leaf route.
-    It returns a `RouteInfo` object that has information like the route name,
-    params, query params and more.
-     See [RouteInfo](/ember/release/classes/RouteInfo) for more info.
-     This property is guaranteed to change whenever a route transition
-    happens (even when that transition only changes parameters
-    and doesn't change the active route).
-     Usage example:
-    ```app/components/header.js
-      import Component from '@glimmer/component';
-      import { service } from '@ember/service';
-      import { notEmpty } from '@ember/object/computed';
-       export default class extends Component {
-        @service router;
-         @notEmpty('router.currentRoute.child') isChildRoute;
-      });
-    ```
-     @property currentRoute
-    @type RouteInfo
-    @public
-  */
-}
-
-/**
-@module ember
-*/
-
-class RoutingService extends Service {
-  [ROUTER];
-  get router() {
-    let router = this[ROUTER];
-    if (router !== undefined) {
-      return router;
-    }
-    let owner = getOwner(this);
-    (isDevelopingApp() && !(owner) && assert('RoutingService is unexpectedly missing an owner', owner));
-    let _router = owner.lookup('router:main');
-    (isDevelopingApp() && !(_router instanceof EmberRouter$1) && assert('ROUTING SERVICE BUG: Expected router to be an instance of EmberRouter', _router instanceof EmberRouter$1));
-    _router.setupRouter();
-    return this[ROUTER] = _router;
-  }
-  hasRoute(routeName) {
-    return this.router.hasRoute(routeName);
-  }
-  transitionTo(routeName, models, queryParams, shouldReplace) {
-    let transition = this.router._doTransition(routeName, models, queryParams);
-    if (shouldReplace) {
-      transition.method('replace');
-    }
-    return transition;
-  }
-  normalizeQueryParams(routeName, models, queryParams) {
-    this.router._prepareQueryParams(routeName, models, queryParams);
-  }
-  _generateURL(routeName, models, queryParams) {
-    let visibleQueryParams = {};
-    if (queryParams) {
-      Object.assign(visibleQueryParams, queryParams);
-      this.normalizeQueryParams(routeName, models, visibleQueryParams);
-    }
-    return this.router.generate(routeName, ...models, {
-      queryParams: visibleQueryParams
-    });
-  }
-  generateURL(routeName, models, queryParams) {
-    if (this.router._initialTransitionStarted) {
-      return this._generateURL(routeName, models, queryParams);
-    } else {
-      // Swallow error when transition has not started.
-      // When rendering in tests without visit(), we cannot infer the route context which <LinkTo/> needs be aware of
-      try {
-        return this._generateURL(routeName, models, queryParams);
-      } catch (_e) {
-        return;
-      }
-    }
-  }
-  isActiveForRoute(contexts, queryParams, routeName, routerState) {
-    let handlers = this.router._routerMicrolib.recognizer.handlersFor(routeName);
-    let leafName = handlers[handlers.length - 1].handler;
-    let maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
-
-    // NOTE: any ugliness in the calculation of activeness is largely
-    // due to the fact that we support automatic normalizing of
-    // `resource` -> `resource.index`, even though there might be
-    // dynamic segments / query params defined on `resource.index`
-    // which complicates (and makes somewhat ambiguous) the calculation
-    // of activeness for links that link to `resource` instead of
-    // directly to `resource.index`.
-
-    // if we don't have enough contexts revert back to full route name
-    // this is because the leaf route will use one of the contexts
-    if (contexts.length > maximumContexts) {
-      routeName = leafName;
-    }
-    return routerState.isActiveIntent(routeName, contexts, queryParams);
-  }
-}
-RoutingService.reopen({
-  targetState: readOnly('router.targetState'),
-  currentState: readOnly('router.currentState'),
-  currentRouteName: readOnly('router.currentRouteName'),
-  currentPath: readOnly('router.currentPath')
-});
-function numberOfContextsAcceptedByHandler(handlerName, handlerInfos) {
-  let req = 0;
-  for (let i = 0; i < handlerInfos.length; i++) {
-    req += handlerInfos[i].names.length;
-    if (handlerInfos[i].handler === handlerName) {
-      break;
-    }
-  }
-  return req;
-}
-
-export { getRenderState as A, getFullQueryParams as B, Component as C, defaultSerialize as D, Engine as E, hasDefaultSerialize as F, triggerEvent as G, Helper as H, Input as I, ROUTER as J, LinkTo as L, OutletView as O, RouterState as R, SafeString as S, Textarea as T, _resetRenderers as _, RoutingService as a, RootTemplate as b, htmlSafe as c, Renderer as d, escapeExpression as e, setupApplicationRegistry as f, buildInitializerMethod as g, helper$1 as h, isHTMLSafe as i, EmberRouter$1 as j, Route as k, RouterService as l, EmberEngineInstance as m, setModifierManager as n, on as o, prefixRouteNameArg as p, extractRouteArgs as q, renderSettled as r, setupEngineRegistry as s, getActiveTargetName as t, uniqueId$1 as u, stashParamNames as v, calculateCacheKey as w, normalizeControllerQueryParams as x, resemblesURL as y, shallowEqual as z };
+export { Component as C, Helper as H, Input as I, LinkTo as L, OutletView as O, RootTemplate as R, SafeString as S, Textarea as T, _resetRenderers as _, htmlSafe as a, Renderer as b, OutletTemplate as c, escapeExpression as e, helper$1 as h, isHTMLSafe as i, renderSettled as r, uniqueId$1 as u };