ember-source 6.0.0-alpha.9 → 6.0.0

package/dist/packages/@glimmer/manager/index.js

@@ -1,9 +1,8 @@
 import { debugToString as debugToString$1, castToBrowser } from '../util/index.js';
 import { associateDestroyableChild, registerDestructor } from '../destroyable/index.js';
 import { createComputeRef, createConstRef, UNDEFINED_REFERENCE, valueForRef } from '../reference/index.js';
-import { untrack, createUpdatableTag, track } from '../validator/index.js';
-import { check, CheckNumber } from '../debug/index.js';
-import { InternalComponentCapabilities } from '../vm/index.js';
+import { untrack, track, createUpdatableTag } from '../validator/index.js';
+import { Op, InternalComponentCapabilities } from '../vm/index.js';
 import { isDevelopingApp } from '@embroider/macros';
 
 const CUSTOM_TAG_FOR = new WeakMap();
@@ -14,30 +13,9 @@ function setCustomTagFor(obj, customTagFn) {
   CUSTOM_TAG_FOR.set(obj, customTagFn);
 }
 function convertToInt(prop) {
-  if (typeof prop === 'symbol') return null;
+  if ("symbol" == typeof prop) return null;
   const num = Number(prop);
-  if (isNaN(num)) return null;
-  return num % 1 === 0 ? num : null;
-}
-function tagForNamedArg(namedArgs, key) {
-  return track(() => {
-    if (key in namedArgs) {
-      valueForRef(namedArgs[key]);
-    }
-  });
-}
-function tagForPositionalArg(positionalArgs, key) {
-  return track(() => {
-    if (key === '[]') {
-      // consume all of the tags in the positional array
-      positionalArgs.forEach(valueForRef);
-    }
-    const parsed = convertToInt(key);
-    if (parsed !== null && parsed < positionalArgs.length) {
-      // consume the tag of the referenced index
-      valueForRef(positionalArgs[parsed]);
-    }
-  });
+  return isNaN(num) ? null : num % 1 == 0 ? num : null;
 }
 class NamedArgsProxy {
   constructor(named) {
@@ -45,9 +23,7 @@ class NamedArgsProxy {
   }
   get(_target, prop) {
     const ref = this.named[prop];
-    if (ref !== undefined) {
-      return valueForRef(ref);
-    }
+    if (void 0 !== ref) return valueForRef(ref);
   }
   has(_target, prop) {
     return prop in this.named;
@@ -56,15 +32,13 @@ class NamedArgsProxy {
     return Object.keys(this.named);
   }
   isExtensible() {
-    return false;
+    return !1;
   }
   getOwnPropertyDescriptor(_target, prop) {
-    if (isDevelopingApp() && !(prop in this.named)) {
-      throw new Error(`args proxies do not have real property descriptors, so you should never need to call getOwnPropertyDescriptor yourself. This code exists for enumerability, such as in for-in loops and Object.keys(). Attempted to get the descriptor for \`${String(prop)}\``);
-    }
+    if (isDevelopingApp() && !(prop in this.named)) throw new Error(`args proxies do not have real property descriptors, so you should never need to call getOwnPropertyDescriptor yourself. This code exists for enumerability, such as in for-in loops and Object.keys(). Attempted to get the descriptor for \`${String(prop)}\``);
     return {
-      enumerable: true,
-      configurable: true
+      enumerable: !0,
+      configurable: !0
     };
   }
 }
@@ -74,92 +48,86 @@ class PositionalArgsProxy {
   }
   get(target, prop) {
     let {
-      positional
+      positional: positional
     } = this;
-    if (prop === 'length') {
-      return positional.length;
-    }
+    if ("length" === prop) return positional.length;
     const parsed = convertToInt(prop);
-    if (parsed !== null && parsed < positional.length) {
-      return valueForRef(positional[parsed]);
-    }
-    return target[prop];
+    return null !== parsed && parsed < positional.length ? valueForRef(positional[parsed]) : target[prop];
   }
   isExtensible() {
-    return false;
+    return !1;
   }
   has(_target, prop) {
     const parsed = convertToInt(prop);
-    return parsed !== null && parsed < this.positional.length;
+    return null !== parsed && parsed < this.positional.length;
   }
 }
 const argsProxyFor = (capturedArgs, type) => {
   const {
-    named,
-    positional
-  } = capturedArgs;
-  let getNamedTag = (_obj, key) => tagForNamedArg(named, key);
-  let getPositionalTag = (_obj, key) => tagForPositionalArg(positional, key);
-  const namedHandler = new NamedArgsProxy(named);
-  const positionalHandler = new PositionalArgsProxy(positional);
-  const namedTarget = Object.create(null);
-  const positionalTarget = [];
+      named: named,
+      positional: positional
+    } = capturedArgs,
+    namedHandler = new NamedArgsProxy(named),
+    positionalHandler = new PositionalArgsProxy(positional),
+    namedTarget = Object.create(null);
   if (isDevelopingApp()) {
     const setHandler = function (_target, prop) {
-      throw new Error(`You attempted to set ${String(prop)} on the arguments of a component, helper, or modifier. Arguments are immutable and cannot be updated directly; they always represent the values that are passed down. If you want to set default values, you should use a getter and local tracked state instead.`);
-    };
-    const forInDebugHandler = () => {
-      throw new Error(`Object.keys() was called on the positional arguments array for a ${type}, which is not supported. This function is a low-level function that should not need to be called for positional argument arrays. You may be attempting to iterate over the array using for...in instead of for...of.`);
-    };
-    namedHandler.set = setHandler;
-    positionalHandler.set = setHandler;
-    positionalHandler.ownKeys = forInDebugHandler;
-  }
-  const namedProxy = new Proxy(namedTarget, namedHandler);
-  const positionalProxy = new Proxy(positionalTarget, positionalHandler);
-  setCustomTagFor(namedProxy, getNamedTag);
-  setCustomTagFor(positionalProxy, getPositionalTag);
-  return {
+        throw new Error(`You attempted to set ${String(prop)} on the arguments of a component, helper, or modifier. Arguments are immutable and cannot be updated directly; they always represent the values that are passed down. If you want to set default values, you should use a getter and local tracked state instead.`);
+      },
+      forInDebugHandler = () => {
+        throw new Error(`Object.keys() was called on the positional arguments array for a ${type}, which is not supported. This function is a low-level function that should not need to be called for positional argument arrays. You may be attempting to iterate over the array using for...in instead of for...of.`);
+      };
+    namedHandler.set = setHandler, positionalHandler.set = setHandler, positionalHandler.ownKeys = forInDebugHandler;
+  }
+  const namedProxy = new Proxy(namedTarget, namedHandler),
+    positionalProxy = new Proxy([], positionalHandler);
+  return setCustomTagFor(namedProxy, (_obj, key) => function (namedArgs, key) {
+    return track(() => {
+      key in namedArgs && valueForRef(namedArgs[key]);
+    });
+  }(named, key)), setCustomTagFor(positionalProxy, (_obj, key) => function (positionalArgs, key) {
+    return track(() => {
+      "[]" === key &&
+      // consume all of the tags in the positional array
+      positionalArgs.forEach(valueForRef);
+      const parsed = convertToInt(key);
+      null !== parsed && parsed < positionalArgs.length &&
+      // consume the tag of the referenced index
+      valueForRef(positionalArgs[parsed]);
+    });
+  }(positional, key)), {
     named: namedProxy,
     positional: positionalProxy
   };
 };
-const FROM_CAPABILITIES = isDevelopingApp() ? new WeakSet() : undefined;
+
+/* This file is generated by build/debug.js */
+new Array(Op.Size).fill(null), new Array(Op.Size).fill(null);
+const FROM_CAPABILITIES = isDevelopingApp() ? new WeakSet() : void 0;
 function buildCapabilities(capabilities) {
-  if (isDevelopingApp()) {
-    FROM_CAPABILITIES.add(capabilities);
-    Object.freeze(capabilities);
-  }
-  return capabilities;
+  return isDevelopingApp() && (FROM_CAPABILITIES.add(capabilities), Object.freeze(capabilities)), capabilities;
 }
 const EMPTY = InternalComponentCapabilities.Empty;
+
 /**
  * Converts a ComponentCapabilities object into a 32-bit integer representation.
  */
 function capabilityFlagsFrom(capabilities) {
-  return EMPTY | capability(capabilities, 'dynamicLayout') | capability(capabilities, 'dynamicTag') | capability(capabilities, 'prepareArgs') | capability(capabilities, 'createArgs') | capability(capabilities, 'attributeHook') | capability(capabilities, 'elementHook') | capability(capabilities, 'dynamicScope') | capability(capabilities, 'createCaller') | capability(capabilities, 'updateHook') | capability(capabilities, 'createInstance') | capability(capabilities, 'wrapped') | capability(capabilities, 'willDestroy') | capability(capabilities, 'hasSubOwner');
+  return EMPTY | capability(capabilities, "dynamicLayout") | capability(capabilities, "dynamicTag") | capability(capabilities, "prepareArgs") | capability(capabilities, "createArgs") | capability(capabilities, "attributeHook") | capability(capabilities, "elementHook") | capability(capabilities, "dynamicScope") | capability(capabilities, "createCaller") | capability(capabilities, "updateHook") | capability(capabilities, "createInstance") | capability(capabilities, "wrapped") | capability(capabilities, "willDestroy") | capability(capabilities, "hasSubOwner");
 }
 function capability(capabilities, capability) {
   return capabilities[capability] ? InternalComponentCapabilities[capability] : EMPTY;
 }
 function managerHasCapability(_manager, capabilities, capability) {
-  check(capabilities, CheckNumber);
   return !!(capabilities & capability);
 }
 function hasCapability(capabilities, capability) {
-  check(capabilities, CheckNumber);
   return !!(capabilities & capability);
 }
 function helperCapabilities(managerAPI, options = {}) {
-  if (isDevelopingApp() && managerAPI !== '3.23') {
-    throw new Error('Invalid helper manager compatibility specified');
-  }
-  if (isDevelopingApp() && (!(options.hasValue || options.hasScheduledEffect) || options.hasValue && options.hasScheduledEffect)) {
-    throw new Error('You must pass either the `hasValue` OR the `hasScheduledEffect` capability when defining a helper manager. Passing neither, or both, is not permitted.');
-  }
-  if (isDevelopingApp() && options.hasScheduledEffect) {
-    throw new Error('The `hasScheduledEffect` capability has not yet been implemented for helper managers. Please pass `hasValue` instead');
-  }
+  if (isDevelopingApp() && "3.23" !== managerAPI) throw new Error("Invalid helper manager compatibility specified");
+  if (isDevelopingApp() && (!options.hasValue && !options.hasScheduledEffect || options.hasValue && options.hasScheduledEffect)) throw new Error("You must pass either the `hasValue` OR the `hasScheduledEffect` capability when defining a helper manager. Passing neither, or both, is not permitted.");
+  if (isDevelopingApp() && options.hasScheduledEffect) throw new Error("The `hasScheduledEffect` capability has not yet been implemented for helper managers. Please pass `hasValue` instead");
   return buildCapabilities({
     hasValue: Boolean(options.hasValue),
     hasDestroyable: Boolean(options.hasDestroyable),
@@ -168,7 +136,6 @@ function helperCapabilities(managerAPI, options = {}) {
 }
 
 ////////////
-
 function hasValue(manager) {
   return manager.capabilities.hasValue;
 }
@@ -177,7 +144,6 @@ function hasDestroyable(manager) {
 }
 
 ////////////
-
 class CustomHelperManager {
   constructor(factory) {
     this.factory = factory;
@@ -186,130 +152,99 @@ class CustomHelperManager {
   undefinedDelegate = null;
   getDelegateForOwner(owner) {
     let delegate = this.helperManagerDelegates.get(owner);
-    if (delegate === undefined) {
+    if (void 0 === delegate) {
       let {
-        factory
+        factory: factory
       } = this;
-      delegate = factory(owner);
-      if (isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities)) {
+      if (delegate = factory(owner), isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities))
         // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(`Custom helper managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.23')\` (imported via \`import { capabilities } from '@ember/helper';\`). Received: \`${JSON.stringify(delegate.capabilities)}\` for: \`${delegate}\``);
-      }
       this.helperManagerDelegates.set(owner, delegate);
     }
     return delegate;
   }
   getDelegateFor(owner) {
-    if (owner === undefined) {
+    if (void 0 === owner) {
       let {
-        undefinedDelegate
+        undefinedDelegate: undefinedDelegate
       } = this;
-      if (undefinedDelegate === null) {
+      if (null === undefinedDelegate) {
         let {
-          factory
+          factory: factory
         } = this;
-        this.undefinedDelegate = undefinedDelegate = factory(undefined);
+        this.undefinedDelegate = undefinedDelegate = factory(void 0);
       }
       return undefinedDelegate;
-    } else {
-      return this.getDelegateForOwner(owner);
     }
+    return this.getDelegateForOwner(owner);
   }
   getHelper(definition) {
     return (capturedArgs, owner) => {
       let manager = this.getDelegateFor(owner);
-      const args = argsProxyFor(capturedArgs, 'helper');
-      const bucket = manager.createHelper(definition, args);
+      const args = argsProxyFor(capturedArgs, "helper"),
+        bucket = manager.createHelper(definition, args);
       if (hasValue(manager)) {
         let cache = createComputeRef(() => manager.getValue(bucket), null, isDevelopingApp() && manager.getDebugName && manager.getDebugName(definition));
-        if (hasDestroyable(manager)) {
-          associateDestroyableChild(cache, manager.getDestroyable(bucket));
-        }
-        return cache;
-      } else if (hasDestroyable(manager)) {
-        let ref = createConstRef(undefined, isDevelopingApp() && (manager.getDebugName?.(definition) ?? 'unknown helper'));
-        associateDestroyableChild(ref, manager.getDestroyable(bucket));
-        return ref;
-      } else {
-        return UNDEFINED_REFERENCE;
+        return hasDestroyable(manager) && associateDestroyableChild(cache, manager.getDestroyable(bucket)), cache;
+      }
+      if (hasDestroyable(manager)) {
+        let ref = createConstRef(void 0, isDevelopingApp() && (manager.getDebugName?.(definition) ?? "unknown helper"));
+        return associateDestroyableChild(ref, manager.getDestroyable(bucket)), ref;
       }
+      return UNDEFINED_REFERENCE;
     };
   }
 }
 class FunctionHelperManager {
   capabilities = buildCapabilities({
-    hasValue: true,
-    hasDestroyable: false,
-    hasScheduledEffect: false
+    hasValue: !0,
+    hasDestroyable: !1,
+    hasScheduledEffect: !1
   });
   createHelper(fn, args) {
     return {
-      fn,
-      args
+      fn: fn,
+      args: args
     };
   }
   getValue({
-    fn,
-    args
+    fn: fn,
+    args: args
   }) {
-    if (Object.keys(args.named).length > 0) {
-      let argsForFn = [...args.positional, args.named];
-      return fn(...argsForFn);
-    }
-    return fn(...args.positional);
+    return Object.keys(args.named).length > 0 ? fn(...args.positional, args.named) : fn(...args.positional);
   }
   getDebugName(fn) {
-    if (fn.name) {
-      return `(helper function ${fn.name})`;
-    }
-    return '(anonymous helper function)';
+    return fn.name ? `(helper function ${fn.name})` : "(anonymous helper function)";
   }
 }
-const COMPONENT_MANAGERS = new WeakMap();
-const MODIFIER_MANAGERS = new WeakMap();
-const HELPER_MANAGERS = new WeakMap();
-
-///////////
-
-const getPrototypeOf$1 = Object.getPrototypeOf;
+const COMPONENT_MANAGERS = new WeakMap(),
+  MODIFIER_MANAGERS = new WeakMap(),
+  HELPER_MANAGERS = new WeakMap(),
+  getPrototypeOf$1 = Object.getPrototypeOf;
 function setManager(map, manager, obj) {
-  if (isDevelopingApp() && (typeof obj !== 'object' || obj === null) && typeof obj !== 'function') {
-    throw new Error(`Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${debugToString$1(obj)}`);
-  }
-  if (isDevelopingApp() && map.has(obj)) {
-    throw new Error(`Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${debugToString$1(obj)}`);
-  }
-  map.set(obj, manager);
-  return obj;
+  if (isDevelopingApp() && ("object" != typeof obj || null === obj) && "function" != typeof obj) throw new Error(`Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${debugToString$1(obj)}`);
+  if (isDevelopingApp() && map.has(obj)) throw new Error(`Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${debugToString$1(obj)}`);
+  return map.set(obj, manager), obj;
 }
 function getManager(map, obj) {
   let pointer = obj;
-  while (pointer !== undefined && pointer !== null) {
+  for (; null != pointer;) {
     const manager = map.get(pointer);
-    if (manager !== undefined) {
-      return manager;
-    }
+    if (void 0 !== manager) return manager;
     pointer = getPrototypeOf$1(pointer);
   }
-  return undefined;
 }
 
 ///////////
-
 function setInternalModifierManager(manager, definition) {
   return setManager(MODIFIER_MANAGERS, manager, definition);
 }
 function getInternalModifierManager(definition, isOptional) {
-  if (isDevelopingApp() && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
-    throw new Error(`Attempted to use a value as a modifier, but it was not an object or function. Modifier definitions must be objects or functions with an associated modifier manager. The value was: ${definition}`);
-  }
+  if (isDevelopingApp() && "function" != typeof definition && ("object" != typeof definition || null === definition)) throw new Error(`Attempted to use a value as a modifier, but it was not an object or function. Modifier definitions must be objects or functions with an associated modifier manager. The value was: ${definition}`);
   const manager = getManager(MODIFIER_MANAGERS, definition);
-  if (manager === undefined) {
-    if (isOptional === true) {
-      return null;
-    } else if (isDevelopingApp()) {
-      throw new Error(`Attempted to load a modifier, but there wasn't a modifier manager associated with the definition. The definition was: ${debugToString$1(definition)}`);
-    }
+  if (void 0 === manager) {
+    if (!0 === isOptional) return null;
+    if (isDevelopingApp()) throw new Error(`Attempted to load a modifier, but there wasn't a modifier manager associated with the definition. The definition was: ${debugToString$1(definition)}`);
   }
   return manager;
 }
@@ -318,81 +253,62 @@ function setInternalHelperManager(manager, definition) {
 }
 const DEFAULT_MANAGER = new CustomHelperManager(() => new FunctionHelperManager());
 function getInternalHelperManager(definition, isOptional) {
-  if (isDevelopingApp() && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
-    throw new Error(`Attempted to use a value as a helper, but it was not an object or function. Helper definitions must be objects or functions with an associated helper manager. The value was: ${definition}`);
-  }
+  if (isDevelopingApp() && "function" != typeof definition && ("object" != typeof definition || null === definition)) throw new Error(`Attempted to use a value as a helper, but it was not an object or function. Helper definitions must be objects or functions with an associated helper manager. The value was: ${definition}`);
   let manager = getManager(HELPER_MANAGERS, definition);
-
   // Functions are special-cased because functions are defined
   // as the "default" helper, per: https://github.com/emberjs/rfcs/pull/756
-  if (manager === undefined && typeof definition === 'function') {
-    manager = DEFAULT_MANAGER;
-  }
-  if (manager) {
-    return manager;
-  } else if (isOptional === true) {
-    return null;
-  } else if (isDevelopingApp()) {
-    throw new Error(`Attempted to load a helper, but there wasn't a helper manager associated with the definition. The definition was: ${debugToString$1(definition)}`);
-  }
+  if (void 0 === manager && "function" == typeof definition && (manager = DEFAULT_MANAGER), manager) return manager;
+  if (!0 === isOptional) return null;
+  if (isDevelopingApp()) throw new Error(`Attempted to load a helper, but there wasn't a helper manager associated with the definition. The definition was: ${debugToString$1(definition)}`);
   return null;
 }
 function setInternalComponentManager(factory, obj) {
   return setManager(COMPONENT_MANAGERS, factory, obj);
 }
 function getInternalComponentManager(definition, isOptional) {
-  if (isDevelopingApp() && typeof definition !== 'function' && (typeof definition !== 'object' || definition === null)) {
-    throw new Error(`Attempted to use a value as a component, but it was not an object or function. Component definitions must be objects or functions with an associated component manager. The value was: ${definition}`);
-  }
+  if (isDevelopingApp() && "function" != typeof definition && ("object" != typeof definition || null === definition)) throw new Error(`Attempted to use a value as a component, but it was not an object or function. Component definitions must be objects or functions with an associated component manager. The value was: ${definition}`);
   const manager = getManager(COMPONENT_MANAGERS, definition);
-  if (manager === undefined) {
-    if (isOptional === true) {
-      return null;
-    } else if (isDevelopingApp()) {
-      throw new Error(`Attempted to load a component, but there wasn't a component manager associated with the definition. The definition was: ${debugToString$1(definition)}`);
-    }
+  if (void 0 === manager) {
+    if (!0 === isOptional) return null;
+    if (isDevelopingApp()) throw new Error(`Attempted to load a component, but there wasn't a component manager associated with the definition. The definition was: ${debugToString$1(definition)}`);
   }
   return manager;
 }
 
 ///////////
-
 function hasInternalComponentManager(definition) {
-  return getManager(COMPONENT_MANAGERS, definition) !== undefined;
+  return void 0 !== getManager(COMPONENT_MANAGERS, definition);
 }
 function hasInternalHelperManager(definition) {
-  return hasDefaultHelperManager(definition) || getManager(HELPER_MANAGERS, definition) !== undefined;
+  return function (definition) {
+    return "function" == typeof definition;
+  }(definition) || void 0 !== getManager(HELPER_MANAGERS, definition);
 }
 function hasInternalModifierManager(definition) {
-  return getManager(MODIFIER_MANAGERS, definition) !== undefined;
-}
-function hasDefaultHelperManager(definition) {
-  return typeof definition === 'function';
+  return void 0 !== getManager(MODIFIER_MANAGERS, definition);
 }
 const CAPABILITIES = {
-  dynamicLayout: false,
-  dynamicTag: false,
-  prepareArgs: false,
-  createArgs: true,
-  attributeHook: false,
-  elementHook: false,
-  createCaller: false,
-  dynamicScope: true,
-  updateHook: true,
-  createInstance: true,
-  wrapped: false,
-  willDestroy: false,
-  hasSubOwner: false
+  dynamicLayout: !1,
+  dynamicTag: !1,
+  prepareArgs: !1,
+  createArgs: !0,
+  attributeHook: !1,
+  elementHook: !1,
+  createCaller: !1,
+  dynamicScope: !0,
+  updateHook: !0,
+  createInstance: !0,
+  wrapped: !1,
+  willDestroy: !1,
+  hasSubOwner: !1
 };
 function componentCapabilities(managerAPI, options = {}) {
-  if (isDevelopingApp() && managerAPI !== '3.13') {
-    throw new Error('Invalid component manager compatibility specified');
-  }
+  if (isDevelopingApp() && "3.13" !== managerAPI) throw new Error("Invalid component manager compatibility specified");
   let updateHook = Boolean(options.updateHook);
   return buildCapabilities({
     asyncLifeCycleCallbacks: Boolean(options.asyncLifecycleCallbacks),
     destructor: Boolean(options.destructor),
-    updateHook
+    updateHook: updateHook
   });
 }
 function hasAsyncLifeCycleCallbacks(delegate) {
@@ -401,12 +317,6 @@ function hasAsyncLifeCycleCallbacks(delegate) {
 function hasUpdateHook(delegate) {
   return delegate.capabilities.updateHook;
 }
-function hasAsyncUpdateHook(delegate) {
-  return hasAsyncLifeCycleCallbacks(delegate) && hasUpdateHook(delegate);
-}
-function hasDestructors(delegate) {
-  return delegate.capabilities.destructor;
-}
 
 /**
   The CustomComponentManager allows addons to provide custom component
@@ -440,77 +350,74 @@ class CustomComponentManager {
   }
   getDelegateFor(owner) {
     let {
-      componentManagerDelegates
-    } = this;
-    let delegate = componentManagerDelegates.get(owner);
-    if (delegate === undefined) {
+        componentManagerDelegates: componentManagerDelegates
+      } = this,
+      delegate = componentManagerDelegates.get(owner);
+    if (void 0 === delegate) {
       let {
-        factory
+        factory: factory
       } = this;
-      delegate = factory(owner);
-      if (isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities)) {
+      if (delegate = factory(owner), isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities))
         // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(`Custom component managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.13')\` (imported via \`import { capabilities } from '@ember/component';\`). Received: \`${JSON.stringify(delegate.capabilities)}\` for: \`${delegate}\``);
-      }
       componentManagerDelegates.set(owner, delegate);
     }
     return delegate;
   }
   create(owner, definition, vmArgs) {
-    let delegate = this.getDelegateFor(owner);
-    let args = argsProxyFor(vmArgs.capture(), 'component');
-    let component = delegate.createComponent(definition, args);
+    let delegate = this.getDelegateFor(owner),
+      args = argsProxyFor(vmArgs.capture(), "component"),
+      component = delegate.createComponent(definition, args);
     return new CustomComponentState(component, delegate, args);
   }
   getDebugName(definition) {
-    return typeof definition === 'function' ? definition.name : definition.toString();
+    return "function" == typeof definition ? definition.name : definition.toString();
   }
   update(bucket) {
     let {
-      delegate
+      delegate: delegate
     } = bucket;
     if (hasUpdateHook(delegate)) {
       let {
-        component,
-        args
+        component: component,
+        args: args
       } = bucket;
       delegate.updateComponent(component, args);
     }
   }
   didCreate({
-    component,
-    delegate
+    component: component,
+    delegate: delegate
   }) {
-    if (hasAsyncLifeCycleCallbacks(delegate)) {
-      delegate.didCreateComponent(component);
-    }
+    hasAsyncLifeCycleCallbacks(delegate) && delegate.didCreateComponent(component);
   }
   didUpdate({
-    component,
-    delegate
+    component: component,
+    delegate: delegate
   }) {
-    if (hasAsyncUpdateHook(delegate)) {
-      delegate.didUpdateComponent(component);
-    }
+    (function (delegate) {
+      return hasAsyncLifeCycleCallbacks(delegate) && hasUpdateHook(delegate);
+    })(delegate) && delegate.didUpdateComponent(component);
   }
   didRenderLayout() {}
   didUpdateLayout() {}
   getSelf({
-    component,
-    delegate
+    component: component,
+    delegate: delegate
   }) {
-    return createConstRef(delegate.getContext(component), 'this');
+    return createConstRef(delegate.getContext(component), "this");
   }
   getDestroyable(bucket) {
     const {
-      delegate
+      delegate: delegate
     } = bucket;
-    if (hasDestructors(delegate)) {
+    if (function (delegate) {
+      return delegate.capabilities.destructor;
+    }(delegate)) {
       const {
-        component
+        component: component
       } = bucket;
-      registerDestructor(bucket, () => delegate.destroyComponent(component));
-      return bucket;
+      return registerDestructor(bucket, () => delegate.destroyComponent(component)), bucket;
     }
     return null;
   }
@@ -524,19 +431,16 @@ class CustomComponentManager {
  */
 class CustomComponentState {
   constructor(component, delegate, args) {
-    this.component = component;
-    this.delegate = delegate;
-    this.args = args;
+    this.component = component, this.delegate = delegate, this.args = args;
   }
 }
 function modifierCapabilities(managerAPI, optionalFeatures = {}) {
-  if (isDevelopingApp() && managerAPI !== '3.22') {
-    throw new Error('Invalid modifier manager compatibility specified');
-  }
+  if (isDevelopingApp() && "3.22" !== managerAPI) throw new Error("Invalid modifier manager compatibility specified");
   return buildCapabilities({
     disableAutoTracking: Boolean(optionalFeatures.disableAutoTracking)
   });
 }
+
 /**
   The CustomModifierManager allows addons to provide custom modifier
   implementations that integrate seamlessly into Ember. This is accomplished
@@ -568,83 +472,66 @@ class CustomModifierManager {
   }
   getDelegateFor(owner) {
     let {
-      componentManagerDelegates
-    } = this;
-    let delegate = componentManagerDelegates.get(owner);
-    if (delegate === undefined) {
+        componentManagerDelegates: componentManagerDelegates
+      } = this,
+      delegate = componentManagerDelegates.get(owner);
+    if (void 0 === delegate) {
       let {
-        factory
+        factory: factory
       } = this;
-      delegate = factory(owner);
-      if (isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities)) {
+      if (delegate = factory(owner), isDevelopingApp() && !FROM_CAPABILITIES.has(delegate.capabilities))
         // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(`Custom modifier managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.22')\` (imported via \`import { capabilities } from '@ember/modifier';\`). Received: \`${JSON.stringify(delegate.capabilities)}\` for: \`${delegate}\``);
-      }
       componentManagerDelegates.set(owner, delegate);
     }
     return delegate;
   }
   create(owner, element, definition, capturedArgs) {
-    let delegate = this.getDelegateFor(owner);
-    let args = argsProxyFor(capturedArgs, 'modifier');
-    let instance = delegate.createModifier(definition, args);
-    let tag = createUpdatableTag();
-    let state;
-    state = {
-      tag,
-      element,
-      delegate,
-      args,
+    let state,
+      delegate = this.getDelegateFor(owner),
+      args = argsProxyFor(capturedArgs, "modifier"),
+      instance = delegate.createModifier(definition, args);
+    return state = {
+      tag: createUpdatableTag(),
+      element: element,
+      delegate: delegate,
+      args: args,
       modifier: instance
-    };
-    registerDestructor(state, () => delegate.destroyModifier(instance, args));
-    return state;
+    }, registerDestructor(state, () => delegate.destroyModifier(instance, args)), state;
   }
   getDebugName(definition) {
-    if (typeof definition === 'function') {
-      return definition.name || definition.toString();
-    } else {
-      return '<unknown>';
-    }
+    return "function" == typeof definition ? definition.name || definition.toString() : "<unknown>";
   }
   getDebugInstance({
-    modifier
+    modifier: modifier
   }) {
     return modifier;
   }
   getTag({
-    tag
+    tag: tag
   }) {
     return tag;
   }
   install({
-    element,
-    args,
-    modifier,
-    delegate
+    element: element,
+    args: args,
+    modifier: modifier,
+    delegate: delegate
   }) {
     let {
-      capabilities
+      capabilities: capabilities
     } = delegate;
-    if (capabilities.disableAutoTracking === true) {
-      untrack(() => delegate.installModifier(modifier, castToBrowser(element, 'ELEMENT'), args));
-    } else {
-      delegate.installModifier(modifier, castToBrowser(element, 'ELEMENT'), args);
-    }
+    !0 === capabilities.disableAutoTracking ? untrack(() => delegate.installModifier(modifier, castToBrowser(element, "ELEMENT"), args)) : delegate.installModifier(modifier, castToBrowser(element, "ELEMENT"), args);
   }
   update({
-    args,
-    modifier,
-    delegate
+    args: args,
+    modifier: modifier,
+    delegate: delegate
   }) {
     let {
-      capabilities
+      capabilities: capabilities
     } = delegate;
-    if (capabilities.disableAutoTracking === true) {
-      untrack(() => delegate.updateModifier(modifier, args));
-    } else {
-      delegate.updateModifier(modifier, args);
-    }
+    !0 === capabilities.disableAutoTracking ? untrack(() => delegate.updateModifier(modifier, args)) : delegate.updateModifier(modifier, args);
   }
   getDestroyable(state) {
     return state;
@@ -659,28 +546,20 @@ function setModifierManager(factory, obj) {
 function setHelperManager(factory, obj) {
   return setInternalHelperManager(new CustomHelperManager(factory), obj);
 }
-const TEMPLATES = new WeakMap();
-const getPrototypeOf = Object.getPrototypeOf;
+const TEMPLATES = new WeakMap(),
+  getPrototypeOf = Object.getPrototypeOf;
 function setComponentTemplate(factory, obj) {
-  if (isDevelopingApp() && !(obj !== null && (typeof obj === 'object' || typeof obj === 'function'))) {
-    throw new Error(`Cannot call \`setComponentTemplate\` on \`${debugToString$1(obj)}\``);
-  }
-  if (isDevelopingApp() && TEMPLATES.has(obj)) {
-    throw new Error(`Cannot call \`setComponentTemplate\` multiple times on the same class (\`${debugToString$1(obj)}\`)`);
-  }
-  TEMPLATES.set(obj, factory);
-  return obj;
+  if (isDevelopingApp() && (null === obj || "object" != typeof obj && "function" != typeof obj)) throw new Error(`Cannot call \`setComponentTemplate\` on \`${debugToString$1(obj)}\``);
+  if (isDevelopingApp() && TEMPLATES.has(obj)) throw new Error(`Cannot call \`setComponentTemplate\` multiple times on the same class (\`${debugToString$1(obj)}\`)`);
+  return TEMPLATES.set(obj, factory), obj;
 }
 function getComponentTemplate(obj) {
   let pointer = obj;
-  while (pointer !== null) {
+  for (; null !== pointer;) {
     let template = TEMPLATES.get(pointer);
-    if (template !== undefined) {
-      return template;
-    }
+    if (void 0 !== template) return template;
     pointer = getPrototypeOf(pointer);
   }
-  return undefined;
 }
 
 export { CustomComponentManager, CustomHelperManager, CustomModifierManager, capabilityFlagsFrom, componentCapabilities, getComponentTemplate, getCustomTagFor, getInternalComponentManager, getInternalHelperManager, getInternalModifierManager, hasCapability, hasDestroyable, hasInternalComponentManager, hasInternalHelperManager, hasInternalModifierManager, hasValue, helperCapabilities, managerHasCapability, modifierCapabilities, setComponentManager, setComponentTemplate, setCustomTagFor, setHelperManager, setInternalComponentManager, setInternalHelperManager, setInternalModifierManager, setModifierManager };