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

package/dist/prod/packages/shared-chunks/{index-DabsnYit.js → index-npr2B-vu.js}

@@ -1,245 +1,132 @@
-import { privatize } from '../@ember/-internals/container/index.js';
 import { E as ENV } from './env-DXxsTFkM.js';
-import { isFactory, getOwner } from '../@ember/-internals/owner/index.js';
-import { a as guidFor } from './guid-PO2v9BaN.js';
-import { getViewId, getViewElement } from '../@ember/-internals/views/lib/system/utils.js';
 import { h as hasDOM } from './has-dom-DdQORPzI.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 import { schedule, _backburner, _getCurrentRunLoop } from '../@ember/runloop/index.js';
-import { associateDestroyableChild, isDestroyed, destroy, registerDestructor, isDestroying } from '../@glimmer/destroyable/index.js';
+import { associateDestroyableChild, destroy, registerDestructor, isDestroyed, isDestroying } from '../@glimmer/destroyable/index.js';
 import { artifacts } from '../@glimmer/program/index.js';
-import { R as RuntimeOpImpl } from './program-CF651Zuj.js';
-import { v as valueForRef, U as UNDEFINED_REFERENCE, b as createComputeRef, d as createConstRef, f as createInvokableRef, h as createReadOnlyRef, i as createUnboundRef, a as childRefFromParts, u as updateRef } from './reference-D2agTt1V.js';
-import { e as clientBuilder } from './element-builder-CZePCkbA.js';
-import { E as EMPTY_ARGS, f as createCapturedArgs, c as EMPTY_POSITIONAL, g as curry } from './debug-render-tree-CYENUjgX.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-B790-vbk.js';
-import { d as dict } from './collections-By4M3cTy.js';
-import { u as unwrapTemplate, b as CurlyComponentManager, i as initialRenderInstrumentDetails, a as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-DCYSwLtz.js';
-import { b as CONSTANT_TAG, k as consumeTag, t as isTracking, D as DIRTY_TAG$1, m as createTag, y as valueForTag, c as CURRENT_TAG, x as validateTag } from './cache-CG6_L9db.js';
-import { a as RSVP } from './rsvp-C6j8G1D1.js';
-import '../@ember/engine/instance.js';
-import { _instrumentStart } from '../@ember/instrumentation/index.js';
-import { c as capabilityFlagsFrom } from './capabilities-_5e35539.js';
-import { h as templateFactory } from './index-D-rcNBLp.js';
-import { g as getFactoryFor } from './container-BYOnjnwz.js';
-import { g as get, a as _getProp } from './property_get-Sw0SicEZ.js';
-import { _ as _setProp, s as set } from './property_set-SHEIPMUG.js';
+import { R as RuntimeOpImpl } from './program-BAh__OXZ.js';
+import { c as clientBuilder } from './api-CQexacBn.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1 } from './render-Dx7lr1hR.js';
+import { c as consumeTag, f as isTracking, a as valueForTag, k as CURRENT_TAG, v as validateTag } from './cache-CofLhaS4.js';
+import { g as get$1, a as _getProp } from './property_get-DAKgbeJX.js';
+import { _ as _setProp, s as set } from './property_set-BaQJdVfS.js';
+import './guid-Cbq2sNV_.js';
 import setGlobalContext from '../@glimmer/global-context/index.js';
-import { t as tagForObject, o as objectAt, b as tagForProperty } from './chain-tags-BP0V2LnZ.js';
+import { a as tagForProperty, t as tagForObject, o as objectAt } from './chain-tags-B2J7DsxO.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
 import { i as isObject } from './spec-BXl1reqK.js';
-import { t as tagFor } from './meta-Ce6-qROq.js';
+import { t as tagFor } from './meta-BJtIZDir.js';
 import { contentFor } from '../@ember/-internals/runtime/lib/mixins/-proxy.js';
 import { i as isProxy } from './is_proxy-Bzg0d4m4.js';
-import { i as internalHelper } from './internal-helper-CoxiRnnb.js';
+import { v as valueForRef, c as createComputeRef, a as createConstRef, h as createInvokableRef, j as createReadOnlyRef, k as createUnboundRef } from './reference-CG0yPgLy.js';
+import { i as internalHelper } from './internal-helper-Bz1lpDXr.js';
 import { i as isHTMLSafe } from './index-D-xTBV4B.js';
-import { isArray } from '../@ember/array/index.js';
+import isArray from '../@ember/array/lib/is-array.js';
+import { isFactory } from '../@ember/-internals/owner/index.js';
+import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { g as getComponentTemplate } from './template-Dc_cBOoX.js';
-import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DOLN_cR2.js';
-import { h as hash, f as fn, a as array } from './hash-C6IoC4eR.js';
-import { g as get$1, c as concat } from './get-tlL23wmp.js';
-import { o as on } from './on-Dgmychhk.js';
-import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-CP0NT7ce.js';
-import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-CCK8Ef0x.js';
+import { a as getInternalHelperManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DlJKfm_f.js';
+import { h as hash, f as fn, a as array } from './hash-gEXIsSO4.js';
+import { g as get, c as concat } from './get-Dago5uGl.js';
+import { o as on } from './on-BZHAxzdq.js';
+import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-DKNcKM5b.js';
+import { i as isCurlyManager } from './curly-brand-B_F79Dep.js';
+import { i as isClassicHelper } from './helper-brand-C9_8vvOf.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-Hn8Qp4dS.js';
-import '../route-recognizer/index.js';
-import './unrecognized-url-error-ClNyMFJt.js';
-import '../@ember/routing/lib/routing-service.js';
-import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
-import { E as EvaluationContextImpl } from './program-context-DmI53TzJ.js';
-
-function instrumentationPayload$1(def) {
-  // "main" used to be the outlet name, keeping it around for compatibility
-  return {
-    object: `${def.name}:main`
+import { a as uniqueId } from './unique-id-o2pS74go.js';
+import { E as EvaluationContextImpl } from './program-context-COSioH46.js';
+
+/**
+@module ember
+*/
+const disallowDynamicResolution = internalHelper(({
+  positional,
+  named
+}) => {
+  const nameOrValueRef = positional[0];
+  let typeRef = named['type'];
+  let locRef = named['loc'];
+  let originalRef = named['original'];
+  // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
+  // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));
+  // assert('[BUG] expecting a string literal for the `original` argument', isConstRef(originalRef));
+  valueForRef(typeRef);
+  valueForRef(locRef);
+  valueForRef(originalRef);
+  return createComputeRef(() => {
+    let nameOrValue = valueForRef(nameOrValueRef);
+    return nameOrValue;
+  });
+});
+
+let helper;
+{
+  helper = args => {
+    let arg = args.positional[0];
+    return arg;
   };
 }
-const CAPABILITIES$2 = {
-  dynamicLayout: false,
-  dynamicTag: false,
-  prepareArgs: false,
-  createArgs: false,
-  attributeHook: false,
-  elementHook: false,
-  createCaller: false,
-  dynamicScope: true,
-  updateHook: false,
-  createInstance: true,
-  wrapped: false,
-  willDestroy: false,
-  hasSubOwner: false
-};
-const CAPABILITIES_MASK$1 = capabilityFlagsFrom(CAPABILITIES$2);
-class OutletComponentManager {
-  create(_owner, definition, _args, env, dynamicScope) {
-    let parentStateRef = dynamicScope.get('outletState');
-    let currentStateRef = definition.ref;
-
-    // This is the actual primary responsibility of the outlet component –
-    // it represents the switching from one route component/template into
-    // the next. The rest only exists to support the debug render tree and
-    // the old-school (and unreliable) instrumentation.
-    dynamicScope.set('outletState', currentStateRef);
-    let state = {
-      finalize: _instrumentStart('render.outlet', instrumentationPayload$1, definition)
-    };
-    if (env.debugRenderTree !== undefined) {
-      let parentState = valueForRef(parentStateRef);
-      let parentOwner = parentState?.render?.owner;
-      let currentState = valueForRef(currentStateRef);
-      let currentOwner = currentState?.render?.owner;
-      if (parentOwner && parentOwner !== currentOwner) {
-        let {
-          mountPoint
-        } = currentOwner;
-        if (mountPoint) {
-          state.engine = {
-            mountPoint,
-            instance: currentOwner
-          };
-        }
-      }
-    }
-    return state;
-  }
-  getDebugName({
-    name
-  }) {
-    return `{{outlet}} for ${name}`;
-  }
-  getDebugCustomRenderTree(_definition, state) {
-    let nodes = [];
-    nodes.push({
-      bucket: state,
-      type: 'outlet',
-      // "main" used to be the outlet name, keeping it around for compatibility
-      name: 'main',
-      args: EMPTY_ARGS,
-      instance: undefined
-    });
-    if (state.engine) {
-      nodes.push({
-        bucket: state.engine,
-        type: 'engine',
-        name: state.engine.mountPoint,
-        args: EMPTY_ARGS,
-        instance: state.engine.instance
-      });
+const inElementNullCheckHelper = internalHelper(helper);
+
+const normalizeClassHelper = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => {
+    let classNameArg = positional[0];
+    let valueArg = positional[1];
+    let classNameParts = valueForRef(classNameArg).split('.');
+    let className = classNameParts[classNameParts.length - 1];
+    let value = valueForRef(valueArg);
+    if (value === true) {
+      return dasherize(className);
+    } else if (!value && value !== 0) {
+      return '';
+    } else {
+      return String(value);
     }
-    return nodes;
-  }
-  getCapabilities() {
-    return CAPABILITIES$2;
-  }
-  getSelf() {
-    return UNDEFINED_REFERENCE;
-  }
-  didCreate() {}
-  didUpdate() {}
-  didRenderLayout(state) {
-    state.finalize();
-  }
-  didUpdateLayout() {}
-  getDestroyable() {
-    return null;
-  }
-}
-const OUTLET_MANAGER = new OutletComponentManager();
-const OUTLET_COMPONENT_TEMPLATE = templateFactory(
-/*
-  <@Component @controller={{@controller}} @model={{@model}} />
+  });
+});
+
+/**
+  @module ember
 */
-{
-  "id": null,
-  "block": "[[[8,[30,1],null,[[\"@controller\",\"@model\"],[[30,2],[30,3]]],null]],[\"@Component\",\"@controller\",\"@model\"],[]]",
-  "moduleName": "(unknown template module)",
-  "isStrictMode": true
+
+const resolve = internalHelper(({
+  positional
+}, owner) => {
+  let fullNameRef = positional[0];
+  let fullName = valueForRef(fullNameRef);
+  return createConstRef(owner.factoryFor(fullName)?.class);
 });
-class OutletComponent {
-  // handle is not used by this custom definition
-  handle = -1;
-  resolvedName = null;
-  manager = OUTLET_MANAGER;
-  capabilities = CAPABILITIES_MASK$1;
-  compilable;
-  constructor(owner, state) {
-    this.state = state;
-    this.compilable = unwrapTemplate(OUTLET_COMPONENT_TEMPLATE(owner)).asLayout();
-  }
-}
-function createRootOutlet(outletView) {
-  return new OutletComponent(outletView.owner, outletView.state);
-}
 
-class RootComponentManager extends CurlyComponentManager {
-  component;
-  constructor(component) {
-    super();
-    this.component = component;
-  }
-  create(_owner, _state, _args, {
-    isInteractive
-  }, dynamicScope) {
-    let component = this.component;
-    let finalizer = _instrumentStart('render.component', initialRenderInstrumentDetails, component);
-    dynamicScope.view = component;
-    let hasWrappedElement = component.tagName !== '';
-
-    // We usually do this in the `didCreateElement`, but that hook doesn't fire for tagless components
-    if (!hasWrappedElement) {
-      if (isInteractive) {
-        component.trigger('willRender');
-      }
-      component._transitionTo('hasElement');
-      if (isInteractive) {
-        component.trigger('willInsertElement');
-      }
-    }
-    let bucket = new ComponentStateBucket(component, null, CONSTANT_TAG, finalizer, hasWrappedElement, isInteractive);
-    consumeTag(component[DIRTY_TAG]);
-    return bucket;
-  }
-}
+/**
+@module ember
+*/
 
-// ROOT is the top-level template it has nothing but one yield.
-// it is supposed to have a dummy element
-const ROOT_CAPABILITIES = {
-  dynamicLayout: true,
-  dynamicTag: true,
-  prepareArgs: false,
-  createArgs: false,
-  attributeHook: true,
-  elementHook: true,
-  createCaller: true,
-  dynamicScope: true,
-  updateHook: true,
-  createInstance: true,
-  wrapped: true,
-  willDestroy: false,
-  hasSubOwner: false
-};
-class RootComponentDefinition {
-  // handle is not used by this custom definition
-  handle = -1;
-  resolvedName = '-top-level';
-  state;
-  manager;
-  capabilities = capabilityFlagsFrom(ROOT_CAPABILITIES);
-  compilable = null;
-  constructor(component) {
-    this.manager = new RootComponentManager(component);
-    let factory = getFactoryFor(component);
-    this.state = factory;
-  }
-}
+/**
+  This reference is used to get the `[]` tag of iterables, so we can trigger
+  updates to `{{each}}` when it changes. It is put into place by a template
+  transform at build time, similar to the (-each-in) helper
+*/
+const trackArray = internalHelper(({
+  positional
+}) => {
+  const inner = positional[0];
+  return createComputeRef(() => {
+    let iterable = valueForRef(inner);
+    if (isObject(iterable)) {
+      consumeTag(tagForProperty(iterable, '[]'));
+    }
+    return iterable;
+  });
+});
 
 /**
 @module ember
 */
 
 /**
-  The `{{#each}}` helper loops over elements in a collection. It is an extension
+  The `{{#each}}` keyword loops over elements in a collection. It is an extension
   of the base Handlebars `{{#each}}` helper.
 
   The default behavior of `{{#each}}` is to yield its inner block once for every
@@ -283,6 +170,8 @@ class RootComponentDefinition {
     {{/each}}
   </ul>
   ```
+    
+  `#each` is a keyword and does not need to be imported. 
 
   ### Specifying Keys
 
@@ -350,11 +239,11 @@ class RootComponentDefinition {
  */
 
 /**
-  The `{{each-in}}` helper loops over properties on an object.
+  The `{{#each-in}}` keyword loops over properties on an object.
 
   For example, given this component definition:
 
-  ```app/components/developer-details.js
+  ```app/components/developer-details.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
 
@@ -363,21 +252,19 @@ class RootComponentDefinition {
       "name": "Shelly Sails",
       "age": 42
     };
+    
+    <template>
+      <ul>
+        {{#each-in this.developer as |key value|}}
+          <li>{{key}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
   }
   ```
 
   This template would display all properties on the `developer`
-  object in a list:
-
-  ```app/components/developer-details.hbs
-  <ul>
-    {{#each-in this.developer as |key value|}}
-      <li>{{key}}: {{value}}</li>
-    {{/each-in}}
-  </ul>
-  ```
-
-  Outputting their name and age:
+  object in a list, outputting their name and age:
 
   ```html
   <ul>
@@ -385,6 +272,8 @@ class RootComponentDefinition {
     <li>age: 42</li>
   </ul>
   ```
+ 
+  `#each-in` is a keyword and does not need to be imported.
 
   @method each-in
   @for Ember.Templates.helpers
@@ -412,437 +301,47 @@ const eachIn = internalHelper(({
   });
 });
 
-function toIterator(iterable) {
-  if (iterable instanceof EachInWrapper) {
-    return toEachInIterator(iterable.inner);
-  } else {
-    return toEachIterator(iterable);
-  }
-}
-function toEachInIterator(iterable) {
-  if (!isIndexable(iterable)) {
-    return null;
-  }
-  if (Array.isArray(iterable) || isEmberArray(iterable)) {
-    return ObjectIterator.fromIndexable(iterable);
-  } else if (isNativeIterable(iterable)) {
-    return MapLikeNativeIterator.from(iterable);
-  } else if (hasForEach(iterable)) {
-    return ObjectIterator.fromForEachable(iterable);
-  } else {
-    return ObjectIterator.fromIndexable(iterable);
-  }
-}
-function toEachIterator(iterable) {
-  if (!isObject(iterable)) {
-    return null;
-  }
-  if (Array.isArray(iterable)) {
-    return ArrayIterator.from(iterable);
-  } else if (isEmberArray(iterable)) {
-    return EmberArrayIterator.from(iterable);
-  } else if (isNativeIterable(iterable)) {
-    return ArrayLikeNativeIterator.from(iterable);
-  } else if (hasForEach(iterable)) {
-    return ArrayIterator.fromForEachable(iterable);
-  } else {
-    return null;
-  }
-}
-class BoundedIterator {
-  position = 0;
-  constructor(length) {
-    this.length = length;
-  }
-  isEmpty() {
-    return false;
-  }
-  memoFor(position) {
-    return position;
-  }
-  next() {
-    let {
-      length,
-      position
-    } = this;
-    if (position >= length) {
-      return null;
-    }
-    let value = this.valueFor(position);
-    let memo = this.memoFor(position);
-    this.position++;
-    return {
-      value,
-      memo
-    };
-  }
-}
-class ArrayIterator extends BoundedIterator {
-  static from(iterable) {
-    return iterable.length > 0 ? new this(iterable) : null;
-  }
-  static fromForEachable(object) {
-    let array = [];
-    object.forEach(item => array.push(item));
-    return this.from(array);
-  }
-  constructor(array) {
-    super(array.length);
-    this.array = array;
-  }
-  valueFor(position) {
-    return this.array[position];
-  }
-}
-class EmberArrayIterator extends BoundedIterator {
-  static from(iterable) {
-    return iterable.length > 0 ? new this(iterable) : null;
-  }
-  constructor(array) {
-    super(array.length);
-    this.array = array;
-  }
-  valueFor(position) {
-    return objectAt(this.array, position);
-  }
-}
-class ObjectIterator extends BoundedIterator {
-  static fromIndexable(obj) {
-    let keys = Object.keys(obj);
-    if (keys.length === 0) {
-      return null;
-    } else {
-      let values = [];
-      for (let key of keys) {
-        let value;
-        value = obj[key];
+/**
+@module ember
+*/
 
-        // Add the tag of the returned value if it is an array, since arrays
-        // should always cause updates if they are consumed and then changed
-        if (isTracking()) {
-          consumeTag(tagFor(obj, key));
-          if (Array.isArray(value)) {
-            consumeTag(tagFor(value, '[]'));
-          }
-        }
-        values.push(value);
-      }
-      return new this(keys, values);
+/**
+  The `mut` helper is a shortcut for updating for args.
+    
+  However, defining update functions on your backing class is preferable to using `mut`.
+    
+  More directly: Don't use `mut`. 
+
+  The `mut` helper, when used with `fn`, will return a function that
+  sets the value passed to `mut` to its first argument. As an example, we can create a
+  button that increments a value passing the value directly to the `fn`:
+
+  ```handlebars
+  <MyChild @childClickCount={{this.totalClicks}} @clickCountChange={{fn (mut this.totalClicks)}} />
+  ```
+
+  The child `Component` would invoke the function with the new click count:
+
+  ```app/components/my-child.gjs
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+    
+  export default class MyChild extends Component {
+    @action
+    update() {
+      this.args.clickCountChange(this.args.childClickCount + 1);
     }
+    
+    <template>
+      <button {{on "click" this.update}}>
+        Click me!
+      </button>
+    </template>
   }
-  static fromForEachable(obj) {
-    let keys = [];
-    let values = [];
-    let length = 0;
-    let isMapLike = false;
-
-    // Not using an arrow function here so we can get an accurate `arguments`
-    obj.forEach(function (value, key) {
-      isMapLike = isMapLike || arguments.length >= 2;
-      if (isMapLike) {
-        keys.push(key);
-      }
-      values.push(value);
-      length++;
-    });
-    if (length === 0) {
-      return null;
-    } else if (isMapLike) {
-      return new this(keys, values);
-    } else {
-      return new ArrayIterator(values);
-    }
-  }
-  constructor(keys, values) {
-    super(values.length);
-    this.keys = keys;
-    this.values = values;
-  }
-  valueFor(position) {
-    return this.values[position];
-  }
-  memoFor(position) {
-    return this.keys[position];
-  }
-}
-class NativeIterator {
-  static from(iterable) {
-    let iterator = iterable[Symbol.iterator]();
-    let result = iterator.next();
-    let {
-      done
-    } = result;
-    if (done) {
-      return null;
-    } else {
-      return new this(iterator, result);
-    }
-  }
-  position = 0;
-  constructor(iterable, result) {
-    this.iterable = iterable;
-    this.result = result;
-  }
-  isEmpty() {
-    return false;
-  }
-  next() {
-    let {
-      iterable,
-      result,
-      position
-    } = this;
-    if (result.done) {
-      return null;
-    }
-    let value = this.valueFor(result, position);
-    let memo = this.memoFor(result, position);
-    this.position++;
-    this.result = iterable.next();
-    return {
-      value,
-      memo
-    };
-  }
-}
-class ArrayLikeNativeIterator extends NativeIterator {
-  valueFor(result) {
-    return result.value;
-  }
-  memoFor(_result, position) {
-    return position;
-  }
-}
-class MapLikeNativeIterator extends NativeIterator {
-  valueFor(result) {
-    return result.value[1];
-  }
-  memoFor(result) {
-    return result.value[0];
-  }
-}
-function hasForEach(value) {
-  return value != null && typeof value['forEach'] === 'function';
-}
-function isNativeIterable(value) {
-  return value != null && typeof value[Symbol.iterator] === 'function';
-}
-function isIndexable(value) {
-  return value !== null && (typeof value === 'object' || typeof value === 'function');
-}
-
-function toBool(predicate) {
-  if (isProxy(predicate)) {
-    consumeTag(tagForProperty(predicate, 'content'));
-    return Boolean(get(predicate, 'isTruthy'));
-  } else if (isArray(predicate)) {
-    consumeTag(tagForProperty(predicate, '[]'));
-    return predicate.length !== 0;
-  } else if (isHTMLSafe(predicate)) {
-    return Boolean(predicate.toString());
-  } else {
-    return Boolean(predicate);
-  }
-}
-
-///////////
-
-// Setup global context
-
-setGlobalContext({
-  scheduleRevalidate() {
-    _backburner.ensureInstance();
-  },
-  toBool,
-  toIterator,
-  getProp: _getProp,
-  setProp: _setProp,
-  getPath: get,
-  setPath: set,
-  scheduleDestroy(destroyable, destructor) {
-    schedule('actions', null, destructor, destroyable);
-  },
-  scheduleDestroyed(finalizeDestructor) {
-    schedule('destroy', null, finalizeDestructor);
-  },
-  warnIfStyleNotTrusted(value) {
-  },
-  assert(test, msg, options) {
-  },
-  deprecate(msg, test, options) {
-  }
-});
-
-///////////
-
-// Define environment delegate
-
-class EmberEnvironmentDelegate {
-  enableDebugTooling = ENV._DEBUG_RENDER_TREE;
-  constructor(owner, isInteractive) {
-    this.owner = owner;
-    this.isInteractive = isInteractive;
-  }
-  onTransactionCommit() {}
-}
-
-/**
-@module ember
-*/
-const disallowDynamicResolution = internalHelper(({
-  positional,
-  named
-}) => {
-  const nameOrValueRef = positional[0];
-  let typeRef = named['type'];
-  let locRef = named['loc'];
-  let originalRef = named['original'];
-  // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
-  // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));
-  // assert('[BUG] expecting a string literal for the `original` argument', isConstRef(originalRef));
-  valueForRef(typeRef);
-  valueForRef(locRef);
-  valueForRef(originalRef);
-  return createComputeRef(() => {
-    let nameOrValue = valueForRef(nameOrValueRef);
-    return nameOrValue;
-  });
-});
-
-let helper;
-{
-  helper = args => {
-    let arg = args.positional[0];
-    return arg;
-  };
-}
-const inElementNullCheckHelper = internalHelper(helper);
-
-const normalizeClassHelper = internalHelper(({
-  positional
-}) => {
-  return createComputeRef(() => {
-    let classNameArg = positional[0];
-    let valueArg = positional[1];
-    let classNameParts = valueForRef(classNameArg).split('.');
-    let className = classNameParts[classNameParts.length - 1];
-    let value = valueForRef(valueArg);
-    if (value === true) {
-      return dasherize(className);
-    } else if (!value && value !== 0) {
-      return '';
-    } else {
-      return String(value);
-    }
-  });
-});
-
-/**
-  @module ember
-*/
-
-const resolve = internalHelper(({
-  positional
-}, owner) => {
-  let fullNameRef = positional[0];
-  let fullName = valueForRef(fullNameRef);
-  return createConstRef(owner.factoryFor(fullName)?.class);
-});
-
-/**
-@module ember
-*/
-
-/**
-  This reference is used to get the `[]` tag of iterables, so we can trigger
-  updates to `{{each}}` when it changes. It is put into place by a template
-  transform at build time, similar to the (-each-in) helper
-*/
-const trackArray = internalHelper(({
-  positional
-}) => {
-  const inner = positional[0];
-  return createComputeRef(() => {
-    let iterable = valueForRef(inner);
-    if (isObject(iterable)) {
-      consumeTag(tagForProperty(iterable, '[]'));
-    }
-    return iterable;
-  });
-});
-
-/**
-@module ember
-*/
-
-/**
-  The `mut` helper lets you __clearly specify__ that a child `Component` can update the
-  (mutable) value passed to it, which will __change the value of the parent component__.
-
-  To specify that a parameter is mutable, when invoking the child `Component`:
-
-  ```handlebars
-  <MyChild @childClickCount={{fn (mut totalClicks)}} />
-  ```
-
-   or
-
-  ```handlebars
-  {{my-child childClickCount=(mut totalClicks)}}
-  ```
-
-  The child `Component` can then modify the parent's value just by modifying its own
-  property:
-
-  ```javascript
-  // my-child.js
-  export default class MyChild extends Component {
-    click() {
-      this.incrementProperty('childClickCount');
-    }
-  }
-  ```
-
-  Note that for curly components (`{{my-component}}`) the bindings are already mutable,
-  making the `mut` unnecessary.
-
-  Additionally, the `mut` helper can be combined with the `fn` helper to
-  mutate a value. For example:
-
-  ```handlebars
-  <MyChild @childClickCount={{this.totalClicks}} @click-count-change={{fn (mut totalClicks))}} />
-  ```
-
-  or
-
-  ```handlebars
-  {{my-child childClickCount=totalClicks click-count-change=(fn (mut totalClicks))}}
-  ```
-
-  The child `Component` would invoke the function with the new click value:
-
-  ```javascript
-  // my-child.js
-  export default class MyChild extends Component {
-    click() {
-      this.get('click-count-change')(this.get('childClickCount') + 1);
-    }
-  }
-  ```
+  ```
 
   The `mut` helper changes the `totalClicks` value to what was provided as the `fn` argument.
 
-  The `mut` helper, when used with `fn`, will return a function that
-  sets the value passed to `mut` to its first argument. As an example, we can create a
-  button that increments a value passing the value directly to the `fn`:
-
-  ```handlebars
-  {{! inc helper is not provided by Ember }}
-  <button onclick={{fn (mut count) (inc count)}}>
-    Increment count
-  </button>
-  ```
-
   @method mut
   @param {Object} [attr] the "two-way" attribute that can be modified.
   @for Ember.Templates.helpers
@@ -864,6 +363,10 @@ const mut = internalHelper(({
 /**
   The `readonly` helper let's you specify that a binding is one-way only,
   instead of two-way.
+  
+  This is a vestigial helper from the days of `@ember/component` and does not apply to
+  components extending from `@glimmer/component`.
+    
   When you pass a `readonly` binding from an outer context (e.g. parent component),
   to to an inner context (e.g. child component), you are saying that changing that
   property in the inner context does not change the value in the outer context.
@@ -876,14 +379,6 @@ const mut = internalHelper(({
   }
   ```
 
-  ```app/templates/components/my-parent.hbs
-  {{log totalClicks}} // -> 3
-  <MyChild @childClickCount={{readonly totalClicks}} />
-  ```
-  ```
-  {{my-child childClickCount=(readonly totalClicks)}}
-  ```
-
   Now, when you update `childClickCount`:
 
   ```app/components/my-child.js
@@ -971,472 +466,57 @@ const mut = internalHelper(({
   {{log childClicks.total}} //-> 4
   ```
 
-  @method readonly
-  @param {Object} [attr] the read-only attribute.
-  @for Ember.Templates.helpers
-  @private
-*/
-const readonly = internalHelper(({
-  positional
-}) => {
-  let firstArg = positional[0];
-  return createReadOnlyRef(firstArg);
-});
-
-/**
-@module ember
-*/
-
-
-/**
-  The `{{unbound}}` helper disconnects the one-way binding of a property,
-  essentially freezing its value at the moment of rendering. For example,
-  in this example the display of the variable `name` will not change even
-  if it is set with a new value:
-
-  ```handlebars
-  {{unbound this.name}}
-  ```
-
-  Like any helper, the `unbound` helper can accept a nested helper expression.
-  This allows for custom helpers to be rendered unbound:
-
-  ```handlebars
-  {{unbound (some-custom-helper)}}
-  {{unbound (capitalize this.name)}}
-  {{! You can use any helper, including unbound, in a nested expression }}
-  {{capitalize (unbound this.name)}}
-  ```
-
-  The `unbound` helper only accepts a single argument, and it return an
-  unbound value.
-
-  @method unbound
-  @for Ember.Templates.helpers
-  @public
-*/
-
-const unbound = internalHelper(({
-  positional,
-  named
-}) => {
-  return createUnboundRef(valueForRef(positional[0]));
-});
-
-const CAPABILITIES$1 = {
-  dynamicLayout: true,
-  dynamicTag: false,
-  prepareArgs: false,
-  createArgs: true,
-  attributeHook: false,
-  elementHook: false,
-  createCaller: true,
-  dynamicScope: true,
-  updateHook: true,
-  createInstance: true,
-  wrapped: false,
-  willDestroy: false,
-  hasSubOwner: true
-};
-class MountManager {
-  getDynamicLayout(state) {
-    let templateFactory = state.engine.lookup('template:application');
-    return unwrapTemplate(templateFactory(state.engine)).asLayout();
-  }
-  getCapabilities() {
-    return CAPABILITIES$1;
-  }
-  getOwner(state) {
-    return state.engine;
-  }
-  create(owner, {
-    name
-  }, args, env) {
-    let engine = owner.buildChildEngineInstance(name);
-    engine.boot();
-    let applicationFactory = engine.factoryFor(`controller:application`);
-    let controllerFactory = applicationFactory || generateControllerFactory(engine, 'application');
-    let controller;
-    let self;
-    let bucket;
-    let modelRef;
-    if (args.named.has('model')) {
-      modelRef = args.named.get('model');
-    }
-    if (modelRef === undefined) {
-      controller = controllerFactory.create();
-      self = createConstRef(controller);
-      bucket = {
-        engine,
-        controller,
-        self,
-        modelRef
-      };
-    } else {
-      let model = valueForRef(modelRef);
-      controller = controllerFactory.create({
-        model
-      });
-      self = createConstRef(controller);
-      bucket = {
-        engine,
-        controller,
-        self,
-        modelRef
-      };
-    }
-    if (env.debugRenderTree) {
-      associateDestroyableChild(engine, controller);
-    }
-    return bucket;
-  }
-  getDebugName({
-    name
-  }) {
-    return name;
-  }
-  getDebugCustomRenderTree(definition, state, args) {
-    return [{
-      bucket: state.engine,
-      instance: state.engine,
-      type: 'engine',
-      name: definition.name,
-      args
-    }, {
-      bucket: state.controller,
-      instance: state.controller,
-      type: 'route-template',
-      name: 'application',
-      args
-    }];
-  }
-  getSelf({
-    self
-  }) {
-    return self;
-  }
-  getDestroyable(bucket) {
-    return bucket.engine;
-  }
-  didCreate() {}
-  didUpdate() {}
-  didRenderLayout() {}
-  didUpdateLayout() {}
-  update(bucket) {
-    let {
-      controller,
-      modelRef
-    } = bucket;
-    if (modelRef !== undefined) {
-      controller.set('model', valueForRef(modelRef));
-    }
-  }
-}
-const MOUNT_MANAGER = new MountManager();
-class MountDefinition {
-  // handle is not used by this custom definition
-  handle = -1;
-  state;
-  manager = MOUNT_MANAGER;
-  compilable = null;
-  capabilities = capabilityFlagsFrom(CAPABILITIES$1);
-  constructor(resolvedName) {
-    this.resolvedName = resolvedName;
-    this.state = {
-      name: resolvedName
-    };
-  }
-}
-
-/**
-@module ember
-*/
-
-
-/**
-  The `{{mount}}` helper lets you embed a routeless engine in a template.
-  Mounting an engine will cause an instance to be booted and its `application`
-  template to be rendered.
-
-  For example, the following template mounts the `ember-chat` engine:
-
-  ```handlebars
-  {{! application.hbs }}
-  {{mount "ember-chat"}}
-  ```
-
-  Additionally, you can also pass in a `model` argument that will be
-  set as the engines model. This can be an existing object:
-
-  ```
-  <div>
-    {{mount 'admin' model=userSettings}}
-  </div>
-  ```
-
-  Or an inline `hash`, and you can even pass components:
-
-  ```
-  <div>
-    <h1>Application template!</h1>
-    {{mount 'admin' model=(hash
-        title='Secret Admin'
-        signInButton=(component 'sign-in-button')
-    )}}
-  </div>
-  ```
-
-  @method mount
-  @param {String} name Name of the engine to mount.
-  @param {Object} [model] Object that will be set as
-                          the model of the engine.
-  @for Ember.Templates.helpers
-  @public
-*/
-const mountHelper = internalHelper((args, owner) => {
-  let nameRef = args.positional[0];
-  let captured;
-  captured = createCapturedArgs(args.named, EMPTY_POSITIONAL);
-  let lastName, lastDef;
-  return createComputeRef(() => {
-    let name = valueForRef(nameRef);
-    if (typeof name === 'string') {
-      if (lastName === name) {
-        return lastDef;
-      }
-      lastName = name;
-      lastDef = curry(0, new MountDefinition(name), owner, captured, true);
-      return lastDef;
-    } else {
-      lastDef = null;
-      lastName = null;
-      return null;
-    }
-  });
-});
-
-const CAPABILITIES = {
-  dynamicLayout: false,
-  dynamicTag: false,
-  prepareArgs: false,
-  createArgs: true,
-  attributeHook: false,
-  elementHook: false,
-  createCaller: false,
-  dynamicScope: false,
-  updateHook: false,
-  createInstance: true,
-  wrapped: false,
-  willDestroy: false,
-  hasSubOwner: false
-};
-const CAPABILITIES_MASK = capabilityFlagsFrom(CAPABILITIES);
-class RouteTemplateManager {
-  create(_owner, _definition, args) {
-    let self = args.named.get('controller');
-    let controller = valueForRef(self);
-    return {
-      self,
-      controller
-    };
-  }
-  getSelf({
-    self
-  }) {
-    return self;
-  }
-  getDebugName({
-    name
-  }) {
-    return `route-template (${name})`;
-  }
-  getDebugCustomRenderTree({
-    name
-  }, state, args) {
-    return [{
-      bucket: state,
-      type: 'route-template',
-      name,
-      args,
-      instance: state.controller
-    }];
-  }
-  getCapabilities() {
-    return CAPABILITIES;
-  }
-  didRenderLayout() {}
-  didUpdateLayout() {}
-  didCreate() {}
-  didUpdate() {}
-  getDestroyable() {
-    return null;
-  }
-}
-const ROUTE_TEMPLATE_MANAGER = new RouteTemplateManager();
+  @method readonly
+  @param {Object} [attr] the read-only attribute.
+  @for Ember.Templates.helpers
+  @private
+*/
+const readonly = internalHelper(({
+  positional
+}) => {
+  let firstArg = positional[0];
+  return createReadOnlyRef(firstArg);
+});
 
 /**
- * This "upgrades" a route template into a invocable component. Conceptually
- * it can be 1:1 for each unique `Template`, but it's also cheap to construct,
- * so unless the stability is desirable for other reasons, it's probably not
- * worth caching this.
- */
-class RouteTemplate {
-  // handle is not used by this custom definition
-  handle = -1;
-  resolvedName;
-  state;
-  manager = ROUTE_TEMPLATE_MANAGER;
-  capabilities = CAPABILITIES_MASK;
-  compilable;
-  constructor(name, template) {
-    let unwrapped = unwrapTemplate(template);
-    // TODO This actually seems inaccurate – it ultimately came from the
-    // outlet's name. Also, setting this overrides `getDebugName()` in that
-    // message. Is that desirable?
-    this.resolvedName = name;
-    this.state = {
-      name
-    };
-    this.compilable = unwrapped.asLayout();
-  }
-}
+@module ember
+*/
 
-// TODO a lot these fields are copied from the adjacent existing components
-// implementation, haven't looked into who cares about `ComponentDefinition`
-// and if it is appropriate here. It seems like this version is intended to
-// be used with `curry` which probably isn't necessary here. It could be the
-// case that we just want to do something more similar to `InternalComponent`
-// (the one we used to implement `Input` and `LinkTo`). For now it follows
-// the same pattern to get things going.
-function makeRouteTemplate(owner, name, template) {
-  let routeTemplate = new RouteTemplate(name, template);
-  return curry(0, routeTemplate, owner, null, true);
-}
 
 /**
-  The `{{outlet}}` helper lets you specify where a child route will render in
-  your template. An important use of the `{{outlet}}` helper is in your
-  application's `application.hbs` file:
+  The `{{unbound}}` helper disconnects the one-way binding of a property,
+  essentially freezing its value at the moment of rendering. For example,
+  in this example the display of the variable `name` will not change even
+  if it is set with a new value:
 
-  ```app/templates/application.hbs
-  <MyHeader />
+  ```handlebars
+  {{unbound this.name}}
+  ```
 
-  <div class="my-dynamic-content">
-    <!-- this content will change based on the current route, which depends on the current URL -->
-    {{outlet}}
-  </div>
+  Like any helper, the `unbound` helper can accept a nested helper expression.
+  This allows for custom helpers to be rendered unbound:
 
-  <MyFooter />
+  ```handlebars
+  {{unbound (some-custom-helper)}}
+  {{unbound (capitalize this.name)}}
+  {{! You can use any helper, including unbound, in a nested expression }}
+  {{capitalize (unbound this.name)}}
   ```
 
-  See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
-  information on how your `route` interacts with the `{{outlet}}` helper.
-  Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
+  The `unbound` helper only accepts a single argument, and it return an
+  unbound value.
 
-  @method outlet
+  @method unbound
   @for Ember.Templates.helpers
   @public
 */
-const outletHelper = internalHelper((_args, owner, scope) => {
-  let outletRef = createComputeRef(() => {
-    let state = valueForRef(scope.get('outletState'));
-    return state?.outlets?.main;
-  });
-  let lastState = null;
-  let outlet = null;
-  return createComputeRef(() => {
-    let outletState = valueForRef(outletRef);
-    let state = stateFor(outletRef, outletState);
-
-    // This code is deliberately using the behavior in glimmer-vm where in
-    // <@Component />, the component is considered stabled via `===`, and
-    // will continue to re-render in-place as long as the `===` holds, but
-    // when it changes to a different object, it teardown the old component
-    // (running destructors, etc), and render the component in its place (or
-    // nothing if the new value is nullish. Here we are carefully exploiting
-    // that fact, and returns the same stable object so long as it is the
-    // same route, but return a different one when the route changes. On the
-    // other hand, changing the model only intentionally do not teardown the
-    // component and instead re-render in-place.
-    if (!isStable(state, lastState)) {
-      lastState = state;
-      if (state !== null) {
-        // If we are crossing an engine mount point, this is how the owner
-        // gets switched.
-        let outletOwner = outletState?.render?.owner ?? owner;
-        let named = dict();
-
-        // Here we either have a raw template that needs to be normalized,
-        // or a component that we can render as-is. `RouteTemplate` upgrades
-        // the template into a component so we can have a unified code path.
-        // We still store the original `template` value, because we rely on
-        // its identity for the stability check, and the `RouteTemplate`
-        // wrapper doesn't dedup for us.
-        let template = state.template;
-        let component;
-        if (hasInternalComponentManager(template)) {
-          component = template;
-        } else {
-          component = makeRouteTemplate(outletOwner, state.name, template);
-        }
-
-        // Component is stable for the lifetime of the outlet
-        named['Component'] = createConstRef(component);
-
-        // Controller is stable for the lifetime of the outlet
-        named['controller'] = createConstRef(state.controller);
 
-        // Create a ref for the model
-        let modelRef = childRefFromParts(outletRef, ['render', 'model']);
-
-        // Store the value of the model
-        let model = valueForRef(modelRef);
-
-        // Create a compute ref which we pass in as the `{{@model}}` reference
-        // for the outlet. This ref will update and return the value of the
-        // model _until_ the outlet itself changes. Once the outlet changes,
-        // dynamic scope also changes, and so the original model ref would not
-        // provide the correct updated value. So we stop updating and return
-        // the _last_ model value for that outlet.
-        named['model'] = createComputeRef(() => {
-          if (lastState === state) {
-            model = valueForRef(modelRef);
-          }
-          return model;
-        });
-        let args = createCapturedArgs(named, EMPTY_POSITIONAL);
-
-        // Package up everything
-        outlet = curry(0, new OutletComponent(owner, state), outletOwner, args, true);
-      } else {
-        outlet = null;
-      }
-    }
-    return outlet;
-  });
+const unbound = internalHelper(({
+  positional,
+  named
+}) => {
+  return createUnboundRef(valueForRef(positional[0]));
 });
-function stateFor(ref, outlet) {
-  if (outlet === undefined) return null;
-  let render = outlet.render;
-  if (render === undefined) return null;
-  let template = render.template;
-  // The type doesn't actually allow for `null`, but if we make it past this
-  // point it is really important that we have _something_ to render. We could
-  // assert, but that is probably overly strict for very little to gain.
-  if (template === undefined || template === null) return null;
-  return {
-    ref,
-    name: render.name,
-    template,
-    controller: render.controller
-  };
-}
-function isStable(state, lastState) {
-  if (state === null || lastState === null) {
-    return false;
-  }
-  return state.template === lastState.template && state.controller === lastState.controller;
-}
 
 function instrumentationPayload(name) {
   return {
@@ -1476,8 +556,6 @@ const BUILTIN_KEYWORD_HELPERS = {
   '-normalize-class': normalizeClassHelper,
   '-resolve': resolve,
   '-track-array': trackArray,
-  '-mount': mountHelper,
-  '-outlet': outletHelper,
   '-in-el-null': inElementNullCheckHelper
 };
 const BUILTIN_HELPERS = {
@@ -1485,21 +563,19 @@ const BUILTIN_HELPERS = {
   array,
   concat,
   fn,
-  get: get$1,
+  get,
   hash,
-  'unique-id': uniqueId
-};
-{
-  // Bug: this may be a quirk of our test setup?
+  'unique-id': uniqueId,
   // In prod builds, this is a no-op helper and is unused in practice. We shouldn't need
   // to add it at all, but the current test build doesn't produce a "prod compiler", so
   // we ended up running the debug-build for the template compliler in prod tests. Once
-  // that is fixed, this can be removed. For now, this allows the test to work and does
-  // not really harm anything, since it's just a no-op pass-through helper and the bytes
-  // has to be included anyway. In the future, perhaps we can avoid the latter by using
-  // `import(...)`?
-  BUILTIN_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
-}
+  // that is fixed, this can be conditionally included only in DEBUG. For now, this
+  // allows the test to work and does not really harm anything, since it's just a no-op
+  // pass-through helper. Keeping it inside the object literal (rather than a top-level
+  // conditional assignment) keeps this module free of top-level side effects so that
+  // consumers that never resolve anything dynamically can tree-shake the whole table.
+  '-disallow-dynamic-resolution': disallowDynamicResolution
+};
 
 // With the implementation of RFC #1006(https://rfcs.emberjs.com/id/1006-deprecate-action-template-helper), the `action` modifer was removed. It was the
 // only built-in keyword modifier, so this object is currently empty.
@@ -1526,182 +602,357 @@ class ResolverImpl {
     if (definition === undefined) {
       return null;
     }
-    if (typeof definition === 'function' && isClassicHelper(definition)) {
-      // For classic class based helpers, we need to pass the factoryFor result itself rather
-      // than the raw value (`factoryFor(...).class`). This is because injections are already
-      // bound in the factoryFor result, including type-based injections
+    if (typeof definition === 'function' && isClassicHelper(definition)) {
+      // For classic class based helpers, we need to pass the factoryFor result itself rather
+      // than the raw value (`factoryFor(...).class`). This is because injections are already
+      // bound in the factoryFor result, including type-based injections
+
+      // The classic helper manager is registered on the classic `Helper` base
+      // class; deriving it from the definition (rather than importing it from
+      // the module that defines `Helper`) keeps this module from pulling in
+      // the classic object model when no classic helpers are in use.
+      let manager = getInternalHelperManager(definition);
+      {
+        setInternalHelperManager(manager, factory);
+      }
+      return factory;
+    }
+    return definition;
+  }
+  lookupBuiltInHelper(name) {
+    return BUILTIN_KEYWORD_HELPERS[name] ?? null;
+  }
+  lookupModifier(name, owner) {
+    let builtin = BUILTIN_MODIFIERS[name];
+    if (builtin !== undefined) {
+      return builtin;
+    }
+    let modifier = owner.factoryFor(`modifier:${name}`);
+    if (modifier === undefined) {
+      return null;
+    }
+    return modifier.class || null;
+  }
+  lookupBuiltInModifier(name) {
+    return BUILTIN_KEYWORD_MODIFIERS[name] ?? null;
+  }
+  lookupComponent(name, owner) {
+    let pair = lookupComponentPair(owner, name);
+    if (pair === null) {
+      return null;
+    }
+    let template = null;
+    let key;
+    if (pair.component === null) {
+      key = template = pair.layout(owner);
+    } else {
+      key = pair.component;
+    }
+    let cachedComponentDefinition = this.componentDefinitionCache.get(key);
+    if (cachedComponentDefinition !== undefined) {
+      return cachedComponentDefinition;
+    }
+    if (template === null && pair.layout !== null) {
+      template = pair.layout(owner);
+    }
+    let finalizer = _instrumentStart('render.getComponentDefinition', instrumentationPayload, name);
+    let definition = null;
+    if (pair.component === null) {
+      definition = {
+        state: templateOnlyComponent(undefined, name),
+        manager: TEMPLATE_ONLY_COMPONENT_MANAGER,
+        template
+      };
+    } else {
+      let factory = pair.component;
+      let ComponentClass = factory.class;
+      let manager = getInternalComponentManager(ComponentClass);
+      definition = {
+        state: isCurlyManager(manager) ? factory : ComponentClass,
+        manager,
+        template
+      };
+    }
+    finalizer();
+    this.componentDefinitionCache.set(key, definition);
+    return definition;
+  }
+}
+
+function toIterator(iterable) {
+  if (iterable instanceof EachInWrapper) {
+    return toEachInIterator(iterable.inner);
+  } else {
+    return toEachIterator(iterable);
+  }
+}
+function toEachInIterator(iterable) {
+  if (!isIndexable(iterable)) {
+    return null;
+  }
+  if (Array.isArray(iterable) || isEmberArray(iterable)) {
+    return ObjectIterator.fromIndexable(iterable);
+  } else if (isNativeIterable(iterable)) {
+    return MapLikeNativeIterator.from(iterable);
+  } else if (hasForEach(iterable)) {
+    return ObjectIterator.fromForEachable(iterable);
+  } else {
+    return ObjectIterator.fromIndexable(iterable);
+  }
+}
+function toEachIterator(iterable) {
+  if (!isObject(iterable)) {
+    return null;
+  }
+  if (Array.isArray(iterable)) {
+    return ArrayIterator.from(iterable);
+  } else if (isEmberArray(iterable)) {
+    return EmberArrayIterator.from(iterable);
+  } else if (isNativeIterable(iterable)) {
+    return ArrayLikeNativeIterator.from(iterable);
+  } else if (hasForEach(iterable)) {
+    return ArrayIterator.fromForEachable(iterable);
+  } else {
+    return null;
+  }
+}
+class BoundedIterator {
+  position = 0;
+  constructor(length) {
+    this.length = length;
+  }
+  isEmpty() {
+    return false;
+  }
+  memoFor(position) {
+    return position;
+  }
+  next() {
+    let {
+      length,
+      position
+    } = this;
+    if (position >= length) {
+      return null;
+    }
+    let value = this.valueFor(position);
+    let memo = this.memoFor(position);
+    this.position++;
+    return {
+      value,
+      memo
+    };
+  }
+}
+class ArrayIterator extends BoundedIterator {
+  static from(iterable) {
+    return iterable.length > 0 ? new this(iterable) : null;
+  }
+  static fromForEachable(object) {
+    let array = [];
+    object.forEach(item => array.push(item));
+    return this.from(array);
+  }
+  constructor(array) {
+    super(array.length);
+    this.array = array;
+  }
+  valueFor(position) {
+    return this.array[position];
+  }
+}
+class EmberArrayIterator extends BoundedIterator {
+  static from(iterable) {
+    return iterable.length > 0 ? new this(iterable) : null;
+  }
+  constructor(array) {
+    super(array.length);
+    this.array = array;
+  }
+  valueFor(position) {
+    return objectAt(this.array, position);
+  }
+}
+class ObjectIterator extends BoundedIterator {
+  static fromIndexable(obj) {
+    let keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return null;
+    } else {
+      let values = [];
+      for (let key of keys) {
+        let value;
+        value = obj[key];
+
+        // Add the tag of the returned value if it is an array, since arrays
+        // should always cause updates if they are consumed and then changed
+        if (isTracking()) {
+          consumeTag(tagFor(obj, key));
+          if (Array.isArray(value)) {
+            consumeTag(tagFor(value, '[]'));
+          }
+        }
+        values.push(value);
+      }
+      return new this(keys, values);
+    }
+  }
+  static fromForEachable(obj) {
+    let keys = [];
+    let values = [];
+    let length = 0;
+    let isMapLike = false;
 
-      {
-        setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
+    // Not using an arrow function here so we can get an accurate `arguments`
+    obj.forEach(function (value, key) {
+      isMapLike = isMapLike || arguments.length >= 2;
+      if (isMapLike) {
+        keys.push(key);
       }
-      return factory;
+      values.push(value);
+      length++;
+    });
+    if (length === 0) {
+      return null;
+    } else if (isMapLike) {
+      return new this(keys, values);
+    } else {
+      return new ArrayIterator(values);
     }
-    return definition;
   }
-  lookupBuiltInHelper(name) {
-    return BUILTIN_KEYWORD_HELPERS[name] ?? null;
+  constructor(keys, values) {
+    super(values.length);
+    this.keys = keys;
+    this.values = values;
   }
-  lookupModifier(name, owner) {
-    let builtin = BUILTIN_MODIFIERS[name];
-    if (builtin !== undefined) {
-      return builtin;
-    }
-    let modifier = owner.factoryFor(`modifier:${name}`);
-    if (modifier === undefined) {
-      return null;
-    }
-    return modifier.class || null;
+  valueFor(position) {
+    return this.values[position];
   }
-  lookupBuiltInModifier(name) {
-    return BUILTIN_KEYWORD_MODIFIERS[name] ?? null;
+  memoFor(position) {
+    return this.keys[position];
   }
-  lookupComponent(name, owner) {
-    let pair = lookupComponentPair(owner, name);
-    if (pair === null) {
+}
+class NativeIterator {
+  static from(iterable) {
+    let iterator = iterable[Symbol.iterator]();
+    let result = iterator.next();
+    let {
+      done
+    } = result;
+    if (done) {
       return null;
-    }
-    let template = null;
-    let key;
-    if (pair.component === null) {
-      key = template = pair.layout(owner);
-    } else {
-      key = pair.component;
-    }
-    let cachedComponentDefinition = this.componentDefinitionCache.get(key);
-    if (cachedComponentDefinition !== undefined) {
-      return cachedComponentDefinition;
-    }
-    if (template === null && pair.layout !== null) {
-      template = pair.layout(owner);
-    }
-    let finalizer = _instrumentStart('render.getComponentDefinition', instrumentationPayload, name);
-    let definition = null;
-    if (pair.component === null) {
-      definition = {
-        state: templateOnlyComponent(undefined, name),
-        manager: TEMPLATE_ONLY_COMPONENT_MANAGER,
-        template
-      };
     } else {
-      let factory = pair.component;
-      let ComponentClass = factory.class;
-      let manager = getInternalComponentManager(ComponentClass);
-      definition = {
-        state: isCurlyManager(manager) ? factory : ComponentClass,
-        manager,
-        template
-      };
+      return new this(iterator, result);
     }
-    finalizer();
-    this.componentDefinitionCache.set(key, definition);
-    return definition;
   }
-}
-
-// We use the `InternalOwner` notion here because we actually need all of its
-// API for using with renderers (normally, it will be `EngineInstance`).
-// We use `getOwner` from our internal home for it rather than the narrower
-// public API for the same reason.
-const TOP_LEVEL_NAME = '-top-level';
-class OutletView {
-  static extend(injections) {
-    return class extends OutletView {
-      static create(options) {
-        if (options) {
-          return super.create(Object.assign({}, injections, options));
-        } else {
-          return super.create(injections);
-        }
-      }
-    };
+  position = 0;
+  constructor(iterable, result) {
+    this.iterable = iterable;
+    this.result = result;
   }
-  static reopenClass(injections) {
-    Object.assign(this, injections);
+  isEmpty() {
+    return false;
   }
-  static create(options) {
+  next() {
     let {
-      environment: _environment,
-      application: namespace,
-      template: templateFactory
-    } = options;
-    let owner = getOwner(options);
-    let template = templateFactory(owner);
-    return new OutletView(_environment, owner, template, namespace);
-  }
-  ref;
-  state;
-  constructor(_environment, owner, template, namespace) {
-    this._environment = _environment;
-    this.owner = owner;
-    this.template = template;
-    this.namespace = namespace;
-    let outletStateTag = createTag();
-    let outletState = {
-      outlets: {
-        main: undefined
-      },
-      render: {
-        owner: owner,
-        name: TOP_LEVEL_NAME,
-        controller: undefined,
-        model: undefined,
-        template
-      }
-    };
-    let ref = this.ref = createComputeRef(() => {
-      consumeTag(outletStateTag);
-      return outletState;
-    }, state => {
-      DIRTY_TAG$1(outletStateTag);
-      outletState.outlets['main'] = state;
-    });
-    this.state = {
-      ref,
-      name: TOP_LEVEL_NAME,
-      template,
-      controller: undefined
+      iterable,
+      result,
+      position
+    } = this;
+    if (result.done) {
+      return null;
+    }
+    let value = this.valueFor(result, position);
+    let memo = this.memoFor(result, position);
+    this.position++;
+    this.result = iterable.next();
+    return {
+      value,
+      memo
     };
   }
-  appendTo(selector) {
-    let target;
-    if (this._environment.hasDOM) {
-      target = typeof selector === 'string' ? document.querySelector(selector) : selector;
-    } else {
-      target = selector;
-    }
-    let renderer = this.owner.lookup('renderer:-dom');
-
-    // SAFETY: It's not clear that this cast is safe.
-    // The types for appendOutletView may be incorrect or this is a potential bug.
-    schedule('render', renderer, 'appendOutletView', this, target);
+}
+class ArrayLikeNativeIterator extends NativeIterator {
+  valueFor(result) {
+    return result.value;
   }
-  rerender() {
-    /**/
+  memoFor(_result, position) {
+    return position;
   }
-  setOutletState(state) {
-    updateRef(this.ref, state);
+}
+class MapLikeNativeIterator extends NativeIterator {
+  valueFor(result) {
+    return result.value[1];
   }
-  destroy() {
-    /**/
+  memoFor(result) {
+    return result.value[0];
   }
 }
+function hasForEach(value) {
+  return value != null && typeof value['forEach'] === 'function';
+}
+function isNativeIterable(value) {
+  return value != null && typeof value[Symbol.iterator] === 'function';
+}
+function isIndexable(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
 
-class DynamicScope {
-  constructor(view, outletState) {
-    this.view = view;
-    this.outletState = outletState;
-  }
-  child() {
-    return new DynamicScope(this.view, this.outletState);
+function toBool(predicate) {
+  if (isProxy(predicate)) {
+    consumeTag(tagForProperty(predicate, 'content'));
+    return Boolean(get$1(predicate, 'isTruthy'));
+  } else if (isArray(predicate)) {
+    consumeTag(tagForProperty(predicate, '[]'));
+    return predicate.length !== 0;
+  } else if (isHTMLSafe(predicate)) {
+    return Boolean(predicate.toString());
+  } else {
+    return Boolean(predicate);
   }
-  get(key) {
-    return this.outletState;
+}
+
+///////////
+
+// Setup global context
+
+setGlobalContext({
+  scheduleRevalidate() {
+    _backburner.ensureInstance();
+  },
+  toBool,
+  toIterator,
+  getProp: _getProp,
+  setProp: _setProp,
+  getPath: get$1,
+  setPath: set,
+  scheduleDestroy(destroyable, destructor) {
+    schedule('actions', null, destructor, destroyable);
+  },
+  scheduleDestroyed(finalizeDestructor) {
+    schedule('destroy', null, finalizeDestructor);
+  },
+  warnIfStyleNotTrusted(value) {
+  },
+  assert(test, msg, options) {
+  },
+  deprecate(msg, test, options) {
   }
-  set(key, value) {
-    this.outletState = value;
-    return value;
+});
+
+///////////
+
+// Define environment delegate
+
+class EmberEnvironmentDelegate {
+  enableDebugTooling = ENV._DEBUG_RENDER_TREE;
+  constructor(owner, isInteractive) {
+    this.owner = owner;
+    this.isInteractive = isInteractive;
   }
+  onTransactionCommit() {}
 }
+
 const NO_OP = () => {};
 
 // This wrapper logic prevents us from rerendering in case of a hard failure
@@ -1712,6 +963,13 @@ function errorLoopTransaction(fn) {
     return fn;
   }
 }
+
+/**
+ * The interface the `RendererState` needs from a render root. The base
+ * renderer only ever creates `ComponentRootState`s; the classic renderer
+ * (`./renderer`) adds `ClassicRootState` for outlet/classic-component roots.
+ */
+
 class ComponentRootState {
   type = 'component';
   #result;
@@ -1729,7 +987,7 @@ class ComponentRootState {
       });
     });
   }
-  isFor(_component) {
+  isFor(_possibleRoot) {
     return false;
   }
   render() {
@@ -1745,61 +1003,6 @@ class ComponentRootState {
     return this.#result;
   }
 }
-class ClassicRootState {
-  type = 'classic';
-  id;
-  result;
-  destroyed;
-  render;
-  env;
-  constructor(root, context, owner, template, self, parentElement, dynamicScope, builder) {
-    this.root = root;
-    this.id = root instanceof OutletView ? guidFor(root) : getViewId(root);
-    this.result = undefined;
-    this.destroyed = false;
-    this.env = context.env;
-    this.render = errorLoopTransaction(() => {
-      let layout = unwrapTemplate(template).asLayout();
-      let iterator = renderMain(context, owner, self, builder(context.env, {
-        element: parentElement,
-        nextSibling: null
-      }), layout, dynamicScope);
-      let result = this.result = iterator.sync();
-      associateDestroyableChild(this, result);
-      this.render = errorLoopTransaction(() => {
-        if (isDestroying(result) || isDestroyed(result)) return;
-        return result.rerender({
-          alwaysRevalidate: false
-        });
-      });
-    });
-  }
-  isFor(possibleRoot) {
-    return this.root === possibleRoot;
-  }
-  destroy() {
-    let {
-      result,
-      env
-    } = this;
-    this.destroyed = true;
-    this.root = null;
-    this.result = undefined;
-    this.render = undefined;
-    if (result !== undefined) {
-      /*
-       Handles these scenarios:
-        * When roots are removed during standard rendering process, a transaction exists already
-         `.begin()` / `.commit()` are not needed.
-       * When roots are being destroyed manually (`component.append(); component.destroy() case), no
-         transaction exists already.
-       * When roots are being destroyed during `Renderer#destroy`, no transaction exists
-        */
-
-      inTransaction(env, () => destroy(result));
-    }
-  }
-}
 const renderers = [];
 function _resetRenderers() {
   renderers.length = 0;
@@ -1828,7 +1031,12 @@ let renderSettledDeferred = null;
 */
 function renderSettled() {
   if (renderSettledDeferred === null) {
-    renderSettledDeferred = RSVP.defer();
+    let resolve;
+    let promise = new Promise(r => resolve = r);
+    renderSettledDeferred = {
+      promise,
+      resolve
+    };
     // if there is no current runloop, the promise created above will not have
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {
@@ -2185,138 +1393,6 @@ class BaseRenderer {
   rerender() {
     this.state.scheduleRevalidate(this);
   }
-
-  // render(component: Component, options: { into: Cursor; args?: Record<string, unknown> }): void {
-  //   this.state.renderRoot(component);
-  // }
-}
-class Renderer extends BaseRenderer {
-  static strict(owner, document, options) {
-    return new BaseRenderer(owner, {
-      hasDOM: hasDOM,
-      ...options
-    }, document, new ResolverImpl(), clientBuilder);
-  }
-  _rootTemplate;
-  _viewRegistry;
-  static create(props) {
-    let {
-      _viewRegistry
-    } = props;
-    let owner = getOwner(props);
-    let document = owner.lookup('service:-document');
-    let env = owner.lookup('-environment:main');
-    let rootTemplate = owner.lookup(privatize`template:-root`);
-    let builder = owner.lookup('service:-dom-builder');
-    return new this(owner, document, env, rootTemplate, _viewRegistry, builder);
-  }
-  constructor(owner, document, env, rootTemplate, viewRegistry, builder = clientBuilder, resolver = new ResolverImpl()) {
-    super(owner, env, document, resolver, builder);
-    this._rootTemplate = rootTemplate(owner);
-    this._viewRegistry = viewRegistry || owner.lookup('-view-registry:main');
-  }
-
-  // renderer HOOKS
-
-  appendOutletView(view, target) {
-    // TODO: This bypasses the {{outlet}} syntax so logically duplicates
-    // some of the set up code. Since this is all internal (or is it?),
-    // we can refactor this to do something more direct/less convoluted
-    // and with less setup, but get it working first
-    let outlet = createRootOutlet(view);
-    let {
-      name,
-      /* controller, */template
-    } = view.state;
-    let named = dict();
-    named['Component'] = createConstRef(makeRouteTemplate(view.owner, name, template));
-
-    // TODO: is this guaranteed to be undefined? It seems to be the
-    // case in the `OutletView` class. Investigate how much that class
-    // exists as an internal implementation detail only, or if it was
-    // used outside of core. As far as I can tell, test-helpers uses
-    // it but only for `setOutletState`.
-    // named['controller'] = createConstRef(controller, '@controller');
-    // Update: at least according to the debug render tree tests, we
-    // appear to always expect this to be undefined. Not a definitive
-    // source by any means, but is useful evidence
-    named['controller'] = UNDEFINED_REFERENCE;
-    named['model'] = UNDEFINED_REFERENCE;
-    let args = createCapturedArgs(named, EMPTY_POSITIONAL);
-    this._appendDefinition(view, curry(0, outlet, view.owner, args, true), target);
-  }
-  appendTo(view, target) {
-    let definition = new RootComponentDefinition(view);
-    this._appendDefinition(view, curry(0, definition, this.state.owner, null, true), target);
-  }
-  _appendDefinition(root, definition, target) {
-    let self = createConstRef(definition);
-    let dynamicScope = new DynamicScope(null, UNDEFINED_REFERENCE);
-    let rootState = new ClassicRootState(root, this.state.context, this.state.owner, this._rootTemplate, self, target, dynamicScope, this.state.builder);
-    this.state.renderRoot(rootState, this);
-  }
-  cleanupRootFor(component) {
-    // no need to cleanup roots if we have already been destroyed
-    if (isDestroyed(this)) {
-      return;
-    }
-    let roots = this.state.roots;
-
-    // traverse in reverse so we can remove items
-    // without mucking up the index
-    let i = roots.length;
-    while (i--) {
-      let root = roots[i];
-      if (root.type === 'classic' && root.isFor(component)) {
-        root.destroy();
-        roots.splice(i, 1);
-      }
-    }
-  }
-  remove(view) {
-    view._transitionTo('destroying');
-    this.cleanupRootFor(view);
-    if (this.state.isInteractive) {
-      view.trigger('didDestroyElement');
-    }
-  }
-  get _roots() {
-    return this.state.debug.roots;
-  }
-  get _inRenderTransaction() {
-    return this.state.debug.inRenderTransaction;
-  }
-  get _isInteractive() {
-    return this.state.debug.isInteractive;
-  }
-  get _context() {
-    return this.state.context;
-  }
-  register(view) {
-    let id = getViewId(view);
-    this._viewRegistry[id] = view;
-  }
-  unregister(view) {
-    delete this._viewRegistry[getViewId(view)];
-  }
-  getElement(component) {
-    if (this._isInteractive) {
-      return getViewElement(component);
-    } else {
-      throw new Error('Accessing `this.element` is not allowed in non-interactive environments (such as FastBoot).');
-    }
-  }
-  getBounds(component) {
-    let bounds = component[BOUNDS];
-    let parentElement = bounds.parentElement();
-    let firstNode = bounds.firstNode();
-    let lastNode = bounds.lastNode();
-    return {
-      parentElement,
-      firstNode,
-      lastNode
-    };
-  }
 }
 
-export { OutletView as O, Renderer as R, _resetRenderers as _, renderSettled as a, outletHelper as o, renderComponent as r };
+export { BaseRenderer as B, ResolverImpl as R, _resetRenderers as _, renderSettled as a, errorLoopTransaction as e, renderComponent as r };