ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/{packages/shared-chunks/observers-DhgQ6ba5.js → dev/packages/shared-chunks/observers-Bj9qLVau.js}

@@ -1,21 +1,20 @@
 import { peekMeta, meta } from '../@ember/-internals/meta/lib/meta.js';
-import { h as setupMandatorySetter, d as isObject, s as setListeners, f as setWithMandatorySetter } from './mandatory-setter-DLKyVs4Q.js';
-import { isDevelopingApp } from '@embroider/macros';
+import { a as setupMandatorySetter, i as isObject, h as setListeners, b as setWithMandatorySetter } from './mandatory-setter-DHZe7-kW.js';
 import { warn, debug } from '../@ember/debug/index.js';
 import { isDestroyed, registerDestructor } from '../@glimmer/destroyable/index.js';
 import { tagFor, dirtyTagFor, CONSTANT_TAG, combine, validateTag, tagMetaFor, createUpdatableTag, updateTag as UPDATE_TAG, valueForTag, CURRENT_TAG, untrack, ALLOW_CYCLES, consumeTag, track, isTracking, trackedData } from '../@glimmer/validator/index.js';
-import './debug-to-string-BsFOvUtQ.js';
+import './debug-to-string-CFb7h0lY.js';
 import '../@glimmer/global-context/index.js';
-import './reference-B6HMX4y0.js';
-import './capabilities-DHiXCCuB.js';
-import { E as ENV } from './env-DEd6hPbj.js';
+import './reference-C3TKDRnP.js';
+import './capabilities-O_xc7Yqk.js';
+import { ENV } from '../@ember/-internals/environment/index.js';
 import { assert } from '../@ember/debug/lib/assert.js';
-import { t as toString, s as symbol } from './to-string-CqD7_vQ4.js';
-import { g as getCustomTagFor } from './args-proxy-B91L3LRK.js';
-import { s as setProxy } from './is_proxy-C2q5rUMp.js';
+import { t as toString } from './to-string-C7M8LBLH.js';
+import { g as getCustomTagFor } from './args-proxy-DgXMc9b5.js';
+import { s as setProxy } from './is_proxy-B0smdQy8.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
 import { C as Cache } from './cache-qDyqAcpg.js';
-import Version from '../ember/version.js';
+import VERSION from '../ember/version.js';
 import { getOwner } from '../@ember/-internals/owner/index.js';
 import inspect from '../@ember/debug/lib/inspect.js';
 
@@ -27,23 +26,25 @@ function objectAt(array, index) {
   }
 }
 
+/////////
+
 // This is exported for `@tracked`, but should otherwise be avoided. Use `tagForObject`.
-const SELF_TAG = symbol('SELF_TAG');
+const SELF_TAG = Symbol('SELF_TAG');
 function tagForProperty(obj, propertyKey, addMandatorySetter = false, meta) {
   let customTagFor = getCustomTagFor(obj);
   if (customTagFor !== undefined) {
     return customTagFor(obj, propertyKey, addMandatorySetter);
   }
   let tag = tagFor(obj, propertyKey, meta);
-  if (isDevelopingApp() && addMandatorySetter) {
+  if (addMandatorySetter) {
     setupMandatorySetter(tag, obj, propertyKey);
   }
   return tag;
 }
 function tagForObject(obj) {
   if (isObject(obj)) {
-    if (isDevelopingApp()) {
-      (isDevelopingApp() && !(!isDestroyed(obj)) && assert(isDestroyed(obj) ? `Cannot create a new tag for \`${toString(obj)}\` after it has been destroyed.` : '', !isDestroyed(obj)));
+    {
+      (!(!isDestroyed(obj)) && assert(isDestroyed(obj) ? `Cannot create a new tag for \`${toString(obj)}\` after it has been destroyed.` : '', !isDestroyed(obj)));
     }
     return tagFor(obj, SELF_TAG);
   }
@@ -120,7 +121,7 @@ function getChainTags(chainTags, obj, path, tagMeta, meta$1) {
       for (let i = 0; i < arrLength; i++) {
         let item = objectAt(current, i);
         if (item) {
-          (isDevelopingApp() && !(typeof item === 'object') && assert(`When using @each to observe the array \`${current.toString()}\`, the items in the array must be objects`, typeof item === 'object'));
+          (!(typeof item === 'object') && assert(`When using @each to observe the array \`${current.toString()}\`, the items in the array must be objects`, typeof item === 'object'));
           chainTags.push(tagForProperty(item, segment, true));
           currentMeta = peekMeta(item);
           descriptor = currentMeta !== null ? currentMeta.peekDescriptors(segment) : undefined;
@@ -195,6 +196,8 @@ function getChainTags(chainTags, obj, path, tagMeta, meta$1) {
   return chainTags;
 }
 
+// Same as built-in MethodDecorator but with more arguments
+
 function isElementDescriptor(args) {
   let [maybeTarget, maybeKey, maybeDesc] = args;
   return (
@@ -236,14 +239,14 @@ class ComputedDescriptor {
   }
 }
 let COMPUTED_GETTERS;
-if (isDevelopingApp()) {
+{
   COMPUTED_GETTERS = new WeakSet();
 }
 function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
   function getter() {
     return descriptor.get(this, name);
   }
-  if (isDevelopingApp()) {
+  {
     COMPUTED_GETTERS.add(getter);
   }
   return getter;
@@ -258,7 +261,7 @@ function DESCRIPTOR_SETTER_FUNCTION(name, descriptor) {
 const COMPUTED_SETTERS = new WeakSet();
 function makeComputedDecorator(desc, DecoratorClass) {
   let decorator = function COMPUTED_DECORATOR(target, key, propertyDesc, maybeMeta, isClassicDecorator) {
-    (isDevelopingApp() && !(isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)) && assert(`Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`, isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)));
+    (!(isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)) && assert(`Only one computed property decorator can be applied to a class field or accessor, but '${key}' was decorated twice. You may have added the decorator to both a getter and setter, which is unnecessary.`, isClassicDecorator || !propertyDesc || !propertyDesc.get || !COMPUTED_GETTERS.has(propertyDesc.get)));
     let meta$1 = arguments.length === 3 ? meta(target) : maybeMeta;
     desc.setup(target, key, propertyDesc, meta$1);
     let computedDesc = {
@@ -288,9 +291,9 @@ const DECORATOR_DESCRIPTOR_MAP = new WeakMap();
   @private
 */
 function descriptorForProperty(obj, keyName, _meta) {
-  (isDevelopingApp() && !(obj !== null) && assert('Cannot call `descriptorForProperty` on null', obj !== null));
-  (isDevelopingApp() && !(obj !== undefined) && assert('Cannot call `descriptorForProperty` on undefined', obj !== undefined));
-  (isDevelopingApp() && !(typeof obj === 'object' || typeof obj === 'function') && assert(`Cannot call \`descriptorForProperty\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function'));
+  (!(obj !== null) && assert('Cannot call `descriptorForProperty` on null', obj !== null));
+  (!(obj !== undefined) && assert('Cannot call `descriptorForProperty` on undefined', obj !== undefined));
+  (!(typeof obj === 'object' || typeof obj === 'function') && assert(`Cannot call \`descriptorForProperty\` on ${typeof obj}`, typeof obj === 'object' || typeof obj === 'function'));
   let meta = _meta === undefined ? peekMeta(obj) : _meta;
   if (meta !== null) {
     return meta.peekDescriptors(keyName);
@@ -323,6 +326,10 @@ function setClassicDecorator(dec, value = true) {
   DECORATOR_DESCRIPTOR_MAP.set(dec, value);
 }
 
+/**
+@module @ember/object
+*/
+
 const END_WITH_EACH_REGEX = /\.@each$/;
 
 /**
@@ -356,9 +363,9 @@ const END_WITH_EACH_REGEX = /\.@each$/;
   expansion, and is passed the expansion.
 */
 function expandProperties(pattern, callback) {
-  (isDevelopingApp() && !(typeof pattern === 'string') && assert(`A computed property key must be a string, you passed ${typeof pattern} ${pattern}`, typeof pattern === 'string'));
-  (isDevelopingApp() && !(pattern.indexOf(' ') === -1) && assert('Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"', pattern.indexOf(' ') === -1)); // regex to look for double open, double close, or unclosed braces
-  (isDevelopingApp() && !(pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null) && assert(`Brace expanded properties have to be balanced and cannot be nested, pattern: ${pattern}`, pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null));
+  (!(typeof pattern === 'string') && assert(`A computed property key must be a string, you passed ${typeof pattern} ${pattern}`, typeof pattern === 'string'));
+  (!(pattern.indexOf(' ') === -1) && assert('Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"', pattern.indexOf(' ') === -1)); // regex to look for double open, double close, or unclosed braces
+  (!(pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null) && assert(`Brace expanded properties have to be balanced and cannot be nested, pattern: ${pattern}`, pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null));
   let start = pattern.indexOf('{');
   if (start < 0) {
     callback(pattern.replace(END_WITH_EACH_REGEX, '.[]'));
@@ -394,8 +401,40 @@ function changeEvent(keyName) {
 @module @ember/object
 */
 
+
+/*
+  The event system uses a series of nested hashes to store listeners on an
+  object. When a listener is registered, or when an event arrives, these
+  hashes are consulted to determine which target and action pair to invoke.
+
+  The hashes are stored in the object's meta hash, and look like this:
+
+      // Object's meta hash
+      {
+        listeners: {       // variable name: `listenerSet`
+          "foo:change": [ // variable name: `actions`
+            target, method, once
+          ]
+        }
+      }
+
+*/
+
+/**
+  Add an event listener
+
+  @method addListener
+  @static
+  @for @ember/object/events
+  @param obj
+  @param {String} eventName
+  @param {Object|Function} target A target object or a function
+  @param {Function|String} method A function or the name of a function to be called on `target`
+  @param {Boolean} once A flag whether a function should only be called once
+  @public
+*/
 function addListener(obj, eventName, target, method, once, sync = true) {
-  (isDevelopingApp() && !(Boolean(obj) && Boolean(eventName)) && assert('You must pass at least an object and event name to addListener', Boolean(obj) && Boolean(eventName)));
+  (!(Boolean(obj) && Boolean(eventName)) && assert('You must pass at least an object and event name to addListener', Boolean(obj) && Boolean(eventName)));
   if (!method && 'function' === typeof target) {
     method = target;
     target = null;
@@ -418,7 +457,7 @@ function addListener(obj, eventName, target, method, once, sync = true) {
   @public
 */
 function removeListener(obj, eventName, targetOrFunction, functionOrName) {
-  (isDevelopingApp() && !(Boolean(obj) && Boolean(eventName) && (typeof targetOrFunction === 'function' || typeof targetOrFunction === 'object' && Boolean(functionOrName))) && assert('You must pass at least an object, event name, and method or target and method/method name to removeListener', Boolean(obj) && Boolean(eventName) && (typeof targetOrFunction === 'function' || typeof targetOrFunction === 'object' && Boolean(functionOrName))));
+  (!(Boolean(obj) && Boolean(eventName) && (typeof targetOrFunction === 'function' || typeof targetOrFunction === 'object' && Boolean(functionOrName))) && assert('You must pass at least an object, event name, and method or target and method/method name to removeListener', Boolean(obj) && Boolean(eventName) && (typeof targetOrFunction === 'function' || typeof targetOrFunction === 'object' && Boolean(functionOrName))));
   let target, method;
   if (typeof targetOrFunction === 'object') {
     target = targetOrFunction;
@@ -526,8 +565,8 @@ function hasListeners(obj, eventName) {
 function on(...args) {
   let func = args.pop();
   let events = args;
-  (isDevelopingApp() && !(typeof func === 'function') && assert('on expects function as last argument', typeof func === 'function'));
-  (isDevelopingApp() && !(events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)) && assert('on called without valid event names', events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)));
+  (!(typeof func === 'function') && assert('on expects function as last argument', typeof func === 'function'));
+  (!(events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)) && assert('on called without valid event names', events.length > 0 && events.every(p => typeof p === 'string' && p.length > 0)));
   setListeners(func, events);
   return func;
 }
@@ -717,6 +756,11 @@ function destroyObservers(target) {
   if (ASYNC_OBSERVERS.size > 0) ASYNC_OBSERVERS.delete(target);
 }
 
+/**
+ @module ember
+ @private
+ */
+
 const PROPERTY_DID_CHANGE = Symbol('PROPERTY_DID_CHANGE');
 function hasPropertyDidChange(obj) {
   return obj != null && typeof obj === 'object' && typeof obj[PROPERTY_DID_CHANGE] === 'function';
@@ -752,7 +796,7 @@ function notifyPropertyChange(obj, keyName, _meta, value) {
   }
   if (PROPERTY_DID_CHANGE in obj) {
     // 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.
-    (isDevelopingApp() && !(hasPropertyDidChange(obj)) && 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`
+    (!(hasPropertyDidChange(obj)) && 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) {
@@ -1023,13 +1067,13 @@ class ComputedProperty extends ComputedDescriptor {
       this._hasConfig = true;
       let config = args.pop();
       if (typeof config === 'function') {
-        (isDevelopingApp() && !(!isClassicDecorator(config)) && assert(`You attempted to pass a computed property instance to computed(). Computed property instances are decorator functions, and cannot be passed to computed() because they cannot be turned into decorators twice`, !isClassicDecorator(config)));
+        (!(!isClassicDecorator(config)) && assert(`You attempted to pass a computed property instance to computed(). Computed property instances are decorator functions, and cannot be passed to computed() because they cannot be turned into decorators twice`, !isClassicDecorator(config)));
         this._getter = config;
       } else {
         const objectConfig = config;
-        (isDevelopingApp() && !(typeof objectConfig === 'object' && !Array.isArray(objectConfig)) && assert('computed expects a function or an object as last argument.', typeof objectConfig === 'object' && !Array.isArray(objectConfig)));
-        (isDevelopingApp() && !(Object.keys(objectConfig).every(key => key === 'get' || key === 'set')) && assert('Config object passed to computed can only contain `get` and `set` keys.', Object.keys(objectConfig).every(key => key === 'get' || key === 'set')));
-        (isDevelopingApp() && !(Boolean(objectConfig.get) || Boolean(objectConfig.set)) && assert('Computed properties must receive a getter or a setter, you passed none.', Boolean(objectConfig.get) || Boolean(objectConfig.set)));
+        (!(typeof objectConfig === 'object' && !Array.isArray(objectConfig)) && assert('computed expects a function or an object as last argument.', typeof objectConfig === 'object' && !Array.isArray(objectConfig)));
+        (!(Object.keys(objectConfig).every(key => key === 'get' || key === 'set')) && assert('Config object passed to computed can only contain `get` and `set` keys.', Object.keys(objectConfig).every(key => key === 'get' || key === 'set')));
+        (!(Boolean(objectConfig.get) || Boolean(objectConfig.set)) && assert('Computed properties must receive a getter or a setter, you passed none.', Boolean(objectConfig.get) || Boolean(objectConfig.set)));
         this._getter = objectConfig.get || noop;
         this._setter = objectConfig.set;
       }
@@ -1040,11 +1084,11 @@ class ComputedProperty extends ComputedDescriptor {
   }
   setup(obj, keyName, propertyDesc, meta) {
     super.setup(obj, keyName, propertyDesc, meta);
-    (isDevelopingApp() && !(!(propertyDesc && typeof propertyDesc.value === 'function')) && assert(`@computed can only be used on accessors or fields, attempted to use it with ${keyName} but that was a method. Try converting it to a getter (e.g. \`get ${keyName}() {}\`)`, !(propertyDesc && typeof propertyDesc.value === 'function')));
-    (isDevelopingApp() && !(!propertyDesc || !propertyDesc.initializer) && assert(`@computed can only be used on empty fields. ${keyName} has an initial value (e.g. \`${keyName} = someValue\`)`, !propertyDesc || !propertyDesc.initializer));
-    (isDevelopingApp() && !(!(this._hasConfig && propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function'))) && assert(`Attempted to apply a computed property that already has a getter/setter to a ${keyName}, but it is a method or an accessor. If you passed @computed a function or getter/setter (e.g. \`@computed({ get() { ... } })\`), then it must be applied to a field`, !(this._hasConfig && propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function'))));
+    (!(!(propertyDesc && typeof propertyDesc.value === 'function')) && assert(`@computed can only be used on accessors or fields, attempted to use it with ${keyName} but that was a method. Try converting it to a getter (e.g. \`get ${keyName}() {}\`)`, !(propertyDesc && typeof propertyDesc.value === 'function')));
+    (!(!propertyDesc || !propertyDesc.initializer) && assert(`@computed can only be used on empty fields. ${keyName} has an initial value (e.g. \`${keyName} = someValue\`)`, !propertyDesc || !propertyDesc.initializer));
+    (!(!(this._hasConfig && propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function'))) && assert(`Attempted to apply a computed property that already has a getter/setter to a ${keyName}, but it is a method or an accessor. If you passed @computed a function or getter/setter (e.g. \`@computed({ get() { ... } })\`), then it must be applied to a field`, !(this._hasConfig && propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function'))));
     if (this._hasConfig === false) {
-      (isDevelopingApp() && !(propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function')) && assert(`Attempted to use @computed on ${keyName}, but it did not have a getter or a setter. You must either pass a get a function or getter/setter to @computed directly (e.g. \`@computed({ get() { ... } })\`) or apply @computed directly to a getter/setter`, propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function')));
+      (!(propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function')) && assert(`Attempted to use @computed on ${keyName}, but it did not have a getter or a setter. You must either pass a get a function or getter/setter to @computed directly (e.g. \`@computed({ get() { ... } })\`) or apply @computed directly to a getter/setter`, propertyDesc && (typeof propertyDesc.get === 'function' || typeof propertyDesc.set === 'function')));
       let {
         get,
         set
@@ -1066,7 +1110,7 @@ class ComputedProperty extends ComputedDescriptor {
   _property(...passedArgs) {
     let args = [];
     function addArg(property) {
-      (isDevelopingApp() && !(DEEP_EACH_REGEX.test(property) === false) && assert(`Dependent keys containing @each only work one level deep. ` + `You used the key "${property}" which is invalid. ` + `Please create an intermediary computed property or ` + `switch to using tracked properties.`, DEEP_EACH_REGEX.test(property) === false));
+      (!(DEEP_EACH_REGEX.test(property) === false) && assert(`Dependent keys containing @each only work one level deep. ` + `You used the key "${property}" which is invalid. ` + `Please create an intermediary computed property or ` + `switch to using tracked properties.`, DEEP_EACH_REGEX.test(property) === false));
       args.push(property);
     }
     for (let arg of passedArgs) {
@@ -1085,7 +1129,7 @@ class ComputedProperty extends ComputedDescriptor {
     } else {
       // For backwards compatibility, we only throw if the CP has any dependencies. CPs without dependencies
       // should be allowed, even after the object has been destroyed, which is why we check _dependentKeys.
-      (isDevelopingApp() && !(this._dependentKeys === undefined || !isDestroyed(obj)) && assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, this._dependentKeys === undefined || !isDestroyed(obj)));
+      (!(this._dependentKeys === undefined || !isDestroyed(obj)) && assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, this._dependentKeys === undefined || !isDestroyed(obj)));
       let {
         _getter,
         _dependentKeys
@@ -1097,7 +1141,7 @@ class ComputedProperty extends ComputedDescriptor {
       });
       if (_dependentKeys !== undefined) {
         UPDATE_TAG(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$1));
-        if (isDevelopingApp()) {
+        {
           ALLOW_CYCLES.set(propertyTag, true);
         }
       }
@@ -1118,7 +1162,7 @@ class ComputedProperty extends ComputedDescriptor {
     if (this._readOnly) {
       this._throwReadOnlyError(obj, keyName);
     }
-    (isDevelopingApp() && !(this._setter !== undefined) && assert(`Cannot override the computed property \`${keyName}\` on ${toString(obj)}.`, this._setter !== undefined));
+    (!(this._setter !== undefined) && assert(`Cannot override the computed property \`${keyName}\` on ${toString(obj)}.`, this._setter !== undefined));
     let meta$1 = meta(obj);
 
     // ensure two way binding works when the component has defined a computed
@@ -1130,7 +1174,7 @@ class ComputedProperty extends ComputedDescriptor {
     // ensure that we only run this once, while the component is being instantiated
     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.
-      (isDevelopingApp() && !(hasPropertyDidChange(obj)) && assert('property did change hook is invalid', hasPropertyDidChange(obj)));
+      (!(hasPropertyDidChange(obj)) && assert('property did change hook is invalid', hasPropertyDidChange(obj)));
       addObserver(obj, keyName, () => {
         obj[PROPERTY_DID_CHANGE](keyName);
       }, undefined, true);
@@ -1147,7 +1191,7 @@ class ComputedProperty extends ComputedDescriptor {
       } = this;
       if (_dependentKeys !== undefined) {
         UPDATE_TAG(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$1));
-        if (isDevelopingApp()) {
+        if (true /* DEBUG */) {
           ALLOW_CYCLES.set(propertyTag, true);
         }
       }
@@ -1202,7 +1246,7 @@ class AutoComputedProperty extends ComputedProperty {
     if (revision !== undefined && validateTag(propertyTag, revision)) {
       ret = meta$1.valueFor(keyName);
     } else {
-      (isDevelopingApp() && !(!isDestroyed(obj)) && assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, !isDestroyed(obj)));
+      (!(!isDestroyed(obj)) && assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, !isDestroyed(obj)));
       let {
         _getter
       } = this;
@@ -1261,7 +1305,7 @@ class ComputedDecoratorImpl extends Function {
   */
   readOnly() {
     let desc = descriptorForDecorator(this);
-    (isDevelopingApp() && !(!(desc._setter && desc._setter !== desc._getter)) && assert('Computed properties that define a setter using the new syntax cannot be read-only', !(desc._setter && desc._setter !== desc._getter)));
+    (!(!(desc._setter && desc._setter !== desc._getter)) && assert('Computed properties that define a setter using the new syntax cannot be read-only', !(desc._setter && desc._setter !== desc._getter)));
     desc._readOnly = true;
     return this;
   }
@@ -1479,7 +1523,7 @@ class ComputedDecoratorImpl extends Function {
 // @computed with config only
 
 function computed(...args) {
-  (isDevelopingApp() && !(!(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)) && assert(`@computed can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: computed()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)));
+  (!(!(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)) && assert(`@computed can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: computed()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)));
   if (isElementDescriptor(args)) {
     // SAFETY: We passed in the impl for this class
     let decorator = makeComputedDecorator(new ComputedProperty([]), ComputedDecoratorImpl);
@@ -1515,6 +1559,55 @@ function isComputed(obj, key) {
 @module @ember/object
 */
 
+
+/**
+  NOTE: This is a low-level method used by other parts of the API. You almost
+  never want to call this method directly. Instead you should use
+  `mixin()` to define new properties.
+
+  Defines a property on an object. This method works much like the ES5
+  `Object.defineProperty()` method except that it can also accept computed
+  properties and other special descriptors.
+
+  Normally this method takes only three parameters. However if you pass an
+  instance of `Descriptor` as the third param then you can pass an
+  optional value as the fourth parameter. This is often more efficient than
+  creating new descriptor hashes for each property.
+
+  ## Examples
+
+  ```javascript
+  import { defineProperty, computed } from '@ember/object';
+
+  // ES5 compatible mode
+  defineProperty(contact, 'firstName', {
+    writable: true,
+    configurable: false,
+    enumerable: true,
+    value: 'Charles'
+  });
+
+  // define a simple property
+  defineProperty(contact, 'lastName', undefined, 'Jolley');
+
+  // define a computed property
+  defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
+    return this.firstName+' '+this.lastName;
+  }));
+  ```
+
+  @public
+  @method defineProperty
+  @static
+  @for @ember/object
+  @param {Object} obj the object to define this property on. This may be a prototype.
+  @param {String} keyName the name of the property
+  @param {Descriptor} [desc] an instance of `Descriptor` (typically a
+    computed property) or an ES5 descriptor.
+    You must provide this or `data` but not both.
+  @param {*} [data] something other than a descriptor, that will
+    become the explicit value of this property.
+*/
 function defineProperty(obj, keyName, desc, data, _meta) {
   let meta$1 = _meta === undefined ? meta(obj) : _meta;
   let previousDesc = descriptorForProperty(obj, keyName, meta$1);
@@ -1539,10 +1632,8 @@ function defineProperty(obj, keyName, desc, data, _meta) {
 }
 function defineDecorator(obj, keyName, desc, meta) {
   let propertyDesc;
-  if (isDevelopingApp()) {
+  {
     propertyDesc = desc(obj, keyName, undefined, meta, true);
-  } else {
-    propertyDesc = desc(obj, keyName, undefined, meta);
   }
   Object.defineProperty(obj, keyName, propertyDesc);
 
@@ -1558,10 +1649,8 @@ function defineValue(obj, keyName, value, wasDescriptor, enumerable = true) {
       value
     });
   } else {
-    if (isDevelopingApp()) {
+    {
       setWithMandatorySetter(obj, keyName, value);
-    } else {
-      obj[keyName] = value;
     }
   }
   return value;
@@ -1576,9 +1665,9 @@ function isPath(path) {
 @module @ember/object
 */
 
-const PROXY_CONTENT = symbol('PROXY_CONTENT');
+const PROXY_CONTENT = Symbol('PROXY_CONTENT');
 let getPossibleMandatoryProxyValue;
-if (isDevelopingApp()) {
+{
   getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
     let content = obj[PROXY_CONTENT];
     if (content === undefined) {
@@ -1610,15 +1699,9 @@ function hasUnknownProperty(val) {
   get(obj, "name");
   ```
 
-  If you plan to run on IE8 and older browsers then you should use this
-  method anytime you want to retrieve a property on an object that you don't
-  know for sure is private. (Properties beginning with an underscore '_'
-  are considered private.)
-
-  On all newer browsers, you only need to use this method to retrieve
-  properties if the property might not be defined on the object and you want
-  to respect the `unknownProperty` handler. Otherwise you can ignore this
-  method.
+  You only need to use this method to retrieve properties if the property
+  might not be defined on the object and you want to respect the
+  `unknownProperty` handler. Otherwise you can access the property directly.
 
   Note that if the object itself is `undefined`, this method will throw
   an error.
@@ -1633,10 +1716,10 @@ function hasUnknownProperty(val) {
 */
 
 function get(obj, keyName) {
-  (isDevelopingApp() && !(arguments.length === 2) && assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2));
-  (isDevelopingApp() && !(obj !== undefined && obj !== null) && assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null));
-  (isDevelopingApp() && !(typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)) && assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)));
-  (isDevelopingApp() && !(typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0) && assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0));
+  (!(arguments.length === 2) && assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2));
+  (!(obj !== undefined && obj !== null) && assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null));
+  (!(typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)) && assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName)));
+  (!(typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0) && assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0));
   return isPath(keyName) ? _getPath(obj, keyName) : _getProp(obj, keyName);
 }
 function _getProp(obj, keyName) {
@@ -1645,10 +1728,8 @@ function _getProp(obj, keyName) {
   }
   let value;
   if (typeof obj === 'object' || typeof obj === 'function') {
-    if (isDevelopingApp()) {
+    {
       value = getPossibleMandatoryProxyValue(obj, keyName);
-    } else {
-      value = obj[keyName];
     }
     if (value === undefined && typeof obj === 'object' && !(keyName in obj) && hasUnknownProperty(obj)) {
       value = obj.unknownProperty(keyName);
@@ -1744,7 +1825,7 @@ class Libraries {
         version
       });
     } else {
-      (isDevelopingApp() && warn(`Library "${name}" is already registered with Ember.`, false, {
+      (warn(`Library "${name}" is already registered with Ember.`, false, {
         id: 'ember-metal.libraries-register'
       }));
     }
@@ -1761,11 +1842,11 @@ class Libraries {
     }
   }
 }
-if (isDevelopingApp()) {
+{
   Libraries.prototype.logVersions = function () {
     let libs = this._registry;
     let nameLengths = libs.map(item => get(item, 'name.length'));
-    (isDevelopingApp() && !(nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number')) && assert('nameLengths is number array', nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number')));
+    (!(nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number')) && assert('nameLengths is number array', nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number')));
     let maxNameLength = Math.max.apply(null, nameLengths);
     debug('-------------------------------');
     for (let lib of libs) {
@@ -1776,10 +1857,10 @@ if (isDevelopingApp()) {
   };
 }
 const LIBRARIES = new Libraries();
-LIBRARIES.registerCoreLibrary('Ember', Version);
+LIBRARIES.registerCoreLibrary('Ember', VERSION);
 
 let DEBUG_INJECTION_FUNCTIONS;
-if (isDevelopingApp()) {
+{
   DEBUG_INJECTION_FUNCTIONS = new WeakMap();
 }
 
@@ -1809,7 +1890,7 @@ if (isDevelopingApp()) {
 // Catch-all for service and controller injections
 
 function inject(type, ...args) {
-  (isDevelopingApp() && !(typeof type === 'string') && assert('a string type must be provided to inject', typeof type === 'string'));
+  (!(typeof type === 'string') && assert('a string type must be provided to inject', typeof type === 'string'));
   let elementDescriptor;
   let name;
   if (isElementDescriptor(args)) {
@@ -1819,10 +1900,10 @@ function inject(type, ...args) {
   }
   let getInjection = function (propertyName) {
     let owner = getOwner(this) || this.container; // fallback to `container` for backwards compat
-    (isDevelopingApp() && !(Boolean(owner)) && assert(`Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.`, Boolean(owner)));
+    (!(Boolean(owner)) && assert(`Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.`, Boolean(owner)));
     return owner.lookup(`${type}:${name || propertyName}`);
   };
-  if (isDevelopingApp()) {
+  {
     DEBUG_INJECTION_FUNCTIONS.set(getInjection, {
       type,
       name
@@ -1841,20 +1922,83 @@ function inject(type, ...args) {
   }
 }
 
+/**
+  @decorator
+  @private
+
+  Marks a property as tracked.
+
+  By default, a component's properties are expected to be static,
+  meaning you are not able to update them and have the template update accordingly.
+  Marking a property as tracked means that when that property changes,
+  a rerender of the component is scheduled so the template is kept up to date.
+
+  There are two usages for the `@tracked` decorator, shown below.
+
+  @example No dependencies
+
+  If you don't pass an argument to `@tracked`, only changes to that property
+  will be tracked:
+
+  ```typescript
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  export default class MyComponent extends Component {
+    @tracked
+    remainingApples = 10
+  }
+  ```
+
+  When something changes the component's `remainingApples` property, the rerender
+  will be scheduled.
+
+  @example Dependents
+
+  In the case that you have a computed property that depends other
+  properties, you want to track both so that when one of the
+  dependents change, a rerender is scheduled.
+
+  In the following example we have two properties,
+  `eatenApples`, and `remainingApples`.
+
+  ```typescript
+  import Component from '@glimmer/component';
+  import { tracked } from '@glimmer/tracking';
+
+  const totalApples = 100;
+
+  export default class MyComponent extends Component {
+    @tracked
+    eatenApples = 0
+
+    get remainingApples() {
+      return totalApples - this.eatenApples;
+    }
+
+    increment() {
+      this.eatenApples = this.eatenApples + 1;
+    }
+  }
+  ```
+
+  @param dependencies Optional dependents to be tracked.
+*/
+
 function tracked(...args) {
-  (isDevelopingApp() && !(!(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)) && assert(`@tracked can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: tracked()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)));
+  (!(!(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)) && assert(`@tracked can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: tracked()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true)));
   if (!isElementDescriptor(args)) {
     let propertyDesc = args[0];
-    (isDevelopingApp() && !(args.length === 0 || typeof propertyDesc === 'object' && propertyDesc !== null) && assert(`tracked() may only receive an options object containing 'value' or 'initializer', received ${propertyDesc}`, args.length === 0 || typeof propertyDesc === 'object' && propertyDesc !== null));
-    if (isDevelopingApp() && propertyDesc) {
+    (!(args.length === 0 || typeof propertyDesc === 'object' && propertyDesc !== null) && assert(`tracked() may only receive an options object containing 'value' or 'initializer', received ${propertyDesc}`, args.length === 0 || typeof propertyDesc === 'object' && propertyDesc !== null));
+    if (propertyDesc) {
       let keys = Object.keys(propertyDesc);
-      (isDevelopingApp() && !(keys.length <= 1 && (keys[0] === undefined || keys[0] === 'value' || keys[0] === 'initializer')) && assert(`The options object passed to tracked() may only contain a 'value' or 'initializer' property, not both. Received: [${keys}]`, keys.length <= 1 && (keys[0] === undefined || keys[0] === 'value' || keys[0] === 'initializer')));
-      (isDevelopingApp() && !(!('initializer' in propertyDesc) || typeof propertyDesc.initializer === 'function') && assert(`The initializer passed to tracked must be a function. Received ${propertyDesc.initializer}`, !('initializer' in propertyDesc) || typeof propertyDesc.initializer === 'function'));
+      (!(keys.length <= 1 && (keys[0] === undefined || keys[0] === 'value' || keys[0] === 'initializer')) && assert(`The options object passed to tracked() may only contain a 'value' or 'initializer' property, not both. Received: [${keys}]`, keys.length <= 1 && (keys[0] === undefined || keys[0] === 'value' || keys[0] === 'initializer')));
+      (!(!('initializer' in propertyDesc) || typeof propertyDesc.initializer === 'function') && assert(`The initializer passed to tracked must be a function. Received ${propertyDesc.initializer}`, !('initializer' in propertyDesc) || typeof propertyDesc.initializer === 'function'));
     }
     let initializer = propertyDesc ? propertyDesc.initializer : undefined;
     let value = propertyDesc ? propertyDesc.value : undefined;
     let decorator = function (target, key, _desc, _meta, isClassicDecorator) {
-      (isDevelopingApp() && !(isClassicDecorator) && assert(`You attempted to set a default value for ${key} with the @tracked({ value: 'default' }) syntax. You can only use this syntax with classic classes. For native classes, you can use class initializers: @tracked field = 'default';`, isClassicDecorator));
+      (!(isClassicDecorator) && assert(`You attempted to set a default value for ${key} with the @tracked({ value: 'default' }) syntax. You can only use this syntax with classic classes. For native classes, you can use class initializers: @tracked field = 'default';`, isClassicDecorator));
       let fieldDesc = {
         initializer: initializer || (() => value)
       };
@@ -1865,13 +2009,13 @@ function tracked(...args) {
   }
   return descriptorForField(args);
 }
-if (isDevelopingApp()) {
+{
   // Normally this isn't a classic decorator, but we want to throw a helpful
   // error in development so we need it to treat it like one
   setClassicDecorator(tracked);
 }
 function descriptorForField([target, key, desc]) {
-  (isDevelopingApp() && !(!desc || !desc.value && !desc.get && !desc.set) && assert(`You attempted to use @tracked on ${key}, but that element is not a class field. @tracked is only usable on class fields. Native getters and setters will autotrack add any tracked fields they encounter, so there is no need mark getters and setters with @tracked.`, !desc || !desc.value && !desc.get && !desc.set));
+  (!(!desc || !desc.value && !desc.get && !desc.set) && assert(`You attempted to use @tracked on ${key}, but that element is not a class field. @tracked is only usable on class fields. Native getters and setters will autotrack add any tracked fields they encounter, so there is no need mark getters and setters with @tracked.`, !desc || !desc.value && !desc.get && !desc.set));
   let {
     getter,
     setter
@@ -1915,4 +2059,4 @@ class TrackedDescriptor {
   }
 }
 
-export { markObjectAsDirty as $, defineDecorator as A, revalidateObservers as B, ComputedProperty as C, DEBUG_INJECTION_FUNCTIONS as D, descriptorForDecorator as E, addListener as F, removeListener as G, makeComputedDecorator as H, flushAsyncObservers as I, ComputedDescriptor as J, CHAIN_PASS_THROUGH as K, getChainTagsForKey as L, finishLazyChains as M, on as N, LIBRARIES as O, PROXY_CONTENT as P, PROPERTY_DID_CHANGE as Q, autoComputed as R, tracked as S, changeProperties as T, isComputed as U, ASYNC_OBSERVERS as V, Libraries as W, SYNC_OBSERVERS as X, TrackedDescriptor as Y, _getProp as Z, _getPath as _, tagForProperty as a, descriptorForProperty as b, computed as c, defineProperty as d, expandProperties as e, isClassicDecorator as f, get as g, hasUnknownProperty as h, isElementDescriptor as i, activateObserver as j, sendEvent as k, beginPropertyChanges as l, endPropertyChanges as m, notifyPropertyChange as n, objectAt as o, inject as p, isPath as q, COMPUTED_SETTERS as r, setClassicDecorator as s, tagForObject as t, getPossibleMandatoryProxyValue as u, hasListeners as v, removeObserver as w, addObserver as x, nativeDescDecorator as y, defineValue as z };
+export { tracked as $, revalidateObservers as A, descriptorForDecorator as B, ComputedProperty as C, DEBUG_INJECTION_FUNCTIONS as D, addListener as E, removeListener as F, makeComputedDecorator as G, flushAsyncObservers as H, ComputedDescriptor as I, CHAIN_PASS_THROUGH as J, getChainTagsForKey as K, finishLazyChains as L, on as M, LIBRARIES as N, PROPERTY_DID_CHANGE as O, PROXY_CONTENT as P, objectAt as Q, autoComputed as R, changeProperties as S, ASYNC_OBSERVERS as T, Libraries as U, SYNC_OBSERVERS as V, TrackedDescriptor as W, _getProp as X, isComputed as Y, markObjectAsDirty as Z, _getPath as _, tagForProperty as a, descriptorForProperty as b, computed as c, defineProperty as d, expandProperties as e, isClassicDecorator as f, get as g, hasUnknownProperty as h, isElementDescriptor as i, activateObserver as j, sendEvent as k, inject as l, isPath as m, notifyPropertyChange as n, COMPUTED_SETTERS as o, getPossibleMandatoryProxyValue as p, hasListeners as q, removeObserver as r, setClassicDecorator as s, tagForObject as t, addObserver as u, endPropertyChanges as v, beginPropertyChanges as w, nativeDescDecorator as x, defineValue as y, defineDecorator as z };