ember-source 4.5.0-alpha.4 → 4.5.0-beta.2

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.5.0-alpha.4
+ * @version   4.5.0-beta.2
  */

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

@@ -1,5 +1,5 @@
 import { setOwner } from '@ember/-internals/owner';
-import { dictionary, symbol, intern } from '@ember/-internals/utils';
+import { dictionary, intern } from '@ember/-internals/utils';
 import { assert, deprecate } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
@@ -377,7 +377,7 @@ function resetMember(container, fullName) {
   }
 }
 
-const INIT_FACTORY = symbol('INIT_FACTORY');
+const INIT_FACTORY = Symbol('INIT_FACTORY');
 function getFactoryFor(obj) {
   return obj[INIT_FACTORY];
 }

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

@@ -1,7 +1,7 @@
 import { templateFactory, programCompilationContext } from '@glimmer/opcode-compiler';
 export { templateFactory as template, templateCacheCounters } from '@glimmer/opcode-compiler';
 import { setOwner, getOwner, isFactory } from '@ember/-internals/owner';
-import { guidFor, symbol, enumerableSymbol, getDebugName, isProxy, isEmberArray, isObject, uuid } from '@ember/-internals/utils';
+import { guidFor, enumerableSymbol, getDebugName, isProxy, isEmberArray, isObject, uuid } from '@ember/-internals/utils';
 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';
@@ -2024,7 +2024,7 @@ function processComponentArgs(namedArgs) {
   props.attrs = attrs;
   return props;
 }
-const REF = symbol('REF');
+const REF = Symbol('REF');
 
 class MutableCell {
   constructor(ref, value) {
@@ -2051,9 +2051,9 @@ var __rest = undefined && undefined.__rest || function (s, e) {
 };
 const ARGS = enumerableSymbol('ARGS');
 const HAS_BLOCK = enumerableSymbol('HAS_BLOCK');
-const DIRTY_TAG = symbol('DIRTY_TAG');
-const IS_DISPATCHING_ATTRS = symbol('IS_DISPATCHING_ATTRS');
-const BOUNDS = symbol('BOUNDS');
+const DIRTY_TAG = Symbol('DIRTY_TAG');
+const IS_DISPATCHING_ATTRS = Symbol('IS_DISPATCHING_ATTRS');
+const BOUNDS = Symbol('BOUNDS');
 const EMBER_VIEW_REF = createPrimitiveRef('ember-view');
 
 function aliasIdToElementId(args, props) {
@@ -2726,7 +2726,7 @@ setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
 @module @ember/component
 */
 var _a;
-const RECOMPUTE_TAG = symbol('RECOMPUTE_TAG');
+const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
 const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
 
 class Helper extends FrameworkObject {
@@ -2957,14 +2957,25 @@ function escapeExpression(string) {
   return string.replace(badChars, escapeChar);
 }
 /**
-  Mark a string as safe for unescaped output with Ember templates. If you
-  return HTML from a helper, use this function to
-  ensure Ember's rendering layer does not escape the HTML.
+  Use this method to indicate that a string should be rendered as HTML
+  when the string is used in a template. To say this another way,
+  strings marked with `htmlSafe` will not be HTML escaped.
+
+  A word of warning -   The `htmlSafe` method does not make the string safe;
+  it only tells the framework to treat the string as if it is safe to render
+  as HTML. If a string contains user inputs or other untrusted
+  data, you must sanitize the string before using the `htmlSafe` method.
+  Otherwise your code is vulnerable to
+  [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+  There are many open source sanitization libraries to choose from,
+  both for front end and server-side sanitization.
 
   ```javascript
   import { htmlSafe } from '@ember/template';
 
-  htmlSafe('<div>someString</div>')
+  const someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+  htmlSafe(someTrustedorSanitizedString)
   ```
 
   @method htmlSafe
@@ -3683,11 +3694,11 @@ class MapLikeNativeIterator extends NativeIterator {
 }
 
 function hasForEach(value) {
-  return typeof value['forEach'] === 'function';
+  return value != null && typeof value['forEach'] === 'function';
 }
 
 function isNativeIterable(value) {
-  return typeof value[Symbol.iterator] === 'function';
+  return value != null && typeof value[Symbol.iterator] === 'function';
 }
 
 function isIndexable(value) {
@@ -4869,9 +4880,16 @@ const BUILTIN_KEYWORD_HELPERS = {
   '-outlet': outletHelper,
   '-in-el-null': inElementNullCheckHelper
 };
+const BUILTIN_HELPERS = Object.assign(Object.assign({}, BUILTIN_KEYWORD_HELPERS), {
+  array,
+  concat,
+  fn,
+  get: get$1,
+  hash
+});
 
 if (DEBUG) {
-  BUILTIN_KEYWORD_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
+  BUILTIN_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
 } else {
   // Bug: this may be a quirk of our test setup?
   // In prod builds, this is a no-op helper and is unused in practice. We shouldn't need
@@ -4881,17 +4899,9 @@ if (DEBUG) {
   // 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_KEYWORD_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
+  BUILTIN_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
 }
 
-const BUILTIN_HELPERS = Object.assign(Object.assign({}, BUILTIN_KEYWORD_HELPERS), {
-  array,
-  concat,
-  fn,
-  get: get$1,
-  hash
-});
-
 {
   BUILTIN_HELPERS['unique-id'] = uniqueId;
 }
@@ -5469,7 +5479,7 @@ class Renderer {
 
   getBounds(view) {
     let bounds = view[BOUNDS];
-    assert('object passed to getBounds must have the BOUNDS symbol as a property', Boolean(bounds));
+    assert('object passed to getBounds must have the BOUNDS symbol as a property', bounds);
     let parentElement = bounds.parentElement();
     let firstNode = bounds.firstNode();
     let lastNode = bounds.lastNode();

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

@@ -1,5 +1,5 @@
 import { meta, peekMeta } from '@ember/-internals/meta';
-import { setListeners, isObject, setupMandatorySetter, symbol, toString, enumerableSymbol, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
+import { setListeners, isObject, setupMandatorySetter, symbol, toString, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
 import { assert, deprecate, debug, warn } from '@ember/debug';
 import { ENV, context } from '@ember/-internals/environment';
 import { schedule } from '@ember/runloop';
@@ -449,7 +449,10 @@ function markObjectAsDirty(obj, propertyKey) {
  @private
  */
 
-const PROPERTY_DID_CHANGE = enumerableSymbol('PROPERTY_DID_CHANGE');
+const PROPERTY_DID_CHANGE = Symbol('PROPERTY_DID_CHANGE');
+function hasPropertyDidChange(obj) {
+  return obj != null && typeof obj === 'object' && typeof obj[PROPERTY_DID_CHANGE] === 'function';
+}
 let deferred = 0;
 /**
   This function is called just after an object property has changed.
@@ -484,9 +487,11 @@ function notifyPropertyChange(obj, keyName, _meta, value) {
   }
 
   if (PROPERTY_DID_CHANGE in obj) {
-    // we need to check the arguments length here; there's a check in `PROPERTY_DID_CHANGE`
+    // It's redundant to do this here, but we don't want to check above so we can avoid an extra function call in prod.
+    assert('property did change hook is invalid', hasPropertyDidChange(obj)); // we need to check the arguments length here; there's a check in Component's `PROPERTY_DID_CHANGE`
     // that checks its arguments length, so we have to explicitly not call this with `value`
     // if it is not passed to `notifyPropertyChange`
+
     if (arguments.length === 4) {
       obj[PROPERTY_DID_CHANGE](keyName, value);
     } else {
@@ -1377,8 +1382,9 @@ class ComputedProperty extends ComputedDescriptor {
     // See GH#18147 / GH#19028 for details.
 
     if ( // ensure that we only run this once, while the component is being instantiated
-    meta$$1.isInitializing() && this._dependentKeys !== undefined && this._dependentKeys.length > 0 && // These two properties are set on Ember.Component
-    typeof obj[PROPERTY_DID_CHANGE] === 'function' && obj.isComponent) {
+    meta$$1.isInitializing() && this._dependentKeys !== undefined && this._dependentKeys.length > 0 && typeof obj[PROPERTY_DID_CHANGE] === 'function' && obj.isComponent) {
+      // It's redundant to do this here, but we don't want to check above so we can avoid an extra function call in prod.
+      assert('property did change hook is invalid', hasPropertyDidChange(obj));
       addObserver(obj, keyName, () => {
         obj[PROPERTY_DID_CHANGE](keyName);
       }, undefined, true);
@@ -2374,12 +2380,14 @@ LIBRARIES.registerCoreLibrary('Ember', VERSION);
 
 function getProperties(obj, keys) {
   let ret = {};
-  let propertyNames = arguments;
+  let propertyNames;
   let i = 1;
 
   if (arguments.length === 2 && Array.isArray(keys)) {
     i = 0;
     propertyNames = arguments[1];
+  } else {
+    propertyNames = Array.from(arguments);
   }
 
   for (; i < propertyNames.length; i++) {
@@ -2546,7 +2554,7 @@ function _processNamespace(paths, root, seen) {
     if (obj && getName(obj) === void 0) {
       // Replace the class' `toString` with the dot-separated path
       setName(obj, paths.join('.')); // Support nested namespaces
-    } else if (obj && obj.isNamespace) {
+    } else if (obj && isNamespace(obj)) {
       // Skip aliased namespaces
       if (seen.has(obj)) {
         continue;
@@ -2561,6 +2569,10 @@ function _processNamespace(paths, root, seen) {
   paths.length = idx; // cut out last item
 }
 
+function isNamespace(obj) {
+  return obj != null && typeof obj === 'object' && obj.isNamespace;
+}
+
 function isUppercase(code) {
   return code >= 65 && code <= 90 // A
   ; // Z

package/dist/packages/@ember/-internals/routing/lib/location/api.js

@@ -83,10 +83,10 @@ export default {
     @private
   */
   create(options) {
-    let implementation = options && options.implementation;
-    assert("Location.create: you must specify a 'implementation' option", Boolean(implementation));
+    let implementation = options === null || options === void 0 ? void 0 : options.implementation;
+    assert("Location.create: you must specify a 'implementation' option", implementation);
     let implementationClass = this.implementations[implementation];
-    assert(`Location.create: ${implementation} is not a valid implementation`, Boolean(implementationClass));
+    assert(`Location.create: ${implementation} is not a valid implementation`, implementationClass);
     deprecate("Calling `create` on Location class is deprecated. Instead, use `container.lookup('location:my-location')` to lookup the location you need.", false, {
       id: 'deprecate-auto-location',
       until: '5.0.0',

package/dist/packages/@ember/-internals/routing/lib/location/auto_location.js

@@ -123,7 +123,11 @@ function delegateToConcreteImplementation(methodName) {
     let {
       concreteImplementation
     } = this;
-    assert("AutoLocation's detect() method should be called before calling any other hooks.", concreteImplementation);
+    assert("AutoLocation's detect() method should be called before calling any other hooks.", concreteImplementation); // We need this cast because `Parameters` is deferred so that it is not
+    // possible for TS to see it will always produce the right type. However,
+    // since `AnyFn` has a rest type, it is allowed. See discussion on [this
+    // issue](https://github.com/microsoft/TypeScript/issues/47615).
+
     return (_a = concreteImplementation[methodName]) === null || _a === void 0 ? void 0 : _a.call(concreteImplementation, ...args);
   };
 }

package/dist/packages/@ember/-internals/routing/lib/services/router.js

@@ -8,14 +8,13 @@ var __decorate = this && this.__decorate || function (decorators, target, key, d
 
 import { getOwner } from '@ember/-internals/owner';
 import { Evented } from '@ember/-internals/runtime';
-import { symbol } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 import { consumeTag, tagFor } from '@glimmer/validator';
 import EmberRouter from '../system/router';
 import { extractRouteArgs, resemblesURL, shallowEqual } from '../utils';
-const ROUTER = symbol('ROUTER');
+export const ROUTER = Symbol('ROUTER');
 
 function cleanURL(url, rootURL) {
   if (rootURL === '/') {
@@ -35,14 +34,16 @@ class RouterService extends Service.extend(Evented) {
 
     let owner = getOwner(this);
     assert('RouterService is unexpectedly missing an owner', owner);
-    router = owner.lookup('router:main');
-    assert('ROUTER SERVICE BUG: Expected router to be an instance of EmberRouter', router instanceof EmberRouter);
-    return this[ROUTER] = router;
+
+    let _router = owner.lookup('router:main');
+
+    assert('ROUTER SERVICE BUG: Expected router to be an instance of EmberRouter', _router instanceof EmberRouter);
+    return this[ROUTER] = _router;
   }
 
   willDestroy() {
     super.willDestroy();
-    this[ROUTER] = null;
+    this[ROUTER] = undefined;
   }
   /**
      Transition the application into another route. The route may

package/dist/packages/@ember/-internals/routing/lib/services/routing.js

@@ -2,12 +2,11 @@
 @module ember
 */
 import { getOwner } from '@ember/-internals/owner';
-import { symbol } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 import EmberRouter from '../system/router';
-const ROUTER = symbol('ROUTER');
+import { ROUTER } from './router';
 /**
   The Routing service is used by LinkTo, and provides facilities for
   the component/view layer to interact with the router.
@@ -29,10 +28,14 @@ export default class RoutingService extends Service {
 
     let owner = getOwner(this);
     assert('RoutingService is unexpectedly missing an owner', owner);
-    router = owner.lookup('router:main');
-    assert('ROUTING SERVICE BUG: Expected router to be an instance of EmberRouter', router instanceof EmberRouter);
-    router.setupRouter();
-    return this[ROUTER] = router;
+
+    let _router = owner.lookup('router:main');
+
+    assert('ROUTING SERVICE BUG: Expected router to be an instance of EmberRouter', _router instanceof EmberRouter);
+
+    _router.setupRouter();
+
+    return this[ROUTER] = _router;
   }
 
   hasRoute(routeName) {

package/dist/packages/@ember/-internals/routing/lib/system/route.js

@@ -11,7 +11,7 @@ import { addObserver, computed, defineProperty, descriptorForProperty, flushAsyn
 import { getOwner } from '@ember/-internals/owner';
 import { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, ActionHandler, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
-import { isProxy, lookupDescriptor, symbol } from '@ember/-internals/utils';
+import { isProxy, lookupDescriptor } from '@ember/-internals/utils';
 import Controller from '@ember/controller';
 import { assert, info, isTesting } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
@@ -23,7 +23,7 @@ import { calculateCacheKey, deprecateTransitionMethods, normalizeControllerQuery
 import generateController from './generate_controller';
 import EmberRouter from './router';
 export const ROUTE_CONNECTIONS = new WeakMap();
-const RENDER = symbol('render');
+const RENDER = Symbol('render');
 
 class Route extends EmberObject.extend(ActionHandler, Evented) {
   constructor(owner) {
@@ -1131,7 +1131,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   get _qp() {
-    let combinedQueryParameterConfiguration;
+    let combinedQueryParameterConfiguration = {};
     let controllerName = this.controllerName || this.routeName;
     let owner = getOwner(this);
     assert('Route is unexpectedly missing an owner', owner);
@@ -1172,6 +1172,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       }
 
       let desc = combinedQueryParameterConfiguration[propName];
+      assert(`[BUG] missing query parameter configuration for ${propName}`, desc);
       let scope = desc.scope || 'model';
       let parts = undefined;
 
@@ -1451,9 +1452,7 @@ function mergeEachQueryParams(controllerQP, routeQP) {
       continue;
     }
 
-    let newControllerParameterConfiguration = {};
-    Object.assign(newControllerParameterConfiguration, controllerQP[cqpName], routeQP[cqpName]);
-    qps[cqpName] = newControllerParameterConfiguration; // allows us to skip this QP when we check route QPs.
+    qps[cqpName] = Object.assign(Object.assign({}, controllerQP[cqpName]), routeQP[cqpName]); // allows us to skip this QP when we check route QPs.
 
     keysAlreadyMergedOrSkippable[cqpName] = true;
   } // loop over all route qps, skipping those that were merged in the first pass
@@ -1465,9 +1464,7 @@ function mergeEachQueryParams(controllerQP, routeQP) {
       continue;
     }
 
-    let newRouteParameterConfiguration = {};
-    Object.assign(newRouteParameterConfiguration, routeQP[rqpName], controllerQP[rqpName]);
-    qps[rqpName] = newRouteParameterConfiguration;
+    qps[rqpName] = Object.assign(Object.assign({}, routeQP[rqpName]), controllerQP[rqpName]);
   }
 
   return qps;

package/dist/packages/@ember/-internals/routing/lib/system/router.js

@@ -1468,7 +1468,7 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
 
   for (let i = routeInfos.length - 1; i >= 0; i--) {
     routeInfo = routeInfos[i];
-    assert('has routeInfo', routeInfo);
+    assert('[BUG] Missing routeInfo', routeInfo);
     handler = routeInfo.route;
     actionHandler = handler && handler.actions && handler.actions[name];
 
@@ -1478,6 +1478,8 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
       } else {
         // Should only hit here if a non-bubbling error action is triggered on a route.
         if (name === 'error') {
+          assert('[BUG] Missing handler', handler);
+
           handler._router._markErrorAsHandled(args[0]);
         }
 
@@ -1489,7 +1491,7 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
   let defaultHandler = defaultActionHandlers[name];
 
   if (defaultHandler) {
-    defaultHandler.apply(this, [routeInfos, ...args]);
+    defaultHandler.call(this, routeInfos, ...args);
     return;
   }
 

package/dist/packages/@ember/-internals/routing/lib/utils.js

@@ -169,35 +169,26 @@ export function normalizeControllerQueryParams(queryParams) {
 }
 
 function accumulateQueryParamDescriptors(_desc, accum) {
-  let desc = _desc;
-  let tmp;
-
-  if (typeof desc === 'string') {
-    tmp = {};
-    tmp[desc] = {
+  let desc = typeof _desc === 'string' ? {
+    [_desc]: {
       as: null
-    };
-    desc = tmp;
-  }
+    }
+  } : _desc;
 
   for (let key in desc) {
     if (!Object.prototype.hasOwnProperty.call(desc, key)) {
       return;
     }
 
-    let singleDesc = desc[key];
-
-    if (typeof singleDesc === 'string') {
-      singleDesc = {
-        as: singleDesc
-      };
-    }
-
-    let val = accum[key] || {
+    let _singleDesc = desc[key];
+    let singleDesc = typeof _singleDesc === 'string' ? {
+      as: _singleDesc
+    } : _singleDesc;
+    let partialVal = accum[key] || {
       as: null,
       scope: 'model'
     };
-    Object.assign(val, singleDesc);
+    let val = Object.assign(Object.assign({}, partialVal), singleDesc);
     accum[key] = val;
   }
 }
@@ -237,13 +228,12 @@ export function prefixRouteNameArg(route, args) {
   return args;
 }
 export function shallowEqual(a, b) {
-  let k;
   let aCount = 0;
   let bCount = 0;
 
-  for (k in a) {
-    if (Object.prototype.hasOwnProperty.call(a, k)) {
-      if (a[k] !== b[k]) {
+  for (let kA in a) {
+    if (Object.prototype.hasOwnProperty.call(a, kA)) {
+      if (a[kA] !== b[kA]) {
         return false;
       }
 
@@ -251,8 +241,8 @@ export function shallowEqual(a, b) {
     }
   }
 
-  for (k in b) {
-    if (Object.prototype.hasOwnProperty.call(b, k)) {
+  for (let kB in b) {
+    if (Object.prototype.hasOwnProperty.call(b, kB)) {
       bCount++;
     }
   }

package/dist/packages/@ember/-internals/runtime/lib/compare.js

@@ -12,7 +12,10 @@ const TYPE_ORDER = {
   instance: 7,
   function: 8,
   class: 9,
-  date: 10
+  date: 10,
+  regexp: 11,
+  filelist: 12,
+  error: 13
 }; //
 // the spaceship operator
 //

package/dist/packages/@ember/-internals/runtime/lib/mixins/-proxy.js

@@ -3,28 +3,34 @@
 */
 import { meta } from '@ember/-internals/meta';
 import { get, set, defineProperty, Mixin, tagForObject, computed, tagForProperty } from '@ember/-internals/metal';
-import { setProxy, setupMandatorySetter, isObject } from '@ember/-internals/utils';
+import { setProxy, setupMandatorySetter, isObject, isProxy } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { setCustomTagFor } from '@glimmer/manager';
 import { combine, updateTag, tagFor, tagMetaFor } from '@glimmer/validator';
 export function contentFor(proxy) {
-  let content = get(proxy, 'content');
+  let content = get(proxy, 'content'); // SAFETY: Ideally we'd assert instead of casting, but @glimmer/validator doesn't give us
+  // sufficient public types for this. Previously this code was .js and worked correctly so
+  // hopefully this is sufficiently reliable.
+
   updateTag(tagForObject(proxy), tagForObject(content));
   return content;
 }
 
 function customTagForProxy(proxy, key, addMandatorySetter) {
+  assert('Expected a proxy', isProxy(proxy));
   let meta = tagMetaFor(proxy);
   let tag = tagFor(proxy, key, meta);
 
   if (DEBUG) {
     // TODO: Replace this with something more first class for tracking tags in DEBUG
+    // SAFETY: This is not an officially supported property but setting shouldn't cause issues.
     tag._propertyKey = key;
   }
 
   if (key in proxy) {
     if (DEBUG && addMandatorySetter) {
+      assert('[BUG] setupMandatorySetter should be set when debugging', setupMandatorySetter);
       setupMandatorySetter(tag, proxy, key);
     }
 
@@ -40,20 +46,11 @@ function customTagForProxy(proxy, key, addMandatorySetter) {
     return combine(tags);
   }
 }
-/**
-  `Ember.ProxyMixin` forwards all properties not defined by the proxy itself
-  to a proxied `content` object.  See ObjectProxy for more details.
-
-  @class ProxyMixin
-  @namespace Ember
-  @private
-*/
-
 
-export default Mixin.create({
+const ProxyMixin = Mixin.create({
   /**
     The object whose properties will be forwarded.
-     @property content
+       @property content
     @type {unknown}
     @default null
     @public
@@ -97,8 +94,10 @@ export default Mixin.create({
     }
 
     let content = contentFor(this);
-    assert(`Cannot delegate set('${key}', ${value}) to the 'content' property of object proxy ${this}: its 'content' is undefined.`, content);
+    assert(`Cannot delegate set('${key}', ${value}) to the 'content' property of object proxy ${this}: its 'content' is undefined.`, content); // SAFETY: We don't actually guarantee that this is an object, so this isn't necessarily safe :(
+
     return set(content, key, value);
   }
 
-});
+});
+export default ProxyMixin;