ember-source 4.3.0-alpha.1 → 4.3.0-beta.1

package/dist/packages/@ember/-internals/glimmer/index.js

@@ -2,11 +2,11 @@ import { templateFactory, programCompilationContext } from '@glimmer/opcode-comp
 export { templateFactory as template, templateCacheCounters } from '@glimmer/opcode-compiler';
 import { setOwner, getOwner } from '@ember/-internals/owner';
 import { guidFor, symbol, enumerableSymbol, getDebugName, isProxy, isEmberArray, isObject, uuid } from '@ember/-internals/utils';
-import { assert, warn, debugFreeze, deprecate } from '@ember/debug';
+import { assert, warn, debugFreeze, inspect, deprecate } from '@ember/debug';
 import { setComponentTemplate, setInternalComponentManager, setInternalHelperManager, getInternalHelperManager, helperCapabilities, setHelperManager, capabilityFlagsFrom, setInternalModifierManager, getComponentTemplate, getInternalComponentManager, componentCapabilities, modifierCapabilities, setComponentManager } from '@glimmer/manager';
 import { createConstRef, isConstRef, valueForRef, isUpdatableRef, updateRef, childRefFor, childRefFromParts, createComputeRef, createPrimitiveRef, createUnboundRef, isInvokableRef, createInvokableRef, createReadOnlyRef, createDebugAliasRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
 import { untrack, consumeTag, createCache, getValue, tagFor, beginUntrackFrame, endUntrackFrame, valueForTag, beginTrackFrame, endTrackFrame, validateTag, createTag, dirtyTag, CONSTANT_TAG, isTracking, setTrackingTransactionEnv, createUpdatableTag, CURRENT_TAG } from '@glimmer/validator';
-import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, _getProp, _setProp, set } from '@ember/-internals/metal';
+import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, set, _getProp, _setProp } from '@ember/-internals/metal';
 import { action } from '@ember/object';
 import { hasDOM } from '@ember/-internals/browser-environment';
 import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
@@ -16,9 +16,9 @@ import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
 import { dasherize } from '@ember/string';
 import { registerDestructor, associateDestroyableChild, destroy } from '@glimmer/destroyable';
-import { join, _backburner, schedule, _getCurrentRunLoop } from '@ember/runloop';
+import { join, schedule, _backburner, _getCurrentRunLoop } from '@ember/runloop';
 import { _WeakSet, EMPTY_ARRAY, unwrapTemplate, dict } from '@glimmer/util';
-import { reifyPositional, normalizeProperty, EMPTY_ARGS, createCapturedArgs, curry, EMPTY_POSITIONAL, array, concat, fn, get as get$1, hash, on, TEMPLATE_ONLY_COMPONENT_MANAGER, templateOnlyComponent, clientBuilder, DOMChanges, DOMTreeConstruction, inTransaction, renderMain, runtimeContext, rehydrationBuilder } from '@glimmer/runtime';
+import { reifyPositional, normalizeProperty, EMPTY_ARGS, createCapturedArgs, curry, EMPTY_POSITIONAL, array, concat, fn, get as get$1, hash, on, templateOnlyComponent, TEMPLATE_ONLY_COMPONENT_MANAGER, clientBuilder, DOMChanges, DOMTreeConstruction, inTransaction, renderMain, runtimeContext, rehydrationBuilder } from '@glimmer/runtime';
 export { DOMChanges, DOMTreeConstruction, isSerializationFirstNode } from '@glimmer/runtime';
 import { TargetActionSupport, FrameworkObject, _contentFor, isArray } from '@ember/-internals/runtime';
 import { ENV } from '@ember/-internals/environment';
@@ -975,9 +975,15 @@ class LinkTo extends InternalComponent {
       try {
         return routing.generateURL(route, models, query);
       } catch (e) {
-        // tslint:disable-next-line:max-line-length
-        e.message = `While generating link to route "${route}": ${e.message}`;
-        throw e;
+        let details = e instanceof Error ? e.message : inspect(e);
+        let message = `While generating link to route "${route}": ${details}`;
+
+        if (e instanceof Error) {
+          e.message = message;
+          throw e;
+        } else {
+          throw message;
+        }
       }
     } else {
       return routing.generateURL(route, models, query);
@@ -1023,8 +1029,7 @@ class LinkTo extends InternalComponent {
       transition: undefined
     };
     flaggedInstrument('interaction.link-to', payload, () => {
-      assert('[BUG] route can only be missing if isLoading is true', isPresent(route)); // TODO: is the signature wrong? this.query is definitely NOT a QueryParam!
-
+      assert('[BUG] route can only be missing if isLoading is true', isPresent(route));
       payload.transition = routing.transitionTo(route, models, query, replace);
     });
   }
@@ -1054,8 +1059,7 @@ class LinkTo extends InternalComponent {
     } else {
       return EMPTY_ARRAY$1;
     }
-  } // TODO: this should probably be Record<string, unknown> or something
-
+  }
 
   get query() {
     if ('query' in this.args.named) {
@@ -1155,8 +1159,7 @@ class LinkTo extends InternalComponent {
         query,
         routing
       } = this;
-      assert('[BUG] route can only be missing if isLoading is true', isPresent(route)); // TODO: is the signature wrong? this.query is definitely NOT a QueryParam!
-
+      assert('[BUG] route can only be missing if isLoading is true', isPresent(route));
       return routing.isActiveForRoute(models, query, route, state);
     }
   }
@@ -1491,8 +1494,8 @@ function installAttributeBinding(component, rootRef, parsed, operations) {
       elementId = component.elementId;
     }
 
-    elementId = createPrimitiveRef(elementId);
-    operations.setAttribute('id', elementId, true, null);
+    let elementIdRef = createPrimitiveRef(elementId);
+    operations.setAttribute('id', elementIdRef, true, null);
     return;
   }
 
@@ -1502,7 +1505,11 @@ function installAttributeBinding(component, rootRef, parsed, operations) {
   operations.setAttribute(attribute, reference, false, null);
 }
 function createClassNameBindingRef(rootRef, microsyntax, operations) {
-  let [prop, truthy, falsy] = microsyntax.split(':');
+  let parts = microsyntax.split(':');
+  let [prop, truthy, falsy] = parts; // NOTE: This could be an empty string
+
+  assert('has prop', prop !== undefined); // Will always have at least one part
+
   let isStatic = prop === '';
 
   if (isStatic) {
@@ -1886,9 +1893,10 @@ var action$1 = internalHelper(args => {
   // Anything else is an action argument.
 
   let [context, action$$1, ...restArgs] = positional;
+  assert('hash position arguments', context && action$$1);
   let debugKey = action$$1.debugLabel;
-  let target = 'target' in named ? named.target : context;
-  let processArgs = makeArgsProcessor('value' in named && named.value, restArgs);
+  let target = 'target' in named && named.target ? named.target : context;
+  let processArgs = makeArgsProcessor('value' in named && named.value || false, restArgs);
   let fn$$1;
 
   if (isInvokableRef(action$$1)) {
@@ -1962,7 +1970,6 @@ function makeClosureAction(context, target, action$$1, processArgs, debugKey) {
     self = context;
     fn$$1 = action$$1;
   } else {
-    // tslint:disable-next-line:max-line-length
     assert(`An action could not be made for \`${debugKey || action$$1}\` in ${target}. Please confirm that you are using either a quoted action name (i.e. \`(action '${debugKey || 'myAction'}')\`) or a function available in ${target}.`, false);
   }
 
@@ -1999,6 +2006,7 @@ function processComponentArgs(namedArgs) {
 
   for (let name in namedArgs) {
     let ref = namedArgs[name];
+    assert('expected ref', ref);
     let value = valueForRef(ref);
     let isAction = typeof value === 'function' && ACTIONS.has(value);
 
@@ -2048,7 +2056,6 @@ const EMBER_VIEW_REF = createPrimitiveRef('ember-view');
 
 function aliasIdToElementId(args, props) {
   if (args.named.has('id')) {
-    // tslint:disable-next-line:max-line-length
     assert(`You cannot invoke a component with both 'id' and 'elementId' at the same time.`, !args.named.has('elementId'));
     props.elementId = props.id;
   }
@@ -2063,6 +2070,7 @@ function applyAttributeBindings(attributeBindings, component, rootRef, operation
 
   while (i !== -1) {
     let binding = attributeBindings[i];
+    assert('has binding', binding);
     let parsed = parseAttributeBinding(binding);
     let attribute = parsed[1];
 
@@ -2089,6 +2097,7 @@ class CurlyComponentManager {
       layoutName
     } = component;
     let owner = getOwner(component);
+    assert('Component is unexpectedly missing an owner', owner);
     let factory;
 
     if (layout === undefined) {
@@ -2141,8 +2150,9 @@ class CurlyComponentManager {
           {
         __ARGS__
       } = _b,
-          rest = __rest(_b, ["__ARGS__"]); // does this need to be untracked?
+          rest = __rest(_b, ["__ARGS__"]);
 
+      assert('[BUG] unexpectedly missing __ARGS__ after check', __ARGS__); // does this need to be untracked?
 
       let __args__ = valueForRef(__ARGS__);
 
@@ -2176,14 +2186,8 @@ class CurlyComponentManager {
       Object.assign(named, args.named.capture());
 
       for (let i = 0; i < count; i++) {
-        // As of TS 3.7, tsc is giving us the following error on this line without the type annotation
-        //
-        //   TS7022: 'name' implicitly has type 'any' because it does not have a type annotation and is
-        //   referenced directly or indirectly in its own initializer.
-        //
-        // This is almost certainly a TypeScript bug, feel free to try and remove the annotation after
-        // upgrading if it is not needed anymore.
-        const name = positionalParams[i];
+        let name = positionalParams[i];
+        assert('Expected at least one positional param', name);
         assert(`You cannot specify both a positional param (at position ${i}) and the hash argument \`${name}\`.`, !args.named.has(name));
         named[name] = args.positional.at(i);
       }
@@ -2443,9 +2447,7 @@ function processComponentInitializationAssertions(component, props) {
       classNameBindings
     } = component;
 
-    for (let i = 0; i < classNameBindings.length; i++) {
-      let binding = classNameBindings[i];
-
+    for (let binding of classNameBindings) {
       if (binding.split(' ').length > 1) {
         return false;
       }
@@ -3141,7 +3143,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
 
     if (DEBUG && eventDispatcher && this.renderer._isInteractive && this.tagName === '') {
       let eventNames = [];
-      let events = eventDispatcher.finalEventNameMapping; // tslint:disable-next-line:forin
+      let events = eventDispatcher.finalEventNameMapping;
 
       for (let key in events) {
         let methodName = events[key];
@@ -3152,14 +3154,14 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
       } // If in a tagless component, assert that no event handlers are defined
 
 
-      assert( // tslint:disable-next-line:max-line-length
-      `You can not define \`${eventNames}\` function(s) to handle DOM event in the \`${this}\` tagless component since it doesn't have any DOM element.`, !eventNames.length);
+      assert(`You can not define \`${eventNames}\` function(s) to handle DOM event in the \`${this}\` tagless component since it doesn't have any DOM element.`, !eventNames.length);
     }
   },
 
   get _dispatcher() {
     if (this.__dispatcher === undefined) {
       let owner = getOwner(this);
+      assert('Component is unexpectedly missing an owner', owner);
 
       if (owner.lookup('-environment:main').isInteractive) {
         this.__dispatcher = owner.lookup('event_dispatcher:main');
@@ -3404,6 +3406,59 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
    @since 1.13.0
    */
   didUpdate() {}
+  /**
+   Called when the component has updated and rerendered itself.
+   Called only during a rerender, not during an initial render.
+   @event didUpdate
+   @public
+   @since 1.13.0
+   */
+
+  /**
+    Layout can be used to wrap content in a component.
+    @property layout
+    @type Function
+    @public
+  */
+
+  /**
+    The name of the layout to lookup if no layout is provided.
+    By default `Component` will lookup a template with this name in
+    `Ember.TEMPLATES` (a shared global object).
+    @property layoutName
+    @type String
+    @default null
+    @private
+  */
+
+  /**
+    The HTML `id` of the component's element in the DOM. You can provide this
+    value yourself but it must be unique (just as in HTML):
+     ```handlebars
+    {{my-component elementId="a-really-cool-id"}}
+    ```
+     ```handlebars
+    <MyComponent @elementId="a-really-cool-id" />
+    ```
+    If not manually set a default value will be provided by the framework.
+    Once rendered an element's `elementId` is considered immutable and you
+    should never change it. If you need to compute a dynamic value for the
+    `elementId`, you should do this when the component or element is being
+    instantiated:
+     ```javascript
+    export default Component.extend({
+      init() {
+        this._super(...arguments);
+         var index = this.get('index');
+        this.set('elementId', `component-id${index}`);
+      }
+    });
+    ```
+     @property elementId
+    @type String
+    @public
+  */
+
 
 });
 
@@ -3418,60 +3473,15 @@ setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
 /**
 @module @ember/component
 */
+var _a;
 const RECOMPUTE_TAG = symbol('RECOMPUTE_TAG');
-/**
-  Ember Helpers are functions that can compute values, and are used in templates.
-  For example, this code calls a helper named `format-currency`:
-
-  ```app/templates/application.hbs
-  <Cost @cents={{230}} />
-  ```
+const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
 
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
-  ```
-
-  Additionally a helper can be called as a nested helper.
-  In this example, we show the formatted currency value if the `showMoney`
-  named argument is truthy.
-
-  ```handlebars
-  {{if @showMoney (format-currency @cents currency="$")}}
-  ```
-
-  Helpers defined using a class must provide a `compute` function. For example:
-
-  ```app/helpers/format-currency.js
-  import Helper from '@ember/component/helper';
-
-  export default class extends Helper {
-    compute([cents], { currency }) {
-      return `${currency}${cents * 0.01}`;
-    }
-  }
-  ```
-
-  Each time the input to a helper changes, the `compute` function will be
-  called again.
-
-  As instances, these helpers also have access to the container and will accept
-  injected dependencies.
-
-  Additionally, class helpers can call `recompute` to force a new computation.
-
-  @class Helper
-  @extends CoreObject
-  @public
-  @since 1.13.0
-*/
-
-let Helper = FrameworkObject.extend({
+class Helper extends FrameworkObject {
   init() {
-    this._super(...arguments);
-
+    super.init();
     this[RECOMPUTE_TAG] = createTag();
-  },
-
+  }
   /**
     On a class-based helper, it may be useful to force a recomputation of that
     helpers value. This is akin to `rerender` on a component.
@@ -3495,14 +3505,17 @@ let Helper = FrameworkObject.extend({
     @public
     @since 1.13.0
   */
+
+
   recompute() {
     join(() => dirtyTag(this[RECOMPUTE_TAG]));
   }
 
-});
-const IS_CLASSIC_HELPER = symbol('IS_CLASSIC_HELPER');
+}
+
+_a = IS_CLASSIC_HELPER;
 Helper.isHelperFactory = true;
-Helper[IS_CLASSIC_HELPER] = true;
+Helper[_a] = true;
 function isClassicHelper(obj) {
   return obj[IS_CLASSIC_HELPER] === true;
 }
@@ -3519,7 +3532,7 @@ class ClassicHelperManager {
   }
 
   createHelper(definition, args) {
-    let instance = definition.class === undefined ? definition.create(this.ownerInjection) : definition.create();
+    let instance = isFactoryManager(definition) ? definition.create() : definition.create(this.ownerInjection);
     return {
       instance,
       args
@@ -3551,6 +3564,10 @@ class ClassicHelperManager {
 
 }
 
+function isFactoryManager(obj) {
+  return obj != null && 'class' in obj;
+}
+
 setHelperManager(owner => {
   return new ClassicHelperManager(owner);
 }, Helper);
@@ -4131,7 +4148,8 @@ class EachInWrapper {
 var eachIn = internalHelper(({
   positional
 }) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
   return createComputeRef(() => {
     let iterable = valueForRef(inner);
     consumeTag(tagForObject(iterable));
@@ -4270,18 +4288,14 @@ class ObjectIterator extends BoundedIterator {
 
   static fromIndexable(obj) {
     let keys = Object.keys(obj);
-    let {
-      length
-    } = keys;
 
-    if (length === 0) {
+    if (keys.length === 0) {
       return null;
     } else {
       let values = [];
 
-      for (let i = 0; i < length; i++) {
+      for (let key of keys) {
         let value;
-        let key = keys[i];
         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
 
@@ -4516,6 +4530,7 @@ const VM_DEPRECATION_OVERRIDES = [{
   until: '4.4.0',
   for: 'ember-source',
   since: {
+    available: '3.28.0',
     enabled: '3.28.0'
   }
 }];
@@ -4540,14 +4555,14 @@ var disallowDynamicResolution = internalHelper(({
   positional,
   named
 }) => {
-  assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1);
-  let nameOrValueRef = positional[0];
-  assert(`[BUG] expecting \`type\` named argument`, 'type' in named);
-  assert(`[BUG] expecting \`loc\` named argument`, 'loc' in named);
-  assert(`[BUG] expecting \`original\` named argument`, 'original' in named);
+  const nameOrValueRef = positional[0];
+  assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef);
   let typeRef = named.type;
   let locRef = named.loc;
-  let originalRef = named.original; // Bug: why do these fail?
+  let originalRef = named.original;
+  assert(`[BUG] expecting \`type\` named argument`, typeRef);
+  assert(`[BUG] expecting \`loc\` named argument`, locRef);
+  assert(`[BUG] expecting \`original\` named argument`, originalRef); // Bug: why do these fail?
   // 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));
@@ -4569,7 +4584,8 @@ let helper$1;
 
 if (DEBUG) {
   helper$1 = args => {
-    let inner = args.positional[0];
+    const inner = args.positional[0];
+    assert('expected at least one positional arg', inner);
     return createComputeRef(() => {
       let value = valueForRef(inner);
       assert('You cannot pass a null or undefined destination element to in-element', value !== null && value !== undefined);
@@ -4577,7 +4593,11 @@ if (DEBUG) {
     });
   };
 } else {
-  helper$1 = args => args.positional[0];
+  helper$1 = args => {
+    let arg = args.positional[0];
+    assert('expected at least one positional arg', arg);
+    return arg;
+  };
 }
 
 var inElementNullCheckHelper = internalHelper(helper$1);
@@ -4586,9 +4606,14 @@ var normalizeClassHelper = internalHelper(({
   positional
 }) => {
   return createComputeRef(() => {
-    let classNameParts = valueForRef(positional[0]).split('.');
+    let classNameArg = positional[0];
+    let valueArg = positional[1];
+    assert('expected at least two positional args', classNameArg && valueArg);
+    let classNameParts = valueForRef(classNameArg).split('.');
     let className = classNameParts[classNameParts.length - 1];
-    let value = valueForRef(positional[1]);
+    assert('has className', className); // Always at least one split result
+
+    let value = valueForRef(valueArg);
 
     if (value === true) {
       return dasherize(className);
@@ -4609,7 +4634,7 @@ var resolve = internalHelper(({
   assert('[BUG] missing owner', owner);
   assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1);
   let fullNameRef = positional[0];
-  assert('[BUG] expecting a string literal as argument', isConstRef(fullNameRef));
+  assert('[BUG] expecting a string literal as argument', fullNameRef && isConstRef(fullNameRef));
   let fullName = valueForRef(fullNameRef);
   assert('[BUG] expecting a string literal as argument', typeof fullName === 'string');
   assert('[BUG] expecting a valid full name', fullName.split(':').length === 2);
@@ -4634,7 +4659,8 @@ var resolve = internalHelper(({
 var trackArray = internalHelper(({
   positional
 }) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
   return createComputeRef(() => {
     let iterable = valueForRef(inner);
 
@@ -4726,7 +4752,8 @@ var trackArray = internalHelper(({
 var mut = internalHelper(({
   positional
 }) => {
-  let ref = positional[0]; // TODO: Improve this error message. This covers at least two distinct
+  let ref = positional[0];
+  assert('expected at least one positional arg', ref); // TODO: Improve this error message. This covers at least two distinct
   // cases:
   //
   // 1. (mut "not a path") – passing a literal, result from a helper
@@ -4862,7 +4889,9 @@ var mut = internalHelper(({
 var readonly = internalHelper(({
   positional
 }) => {
-  return createReadOnlyRef(positional[0]);
+  let firstArg = positional[0];
+  assert('has first arg', firstArg);
+  return createReadOnlyRef(firstArg);
 });
 
 /**
@@ -4901,7 +4930,7 @@ var unbound = internalHelper(({
   named
 }) => {
   assert('unbound helper cannot be called with multiple params or hash params', positional.length === 1 && Object.keys(named).length === 0);
-  return createUnboundRef(valueForRef(positional[0]), '(resurt of an `unbound` helper)');
+  return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
 });
 
 const MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
@@ -5120,6 +5149,7 @@ class ActionModifierManager {
       positional
     } = actionState;
     let actionNameRef = positional[1];
+    assert('Expected at least one positional arg', actionNameRef);
 
     if (!isInvokableRef(actionNameRef)) {
       actionState.actionName = valueForRef(actionNameRef);
@@ -5413,7 +5443,9 @@ const outletHelper = internalHelper((args, owner, scope) => {
   if (args.positional.length === 0) {
     nameRef = createPrimitiveRef('main');
   } else {
-    nameRef = args.positional[0];
+    let maybeNameRef = args.positional[0];
+    assert('Expected at least one positional arg', maybeNameRef);
+    nameRef = maybeNameRef;
   }
 
   let outletRef = createComputeRef(() => {
@@ -5744,13 +5776,11 @@ class DynamicScope {
   }
 
   get(key) {
-    // tslint:disable-next-line:max-line-length
     assert(`Using \`-get-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`, key === 'outletState');
     return this.outletState;
   }
 
   set(key, value) {
-    // tslint:disable-next-line:max-line-length
     assert(`Using \`-with-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`, key === 'outletState');
     this.outletState = value;
     return value;
@@ -5773,6 +5803,7 @@ function errorLoopTransaction(fn$$1) {
           // Noop the function so that we won't keep calling it and causing
           // infinite looping failures;
           fn$$1 = () => {
+            // eslint-disable-next-line no-console
             console.warn('Attempted to rerender, but the Ember application has had an unrecoverable error occur during render. You should reload the application after fixing the cause of the error.');
           };
         }
@@ -5854,8 +5885,8 @@ function deregister(renderer) {
 }
 
 function loopBegin() {
-  for (let i = 0; i < renderers.length; i++) {
-    renderers[i]._scheduleRevalidate();
+  for (let renderer of renderers) {
+    renderer._scheduleRevalidate();
   }
 }
 
@@ -5900,12 +5931,12 @@ function resolveRenderPromise() {
 let loops = 0;
 
 function loopEnd() {
-  for (let i = 0; i < renderers.length; i++) {
-    if (!renderers[i]._isValid()) {
+  for (let renderer of renderers) {
+    if (!renderer._isValid()) {
       if (loops > ENV._RERENDER_LOOP_LIMIT) {
         loops = 0; // TODO: do something better
 
-        renderers[i].destroy();
+        renderer.destroy();
         throw new Error('infinite rendering invalidation detected');
       }
 
@@ -5949,12 +5980,13 @@ class Renderer {
     let {
       _viewRegistry
     } = props;
-    let document = getOwner(props).lookup('service:-document');
-    let env = getOwner(props).lookup('-environment:main');
     let owner = getOwner(props);
+    assert('Renderer is unexpectedly missing an owner', owner);
+    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(getOwner(props), document, env, rootTemplate, _viewRegistry, builder);
+    return new this(owner, document, env, rootTemplate, _viewRegistry, builder);
   }
 
   get debugRenderTree() {
@@ -6027,6 +6059,7 @@ class Renderer {
 
     while (i--) {
       let root = roots[i];
+      assert('has root', root);
 
       if (root.isFor(view)) {
         root.destroy();
@@ -6098,6 +6131,7 @@ class Renderer {
         // each root is processed
         for (let i = 0; i < roots.length; i++) {
           let root = roots[i];
+          assert('has root', root);
 
           if (root.destroyed) {
             // add to the list of roots to be removed
@@ -6160,8 +6194,7 @@ class Renderer {
   _clearAllRoots() {
     let roots = this._roots;
 
-    for (let i = 0; i < roots.length; i++) {
-      let root = roots[i];
+    for (let root of roots) {
       root.destroy();
     }
 
@@ -6282,6 +6315,7 @@ class OutletView {
       template: templateFactory$$1
     } = options;
     let owner = getOwner(options);
+    assert('OutletView is unexpectedly missing an owner', owner);
     let template = templateFactory$$1(owner);
     return new OutletView(_environment, owner, template, namespace);
   }
@@ -6319,7 +6353,9 @@ function setupApplicationRegistry(registry) {
   // association won't leak
   registry.register('service:-dom-builder', {
     create(props) {
-      let env = getOwner(props).lookup('-environment:main');
+      let owner = getOwner(props);
+      assert('DomBuilderService is unexpectedly missing an owner', owner);
+      let env = owner.lookup('-environment:main');
 
       switch (env._renderMode) {
         case 'serialize':