ember-source 3.28.5 → 4.0.0-beta.10

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

@@ -1,10 +1,10 @@
 import { meta, peekMeta } from '@ember/-internals/meta';
-import { setListeners, isObject, setupMandatorySetter, symbol, toString, enumerableSymbol, getDebugName, setWithMandatorySetter, Cache, HAS_NATIVE_PROXY, isEmberArray, setProxy, lookupDescriptor, inspect, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
-import { assert, deprecate, warn, debug } from '@ember/debug';
+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 { assert, deprecate, debug, warn } from '@ember/debug';
 import { ENV, context } from '@ember/-internals/environment';
 import { schedule } from '@ember/runloop';
 import { registerDestructor, isDestroyed } from '@glimmer/destroyable';
-import { CURRENT_TAG, tagMetaFor, validateTag, valueForTag, CONSTANT_TAG, dirtyTagFor, tagFor, combine, createUpdatableTag, updateTag, consumeTag, deprecateMutationsInTrackingTransaction, isTracking, track, ALLOW_CYCLES, untrack, trackedData } from '@glimmer/validator';
+import { CURRENT_TAG, tagMetaFor, validateTag, valueForTag, CONSTANT_TAG, dirtyTagFor, tagFor, combine, createUpdatableTag, updateTag, ALLOW_CYCLES, consumeTag, track, untrack, isTracking, trackedData } from '@glimmer/validator';
 export { createCache, getValue, isConst } from '@glimmer/validator';
 import { DEBUG } from '@glimmer/env';
 import { getCustomTagFor } from '@glimmer/manager';
@@ -12,8 +12,6 @@ import { _WeakSet } from '@glimmer/util';
 import EmberError from '@ember/error';
 import VERSION from 'ember/version';
 import { INIT_FACTORY } from '@ember/-internals/container';
-import { ALIAS_METHOD } from '@ember/deprecated-features';
-import { assign } from '@ember/polyfills';
 import { getOwner } from '@ember/-internals/owner';
 
 /**
@@ -653,43 +651,29 @@ function replaceInNativeArray(array, start, deleteCount, items) {
   arrayContentDidChange(array, start, deleteCount, items.length);
 }
 
-function arrayObserversHelper(obj, target, opts, operation, notify) {
-  let willChange = opts && opts.willChange || 'arrayWillChange';
-  let didChange = opts && opts.didChange || 'arrayDidChange';
-  let hasObservers = obj.hasArrayObservers;
+function arrayObserversHelper(obj, target, opts, operation) {
+  var _a;
+
+  let {
+    willChange,
+    didChange
+  } = opts;
   operation(obj, '@array:before', target, willChange);
   operation(obj, '@array:change', target, didChange);
+  /*
+   * Array proxies have a `_revalidate` method which must be called to set
+   * up their internal array observation systems.
+   */
 
-  if (hasObservers === notify) {
-    notifyPropertyChange(obj, 'hasArrayObservers');
-  }
-
+  (_a = obj._revalidate) === null || _a === void 0 ? void 0 : _a.call(obj);
   return obj;
 }
 
-function addArrayObserver(array, target, opts, suppress = false) {
-  deprecate(`Array observers have been deprecated. Added an array observer to ${getDebugName === null || getDebugName === void 0 ? void 0 : getDebugName(array)}.`, suppress, {
-    id: 'array-observers',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_array-observers',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0-beta.1'
-    }
-  });
-  return arrayObserversHelper(array, target, opts, addListener, false);
+function addArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, addListener);
 }
-function removeArrayObserver(array, target, opts, suppress = false) {
-  deprecate(`Array observers have been deprecated. Removed an array observer from ${getDebugName === null || getDebugName === void 0 ? void 0 : getDebugName(array)}.`, suppress, {
-    id: 'array-observers',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_array-observers',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0-beta.1'
-    }
-  });
-  return arrayObserversHelper(array, target, opts, removeListener, true);
+function removeArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, removeListener);
 }
 
 const CHAIN_PASS_THROUGH = new _WeakSet();
@@ -743,16 +727,7 @@ function getChainTags(chainTags, obj, path, tagMeta, meta$$1) {
 
     if (segment === '@each' && segmentEnd !== pathLength) {
       lastSegmentEnd = segmentEnd + 1;
-      segmentEnd = path.indexOf('.', lastSegmentEnd); // There should be exactly one segment after an `@each` (i.e. `@each.foo`, not `@each.foo.bar`)
-
-      deprecate(`When using @each in a dependent-key or an observer, ` + `you can only chain one property level deep after ` + `the @each. That is, \`${path.slice(0, segmentEnd)}\` ` + `is allowed but \`${path}\` (which is what you passed) ` + `is not.\n\n` + `This was never supported. Currently, the extra segments ` + `are silently ignored, i.e. \`${path}\` behaves exactly ` + `the same as \`${path.slice(0, segmentEnd)}\`. ` + `In the future, this will throw an error.\n\n` + `If the current behavior is acceptable for your use case, ` + `please remove the extraneous segments by changing your ` + `key to \`${path.slice(0, segmentEnd)}\`. ` + `Otherwise, please create an intermediary computed property ` + `or switch to using tracked properties.`, segmentEnd === -1, {
-        until: '3.17.0',
-        id: 'ember-metal.computed-deep-each',
-        for: 'ember-source',
-        since: {
-          enabled: '3.13.0-beta.3'
-        }
-      });
+      segmentEnd = path.indexOf('.', lastSegmentEnd);
       let arrLength = current.length;
 
       if (typeof arrLength !== 'number' || // TODO: should the second test be `isEmberArray` instead?
@@ -1068,1161 +1043,967 @@ function dive(prefix, pattern, start, callback) {
 /**
 @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.
+const DEEP_EACH_REGEX = /\.@each\.[^.]+\./;
 
-  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.
+function noop() {}
+/**
+  `@computed` is a decorator that turns a JavaScript getter and setter into a
+  computed property, which is a _cached, trackable value_. By default the getter
+  will only be called once and the result will be cached. You can specify
+  various properties that your computed property depends on. This will force the
+  cached result to be cleared if the dependencies are modified, and lazily recomputed the next time something asks for it.
 
-  ## Examples
+  In the following example we decorate a getter - `fullName` -  by calling
+  `computed` with the property dependencies (`firstName` and `lastName`) as
+  arguments. The `fullName` getter will be called once (regardless of how many
+  times it is accessed) as long as its dependencies do not change. Once
+  `firstName` or `lastName` are updated any future calls to `fullName` will
+  incorporate the new values, and any watchers of the value such as templates
+  will be updated:
 
   ```javascript
-  import { defineProperty, computed } from '@ember/object';
+  import { computed, set } from '@ember/object';
 
-  // ES5 compatible mode
-  defineProperty(contact, 'firstName', {
-    writable: true,
-    configurable: false,
-    enumerable: true,
-    value: 'Charles'
+  class Person {
+    constructor(firstName, lastName) {
+      set(this, 'firstName', firstName);
+      set(this, 'lastName', lastName);
+    }
+
+    @computed('firstName', 'lastName')
+    get fullName() {
+      return `${this.firstName} ${this.lastName}`;
+    }
   });
 
-  // define a simple property
-  defineProperty(contact, 'lastName', undefined, 'Jolley');
+  let tom = new Person('Tom', 'Dale');
 
-  // define a computed property
-  defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
-    return this.firstName+' '+this.lastName;
-  }));
+  tom.fullName; // 'Tom Dale'
   ```
 
-  @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.
-*/
+  You can also provide a setter, which will be used when updating the computed
+  property. Ember's `set` function must be used to update the property
+  since it will also notify observers of the property:
 
-function defineProperty(obj, keyName, desc, data, _meta) {
-  let meta$$1 = _meta === undefined ? meta(obj) : _meta;
-  let previousDesc = descriptorForProperty(obj, keyName, meta$$1);
-  let wasDescriptor = previousDesc !== undefined;
+  ```javascript
+  import { computed, set } from '@ember/object';
 
-  if (wasDescriptor) {
-    previousDesc.teardown(obj, keyName, meta$$1);
-  }
+  class Person {
+    constructor(firstName, lastName) {
+      set(this, 'firstName', firstName);
+      set(this, 'lastName', lastName);
+    }
 
-  if (isClassicDecorator(desc)) {
-    defineDecorator(obj, keyName, desc, meta$$1);
-  } else if (desc === null || desc === undefined) {
-    defineValue(obj, keyName, data, wasDescriptor, true);
-  } else {
-    // fallback to ES5
-    Object.defineProperty(obj, keyName, desc);
-  } // if key is being watched, override chains that
-  // were initialized with the prototype
+    @computed('firstName', 'lastName')
+    get fullName() {
+      return `${this.firstName} ${this.lastName}`;
+    }
 
+    set fullName(value) {
+      let [firstName, lastName] = value.split(' ');
 
-  if (!meta$$1.isPrototypeMeta(obj)) {
-    revalidateObservers(obj);
-  }
-}
-function defineDecorator(obj, keyName, desc, meta$$1) {
-  let propertyDesc;
+      set(this, 'firstName', firstName);
+      set(this, 'lastName', lastName);
+    }
+  });
 
-  if (DEBUG) {
-    propertyDesc = desc(obj, keyName, undefined, meta$$1, true);
-  } else {
-    propertyDesc = desc(obj, keyName, undefined, meta$$1);
-  }
+  let person = new Person();
 
-  Object.defineProperty(obj, keyName, propertyDesc); // pass the decorator function forward for backwards compat
+  set(person, 'fullName', 'Peter Wagenet');
+  person.firstName; // 'Peter'
+  person.lastName;  // 'Wagenet'
+  ```
 
-  return desc;
-}
-function defineValue(obj, keyName, value, wasDescriptor, enumerable = true) {
-  if (wasDescriptor === true || enumerable === false) {
-    Object.defineProperty(obj, keyName, {
-      configurable: true,
-      enumerable,
-      writable: true,
-      value
+  You can also pass a getter function or object with `get` and `set` functions
+  as the last argument to the computed decorator. This allows you to define
+  computed property _macros_:
+
+  ```js
+  import { computed } from '@ember/object';
+
+  function join(...keys) {
+    return computed(...keys, function() {
+      return keys.map(key => this[key]).join(' ');
     });
-  } else {
-    if (DEBUG) {
-      setWithMandatorySetter(obj, keyName, value);
-    } else {
-      obj[keyName] = value;
-    }
   }
 
-  return value;
-}
+  class Person {
+    @join('firstName', 'lastName')
+    fullName;
+  }
+  ```
 
-const firstDotIndexCache = new Cache(1000, key => key.indexOf('.'));
-function isPath(path) {
-  return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
-}
+  Note that when defined this way, getters and setters receive the _key_ of the
+  property they are decorating as the first argument. Setters receive the value
+  they are setting to as the second argument instead. Additionally, setters must
+  _return_ the value that should be cached:
 
-/**
-@module @ember/object
-*/
-const PROXY_CONTENT = symbol('PROXY_CONTENT');
-let getPossibleMandatoryProxyValue;
+  ```javascript
+  import { computed, set } from '@ember/object';
 
-if (DEBUG && HAS_NATIVE_PROXY) {
-  getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
-    let content = obj[PROXY_CONTENT];
+  function fullNameMacro(firstNameKey, lastNameKey) {
+    return computed(firstNameKey, lastNameKey, {
+      get() {
+        return `${this[firstNameKey]} ${this[lastNameKey]}`;
+      }
 
-    if (content === undefined) {
-      return obj[keyName];
-    } else {
-      /* global Reflect */
-      return Reflect.get(content, keyName, obj);
+      set(key, value) {
+        let [firstName, lastName] = value.split(' ');
+
+        set(this, firstNameKey, firstName);
+        set(this, lastNameKey, lastName);
+
+        return value;
+      }
+    });
+  }
+
+  class Person {
+    constructor(firstName, lastName) {
+      set(this, 'firstName', firstName);
+      set(this, 'lastName', lastName);
     }
-  };
-} // ..........................................................
-// GET AND SET
-//
-// If we are on a platform that supports accessors we can use those.
-// Otherwise simulate accessors by looking up the property directly on the
-// object.
 
-/**
-  Gets the value of a property on an object. If the property is computed,
-  the function will be invoked. If the property is not defined but the
-  object implements the `unknownProperty` method then that will be invoked.
+    @fullNameMacro('firstName', 'lastName') fullName;
+  });
 
-  ```javascript
-  import { get } from '@ember/object';
-  get(obj, "name");
-  ```
+  let person = new Person();
 
-  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.)
+  set(person, 'fullName', 'Peter Wagenet');
+  person.firstName; // 'Peter'
+  person.lastName;  // 'Wagenet'
+  ```
 
-  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.
+  Computed properties can also be used in classic classes. To do this, we
+  provide the getter and setter as the last argument like we would for a macro,
+  and we assign it to a property on the class definition. This is an _anonymous_
+  computed macro:
 
-  Note that if the object itself is `undefined`, this method will throw
-  an error.
+  ```javascript
+  import EmberObject, { computed, set } from '@ember/object';
 
-  @method get
-  @for @ember/object
-  @static
-  @param {Object} obj The object to retrieve from.
-  @param {String} keyName The property key to retrieve
-  @return {Object} the property value or `null`.
-  @public
-*/
+  let Person = EmberObject.extend({
+    // these will be supplied by `create`
+    firstName: null,
+    lastName: null,
 
+    fullName: computed('firstName', 'lastName', {
+      get() {
+        return `${this.firstName} ${this.lastName}`;
+      }
 
-function get(obj, keyName) {
-  assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2);
-  assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
-  assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName));
-  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) {
-  let type = typeof obj;
-  let isObject$$1 = type === 'object';
-  let isFunction = type === 'function';
-  let isObjectLike = isObject$$1 || isFunction;
-  let value;
+      set(key, value) {
+        let [firstName, lastName] = value.split(' ');
 
-  if (isObjectLike) {
-    if (DEBUG && HAS_NATIVE_PROXY) {
-      value = getPossibleMandatoryProxyValue(obj, keyName);
-    } else {
-      value = obj[keyName];
-    }
+        set(this, 'firstName', firstName);
+        set(this, 'lastName', lastName);
 
-    if (value === undefined && isObject$$1 && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
-      if (DEBUG) {
-        deprecateMutationsInTrackingTransaction(() => {
-          value = obj.unknownProperty(keyName);
-        });
-      } else {
-        value = obj.unknownProperty(keyName);
+        return value;
       }
-    }
+    })
+  });
 
-    if (isTracking()) {
-      consumeTag(tagFor(obj, keyName));
+  let tom = Person.create({
+    firstName: 'Tom',
+    lastName: 'Dale'
+  });
 
-      if (Array.isArray(value) || isEmberArray(value)) {
-        // Add the tag of the returned value if it is an array, since arrays
-        // should always cause updates if they are consumed and then changed
-        consumeTag(tagFor(value, '[]'));
-      }
-    }
-  } else {
-    value = obj[keyName];
-  }
+  tom.get('fullName') // 'Tom Dale'
+  ```
 
-  return value;
-}
-function _getPath(root, path) {
-  let obj = root;
-  let parts = typeof path === 'string' ? path.split('.') : path;
+  You can overwrite computed property without setters with a normal property (no
+  longer computed) that won't change if dependencies change. You can also mark
+  computed property as `.readOnly()` and block all attempts to set it.
 
-  for (let i = 0; i < parts.length; i++) {
-    if (obj === undefined || obj === null || obj.isDestroyed) {
-      return undefined;
-    }
+  ```javascript
+  import { computed, set } from '@ember/object';
 
-    obj = _getProp(obj, parts[i]);
-  }
+  class Person {
+    constructor(firstName, lastName) {
+      set(this, 'firstName', firstName);
+      set(this, 'lastName', lastName);
+    }
 
-  return obj;
-}
-/**
-  Retrieves the value of a property from an Object, or a default value in the
-  case that the property returns `undefined`.
+    @computed('firstName', 'lastName').readOnly()
+    get fullName() {
+      return `${this.firstName} ${this.lastName}`;
+    }
+  });
 
-  ```javascript
-  import { getWithDefault } from '@ember/object';
-  getWithDefault(person, 'lastName', 'Doe');
+  let person = new Person();
+  person.set('fullName', 'Peter Wagenet'); // Uncaught Error: Cannot set read-only property "fullName" on object: <(...):emberXXX>
   ```
 
-  @method getWithDefault
-  @for @ember/object
-  @static
-  @param {Object} obj The object to retrieve from.
-  @param {String} keyName The name of the property to retrieve
-  @param {Object} defaultValue The value to return if the property value is undefined
-  @return {Object} The property value or the defaultValue.
+  Additional resources:
+  - [Decorators RFC](https://github.com/emberjs/rfcs/blob/master/text/0408-decorators.md)
+  - [New CP syntax RFC](https://github.com/emberjs/rfcs/blob/master/text/0011-improved-cp-syntax.md)
+  - [New computed syntax explained in "Ember 1.12 released" ](https://emberjs.com/blog/2015/05/13/ember-1-12-released.html#toc_new-computed-syntax)
+
+  @class ComputedProperty
   @public
-  @deprecated
 */
 
-function getWithDefault(root, key, defaultValue) {
-  deprecate('Using getWithDefault has been deprecated. Instead, consider using Ember get and explicitly checking for undefined.', false, {
-    id: 'ember-metal.get-with-default',
-    until: '4.0.0',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_ember-metal-get-with-default',
-    for: 'ember-source',
-    since: {
-      enabled: '3.21.0'
+
+class ComputedProperty extends ComputedDescriptor {
+  constructor(args) {
+    super();
+    this._readOnly = false;
+    this._hasConfig = false;
+    this._getter = undefined;
+    this._setter = undefined;
+    let maybeConfig = args[args.length - 1];
+
+    if (typeof maybeConfig === 'function' || maybeConfig !== null && typeof maybeConfig === 'object') {
+      this._hasConfig = true;
+      let config = args.pop();
+
+      if (typeof config === 'function') {
+        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;
+        assert('computed expects a function or an object as last argument.', typeof objectConfig === 'object' && !Array.isArray(objectConfig));
+        assert('Config object passed to computed can only contain `get` and `set` keys.', Object.keys(objectConfig).every(key => key === 'get' || key === '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;
+      }
     }
-  });
-  let value = get(root, key);
 
-  if (value === undefined) {
-    return defaultValue;
+    if (args.length > 0) {
+      this._property(...args);
+    }
   }
 
-  return value;
-}
-
-_getProp('foo', 'a');
+  setup(obj, keyName, propertyDesc, meta$$1) {
+    super.setup(obj, keyName, propertyDesc, meta$$1);
+    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'));
+    assert(`@computed can only be used on empty fields. ${keyName} has an initial value (e.g. \`${keyName} = someValue\`)`, !propertyDesc || !propertyDesc.initializer);
+    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')));
 
-_getProp('foo', 1);
+    if (this._hasConfig === false) {
+      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
+      } = propertyDesc;
 
-_getProp({}, 'a');
+      if (get !== undefined) {
+        this._getter = get;
+      }
 
-_getProp({}, 1);
+      if (set !== undefined) {
+        this._setter = function setterWrapper(_key, value) {
+          let ret = set.call(this, value);
 
-_getProp({
-  unkonwnProperty() {}
+          if (get !== undefined) {
+            return typeof ret === 'undefined' ? get.call(this) : ret;
+          }
 
-}, 'a');
+          return ret;
+        };
+      }
+    }
+  }
 
-_getProp({
-  unkonwnProperty() {}
+  _property(...passedArgs) {
+    let args = [];
 
-}, 1);
+    function addArg(property) {
+      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);
+    }
 
-get({}, 'foo');
-get({}, 'foo.bar');
-let fakeProxy = {};
-setProxy(fakeProxy);
-track(() => _getProp({}, 'a'));
-track(() => _getProp({}, 1));
-track(() => _getProp({
-  a: []
-}, 'a'));
-track(() => _getProp({
-  a: fakeProxy
-}, 'a'));
+    for (let i = 0; i < passedArgs.length; i++) {
+      expandProperties(passedArgs[i], addArg);
+    }
 
-/**
- @module @ember/object
-*/
+    this._dependentKeys = args;
+  }
 
-/**
-  Sets the value of a property on an object, respecting computed properties
-  and notifying observers and other listeners of the change.
-  If the specified property is not defined on the object and the object
-  implements the `setUnknownProperty` method, then instead of setting the
-  value of the property on the object, its `setUnknownProperty` handler
-  will be invoked with the two parameters `keyName` and `value`.
+  get(obj, keyName) {
+    let meta$$1 = meta(obj);
+    let tagMeta = tagMetaFor(obj);
+    let propertyTag = tagFor(obj, keyName, tagMeta);
+    let ret;
+    let revision = meta$$1.revisionFor(keyName);
 
-  ```javascript
-  import { set } from '@ember/object';
-  set(obj, "name", value);
-  ```
+    if (revision !== undefined && validateTag(propertyTag, revision)) {
+      ret = meta$$1.valueFor(keyName);
+    } 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.
+      assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, this._dependentKeys === undefined || !isDestroyed(obj));
+      let {
+        _getter,
+        _dependentKeys
+      } = this; // Create a tracker that absorbs any trackable actions inside the CP
 
-  @method set
-  @static
-  @for @ember/object
-  @param {Object} obj The object to modify.
-  @param {String} keyName The property key to set
-  @param {Object} value The value to set
-  @return {Object} the passed value.
-  @public
-*/
+      untrack(() => {
+        ret = _getter.call(obj, keyName);
+      });
 
-function set(obj, keyName, value, tolerant) {
-  assert(`Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`, arguments.length === 3 || arguments.length === 4);
-  assert(`Cannot call set with '${keyName}' on an undefined object.`, obj && typeof obj === 'object' || typeof obj === 'function');
-  assert(`The key provided to set must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName));
-  assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0);
+      if (_dependentKeys !== undefined) {
+        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$$1));
 
-  if (obj.isDestroyed) {
-    assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`, tolerant);
-    return value;
-  }
+        if (DEBUG) {
+          ALLOW_CYCLES.set(propertyTag, true);
+        }
+      }
 
-  return isPath(keyName) ? _setPath(obj, keyName, value, tolerant) : _setProp(obj, keyName, value);
-}
-function _setProp(obj, keyName, value) {
-  let descriptor = lookupDescriptor(obj, keyName);
+      meta$$1.setValueFor(keyName, ret);
+      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      finishLazyChains(meta$$1, keyName, ret);
+    }
 
-  if (descriptor !== null && COMPUTED_SETTERS.has(descriptor.set)) {
-    obj[keyName] = value;
-    return value;
-  }
+    consumeTag(propertyTag); // Add the tag of the returned value if it is an array, since arrays
+    // should always cause updates if they are consumed and then changed
 
-  let currentValue;
+    if (Array.isArray(ret)) {
+      consumeTag(tagFor(ret, '[]'));
+    }
 
-  if (DEBUG && HAS_NATIVE_PROXY) {
-    currentValue = getPossibleMandatoryProxyValue(obj, keyName);
-  } else {
-    currentValue = obj[keyName];
+    return ret;
   }
 
-  if (currentValue === undefined && 'object' === typeof obj && !(keyName in obj) && typeof obj.setUnknownProperty === 'function') {
-    /* unknown property */
-    obj.setUnknownProperty(keyName, value);
-  } else {
-    if (DEBUG) {
-      setWithMandatorySetter(obj, keyName, value);
-    } else {
-      obj[keyName] = value;
-    }
-
-    if (currentValue !== value) {
-      notifyPropertyChange(obj, keyName);
+  set(obj, keyName, value) {
+    if (this._readOnly) {
+      this._throwReadOnlyError(obj, keyName);
     }
-  }
 
-  return value;
-}
+    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
+    // property with both a setter and dependent keys, in that scenario without
+    // the sync observer added below the caller's value will never be updated
+    //
+    // See GH#18147 / GH#19028 for details.
 
-function _setPath(root, path, value, tolerant) {
-  let parts = path.split('.');
-  let keyName = parts.pop();
-  assert('Property set failed: You passed an empty path', keyName.trim().length > 0);
-  let newRoot = _getPath(root, parts);
+    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) {
+      addObserver(obj, keyName, () => {
+        obj[PROPERTY_DID_CHANGE](keyName);
+      }, undefined, true);
+    }
 
-  if (newRoot !== null && newRoot !== undefined) {
-    return set(newRoot, keyName, value);
-  } else if (!tolerant) {
-    throw new EmberError(`Property set failed: object in path "${parts.join('.')}" could not be found.`);
-  }
-}
-/**
-  Error-tolerant form of `set`. Will not blow up if any part of the
-  chain is `undefined`, `null`, or destroyed.
+    let ret;
 
-  This is primarily used when syncing bindings, which may try to update after
-  an object has been destroyed.
+    try {
+      beginPropertyChanges();
+      ret = this._set(obj, keyName, value, meta$$1);
+      finishLazyChains(meta$$1, keyName, ret);
+      let tagMeta = tagMetaFor(obj);
+      let propertyTag = tagFor(obj, keyName, tagMeta);
+      let {
+        _dependentKeys
+      } = this;
 
-  ```javascript
-  import { trySet } from '@ember/object';
+      if (_dependentKeys !== undefined) {
+        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$$1));
 
-  let obj = { name: "Zoey" };
-  trySet(obj, "contacts.twitter", "@emberjs");
-  ```
+        if (DEBUG) {
+          ALLOW_CYCLES.set(propertyTag, true);
+        }
+      }
 
-  @method trySet
-  @static
-  @for @ember/object
-  @param {Object} root The object to modify.
-  @param {String} path The property path to set
-  @param {Object} value The value to set
-  @public
-*/
+      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
+    } finally {
+      endPropertyChanges();
+    }
 
+    return ret;
+  }
 
-function trySet(root, path, value) {
-  return set(root, path, value, true);
-}
+  _throwReadOnlyError(obj, keyName) {
+    throw new EmberError(`Cannot set read-only property "${keyName}" on object: ${inspect(obj)}`);
+  }
 
-/**
-@module @ember/object
-*/
+  _set(obj, keyName, value, meta$$1) {
+    let hadCachedValue = meta$$1.revisionFor(keyName) !== undefined;
+    let cachedValue = meta$$1.valueFor(keyName);
+    let ret;
+    let {
+      _setter
+    } = this;
+    setObserverSuspended(obj, keyName, true);
 
-const DEEP_EACH_REGEX = /\.@each\.[^.]+\./;
+    try {
+      ret = _setter.call(obj, keyName, value, cachedValue);
+    } finally {
+      setObserverSuspended(obj, keyName, false);
+    } // allows setter to return the same value that is cached already
 
-function noop() {}
-/**
-  `@computed` is a decorator that turns a JavaScript getter and setter into a
-  computed property, which is a _cached, trackable value_. By default the getter
-  will only be called once and the result will be cached. You can specify
-  various properties that your computed property depends on. This will force the
-  cached result to be cleared if the dependencies are modified, and lazily recomputed the next time something asks for it.
 
-  In the following example we decorate a getter - `fullName` -  by calling
-  `computed` with the property dependencies (`firstName` and `lastName`) as
-  arguments. The `fullName` getter will be called once (regardless of how many
-  times it is accessed) as long as its dependencies do not change. Once
-  `firstName` or `lastName` are updated any future calls to `fullName` will
-  incorporate the new values, and any watchers of the value such as templates
-  will be updated:
+    if (hadCachedValue && cachedValue === ret) {
+      return ret;
+    }
 
-  ```javascript
-  import { computed, set } from '@ember/object';
+    meta$$1.setValueFor(keyName, ret);
+    notifyPropertyChange(obj, keyName, meta$$1, value);
+    return ret;
+  }
+  /* called before property is overridden */
 
-  class Person {
-    constructor(firstName, lastName) {
-      set(this, 'firstName', firstName);
-      set(this, 'lastName', lastName);
-    }
 
-    @computed('firstName', 'lastName')
-    get fullName() {
-      return `${this.firstName} ${this.lastName}`;
+  teardown(obj, keyName, meta$$1) {
+    if (meta$$1.revisionFor(keyName) !== undefined) {
+      meta$$1.setRevisionFor(keyName, undefined);
+      meta$$1.setValueFor(keyName, undefined);
     }
-  });
-
-  let tom = new Person('Tom', 'Dale');
 
-  tom.fullName; // 'Tom Dale'
-  ```
+    super.teardown(obj, keyName, meta$$1);
+  }
 
-  You can also provide a setter, which will be used when updating the computed
-  property. Ember's `set` function must be used to update the property
-  since it will also notify observers of the property:
+}
 
-  ```javascript
-  import { computed, set } from '@ember/object';
+class AutoComputedProperty extends ComputedProperty {
+  get(obj, keyName) {
+    let meta$$1 = meta(obj);
+    let tagMeta = tagMetaFor(obj);
+    let propertyTag = tagFor(obj, keyName, tagMeta);
+    let ret;
+    let revision = meta$$1.revisionFor(keyName);
 
-  class Person {
-    constructor(firstName, lastName) {
-      set(this, 'firstName', firstName);
-      set(this, 'lastName', lastName);
-    }
+    if (revision !== undefined && validateTag(propertyTag, revision)) {
+      ret = meta$$1.valueFor(keyName);
+    } else {
+      assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, !isDestroyed(obj));
+      let {
+        _getter
+      } = this; // Create a tracker that absorbs any trackable actions inside the CP
 
-    @computed('firstName', 'lastName')
-    get fullName() {
-      return `${this.firstName} ${this.lastName}`;
+      let tag = track(() => {
+        ret = _getter.call(obj, keyName);
+      });
+      updateTag(propertyTag, tag);
+      meta$$1.setValueFor(keyName, ret);
+      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
+      finishLazyChains(meta$$1, keyName, ret);
     }
 
-    set fullName(value) {
-      let [firstName, lastName] = value.split(' ');
+    consumeTag(propertyTag); // Add the tag of the returned value if it is an array, since arrays
+    // should always cause updates if they are consumed and then changed
 
-      set(this, 'firstName', firstName);
-      set(this, 'lastName', lastName);
+    if (Array.isArray(ret)) {
+      consumeTag(tagFor(ret, '[]', tagMeta));
     }
-  });
-
-  let person = new Person();
-
-  set(person, 'fullName', 'Peter Wagenet');
-  person.firstName; // 'Peter'
-  person.lastName;  // 'Wagenet'
-  ```
-
-  You can also pass a getter function or object with `get` and `set` functions
-  as the last argument to the computed decorator. This allows you to define
-  computed property _macros_:
-
-  ```js
-  import { computed } from '@ember/object';
-
-  function join(...keys) {
-    return computed(...keys, function() {
-      return keys.map(key => this[key]).join(' ');
-    });
-  }
 
-  class Person {
-    @join('firstName', 'lastName')
-    fullName;
+    return ret;
   }
-  ```
-
-  Note that when defined this way, getters and setters receive the _key_ of the
-  property they are decorating as the first argument. Setters receive the value
-  they are setting to as the second argument instead. Additionally, setters must
-  _return_ the value that should be cached:
-
-  ```javascript
-  import { computed, set } from '@ember/object';
-
-  function fullNameMacro(firstNameKey, lastNameKey) {
-    return computed(firstNameKey, lastNameKey, {
-      get() {
-        return `${this[firstNameKey]} ${this[lastNameKey]}`;
-      }
 
-      set(key, value) {
-        let [firstName, lastName] = value.split(' ');
+} // TODO: This class can be svelted once `meta` has been deprecated
 
-        set(this, firstNameKey, firstName);
-        set(this, lastNameKey, lastName);
 
-        return value;
+class ComputedDecoratorImpl extends Function {
+  /**
+    Call on a computed property to set it into read-only mode. When in this
+    mode the computed property will throw an error when set.
+       Example:
+       ```javascript
+    import { computed, set } from '@ember/object';
+       class Person {
+      @computed().readOnly()
+      get guid() {
+        return 'guid-guid-guid';
       }
-    });
-  }
-
-  class Person {
-    constructor(firstName, lastName) {
-      set(this, 'firstName', firstName);
-      set(this, 'lastName', lastName);
     }
-
-    @fullNameMacro('firstName', 'lastName') fullName;
-  });
-
-  let person = new Person();
-
-  set(person, 'fullName', 'Peter Wagenet');
-  person.firstName; // 'Peter'
-  person.lastName;  // 'Wagenet'
-  ```
-
-  Computed properties can also be used in classic classes. To do this, we
-  provide the getter and setter as the last argument like we would for a macro,
-  and we assign it to a property on the class definition. This is an _anonymous_
-  computed macro:
-
-  ```javascript
-  import EmberObject, { computed, set } from '@ember/object';
-
-  let Person = EmberObject.extend({
-    // these will be supplied by `create`
-    firstName: null,
-    lastName: null,
-
-    fullName: computed('firstName', 'lastName', {
-      get() {
-        return `${this.firstName} ${this.lastName}`;
-      }
-
-      set(key, value) {
-        let [firstName, lastName] = value.split(' ');
-
-        set(this, 'firstName', firstName);
-        set(this, 'lastName', lastName);
-
-        return value;
+       let person = new Person();
+    set(person, 'guid', 'new-guid'); // will throw an exception
+    ```
+       Classic Class Example:
+       ```javascript
+    import EmberObject, { computed } from '@ember/object';
+       let Person = EmberObject.extend({
+      guid: computed(function() {
+        return 'guid-guid-guid';
+      }).readOnly()
+    });
+       let person = Person.create();
+    person.set('guid', 'new-guid'); // will throw an exception
+    ```
+       @method readOnly
+    @return {ComputedProperty} this
+    @chainable
+    @public
+  */
+  readOnly() {
+    let desc = descriptorForDecorator(this);
+    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;
+  }
+  /**
+    In some cases, you may want to annotate computed properties with additional
+    metadata about how they function or what values they operate on. For example,
+    computed property functions may close over variables that are then no longer
+    available for introspection. You can pass a hash of these values to a
+    computed property.
+       Example:
+       ```javascript
+    import { computed } from '@ember/object';
+    import Person from 'my-app/utils/person';
+       class Store {
+      @computed().meta({ type: Person })
+      get person() {
+        let personId = this.personId;
+        return Person.create({ id: personId });
       }
-    })
-  });
-
-  let tom = Person.create({
-    firstName: 'Tom',
-    lastName: 'Dale'
-  });
-
-  tom.get('fullName') // 'Tom Dale'
-  ```
-
-  You can overwrite computed property without setters with a normal property (no
-  longer computed) that won't change if dependencies change. You can also mark
-  computed property as `.readOnly()` and block all attempts to set it.
-
-  ```javascript
-  import { computed, set } from '@ember/object';
-
-  class Person {
-    constructor(firstName, lastName) {
-      set(this, 'firstName', firstName);
-      set(this, 'lastName', lastName);
     }
+    ```
+       Classic Class Example:
+       ```javascript
+    import { computed } from '@ember/object';
+    import Person from 'my-app/utils/person';
+       const Store = EmberObject.extend({
+      person: computed(function() {
+        let personId = this.get('personId');
+        return Person.create({ id: personId });
+      }).meta({ type: Person })
+    });
+    ```
+       The hash that you pass to the `meta()` function will be saved on the
+    computed property descriptor under the `_meta` key. Ember runtime
+    exposes a public API for retrieving these values from classes,
+    via the `metaForProperty()` function.
+       @method meta
+    @param {Object} meta
+    @chainable
+    @public
+  */
 
-    @computed('firstName', 'lastName').readOnly()
-    get fullName() {
-      return `${this.firstName} ${this.lastName}`;
-    }
-  });
-
-  let person = new Person();
-  person.set('fullName', 'Peter Wagenet'); // Uncaught Error: Cannot set read-only property "fullName" on object: <(...):emberXXX>
-  ```
-
-  Additional resources:
-  - [Decorators RFC](https://github.com/emberjs/rfcs/blob/master/text/0408-decorators.md)
-  - [New CP syntax RFC](https://github.com/emberjs/rfcs/blob/master/text/0011-improved-cp-syntax.md)
-  - [New computed syntax explained in "Ember 1.12 released" ](https://emberjs.com/blog/2015/05/13/ember-1-12-released.html#toc_new-computed-syntax)
-
-  @class ComputedProperty
-  @public
-*/
-
-
-class ComputedProperty extends ComputedDescriptor {
-  constructor(args) {
-    super();
-    this._volatile = false;
-    this._readOnly = false;
-    this._hasConfig = false;
-    this._getter = undefined;
-    this._setter = undefined;
-    let maybeConfig = args[args.length - 1];
-
-    if (typeof maybeConfig === 'function' || maybeConfig !== null && typeof maybeConfig === 'object') {
-      this._hasConfig = true;
-      let config = args.pop();
 
-      if (typeof config === 'function') {
-        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;
-        assert('computed expects a function or an object as last argument.', typeof objectConfig === 'object' && !Array.isArray(objectConfig));
-        assert('Config object passed to computed can only contain `get` and `set` keys.', Object.keys(objectConfig).every(key => key === 'get' || key === '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;
-      }
-    }
+  meta(meta$$1) {
+    let prop = descriptorForDecorator(this);
 
-    if (args.length > 0) {
-      this._property(...args);
+    if (arguments.length === 0) {
+      return prop._meta || {};
+    } else {
+      prop._meta = meta$$1;
+      return this;
     }
-  }
-
-  setup(obj, keyName, propertyDesc, meta$$1) {
-    super.setup(obj, keyName, propertyDesc, meta$$1);
-    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'));
-    assert(`@computed can only be used on empty fields. ${keyName} has an initial value (e.g. \`${keyName} = someValue\`)`, !propertyDesc || !propertyDesc.initializer);
-    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) {
-      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: set$$1
-      } = propertyDesc;
+  } // TODO: Remove this when we can provide alternatives in the ecosystem to
+  // addons such as ember-macro-helpers that use it.
 
-      if (get !== undefined) {
-        this._getter = get;
-      }
 
-      if (set$$1 !== undefined) {
-        this._setter = function setterWrapper(_key, value) {
-          let ret = set$$1.call(this, value);
+  get _getter() {
+    return descriptorForDecorator(this)._getter;
+  } // TODO: Refactor this, this is an internal API only
 
-          if (get !== undefined) {
-            return typeof ret === 'undefined' ? get.call(this) : ret;
-          }
 
-          return ret;
-        };
-      }
-    }
+  set enumerable(value) {
+    descriptorForDecorator(this).enumerable = value;
   }
 
-  _property(...passedArgs) {
-    let args = [];
-
-    function addArg(property) {
-      warn(`Dependent keys containing @each only work one level deep. ` + `You used the key "${property}" which is invalid. ` + `Please create an intermediary computed property.`, DEEP_EACH_REGEX.test(property) === false, {
-        id: 'ember-metal.computed-deep-each'
-      });
-      args.push(property);
-    }
+}
 
-    for (let i = 0; i < passedArgs.length; i++) {
-      expandProperties(passedArgs[i], addArg);
-    }
+function computed(...args) {
+  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));
 
-    this._dependentKeys = args;
+  if (isElementDescriptor(args)) {
+    let decorator = makeComputedDecorator(new ComputedProperty([]), ComputedDecoratorImpl);
+    return decorator(args[0], args[1], args[2]);
   }
 
-  get(obj, keyName) {
-    if (this._volatile) {
-      return this._getter.call(obj, keyName);
-    }
-
-    let meta$$1 = meta(obj);
-    let tagMeta = tagMetaFor(obj);
-    let propertyTag = tagFor(obj, keyName, tagMeta);
-    let ret;
-    let revision = meta$$1.revisionFor(keyName);
+  return makeComputedDecorator(new ComputedProperty(args), ComputedDecoratorImpl);
+}
+function autoComputed(...config) {
+  return makeComputedDecorator(new AutoComputedProperty(config), ComputedDecoratorImpl);
+}
+/**
+  Allows checking if a given property on an object is a computed property. For the most part,
+  this doesn't matter (you would normally just access the property directly and use its value),
+  but for some tooling specific scenarios (e.g. the ember-inspector) it is important to
+  differentiate if a property is a computed property or a "normal" property.
 
-    if (revision !== undefined && validateTag(propertyTag, revision)) {
-      ret = meta$$1.valueFor(keyName);
-    } 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.
-      assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, this._dependentKeys === undefined || !isDestroyed(obj));
-      let {
-        _getter,
-        _dependentKeys
-      } = this; // Create a tracker that absorbs any trackable actions inside the CP
+  This will work on either a class's prototype or an instance itself.
 
-      untrack(() => {
-        ret = _getter.call(obj, keyName);
-      });
+  @static
+  @method isComputed
+  @for @ember/debug
+  @private
+ */
 
-      if (_dependentKeys !== undefined) {
-        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$$1));
+function isComputed(obj, key) {
+  return Boolean(descriptorForProperty(obj, key));
+}
 
-        if (DEBUG) {
-          ALLOW_CYCLES.set(propertyTag, true);
-        }
-      }
+function getCachedValueFor(obj, key) {
+  let meta$$1 = peekMeta(obj);
 
-      meta$$1.setValueFor(keyName, ret);
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
-      finishLazyChains(meta$$1, keyName, ret);
-    }
+  if (meta$$1) {
+    return meta$$1.valueFor(key);
+  }
+}
 
-    consumeTag(propertyTag); // Add the tag of the returned value if it is an array, since arrays
-    // should always cause updates if they are consumed and then changed
+/**
+@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.
 
-    if (Array.isArray(ret)) {
-      consumeTag(tagFor(ret, '[]'));
-    }
+  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.
 
-    return ret;
-  }
+  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.
 
-  set(obj, keyName, value) {
-    if (this._readOnly) {
-      this._throwReadOnlyError(obj, keyName);
-    }
+  ## Examples
 
-    if (!this._setter) {
-      return this.clobberSet(obj, keyName, value);
-    }
+  ```javascript
+  import { defineProperty, computed } from '@ember/object';
 
-    if (this._volatile) {
-      return this.volatileSet(obj, keyName, value);
-    }
+  // ES5 compatible mode
+  defineProperty(contact, 'firstName', {
+    writable: true,
+    configurable: false,
+    enumerable: true,
+    value: 'Charles'
+  });
 
-    let meta$$1 = meta(obj); // ensure two way binding works when the component has defined a computed
-    // property with both a setter and dependent keys, in that scenario without
-    // the sync observer added below the caller's value will never be updated
-    //
-    // See GH#18147 / GH#19028 for details.
+  // define a simple property
+  defineProperty(contact, 'lastName', undefined, 'Jolley');
 
-    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) {
-      addObserver(obj, keyName, () => {
-        obj[PROPERTY_DID_CHANGE](keyName);
-      }, undefined, true);
-    }
+  // define a computed property
+  defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
+    return this.firstName+' '+this.lastName;
+  }));
+  ```
 
-    let ret;
+  @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.
+*/
 
-    try {
-      beginPropertyChanges();
-      ret = this._set(obj, keyName, value, meta$$1);
-      finishLazyChains(meta$$1, keyName, ret);
-      let tagMeta = tagMetaFor(obj);
-      let propertyTag = tagFor(obj, keyName, tagMeta);
-      let {
-        _dependentKeys
-      } = this;
+function defineProperty(obj, keyName, desc, data, _meta) {
+  let meta$$1 = _meta === undefined ? meta(obj) : _meta;
+  let previousDesc = descriptorForProperty(obj, keyName, meta$$1);
+  let wasDescriptor = previousDesc !== undefined;
 
-      if (_dependentKeys !== undefined) {
-        updateTag(propertyTag, getChainTagsForKeys(obj, _dependentKeys, tagMeta, meta$$1));
+  if (wasDescriptor) {
+    previousDesc.teardown(obj, keyName, meta$$1);
+  }
 
-        if (DEBUG) {
-          ALLOW_CYCLES.set(propertyTag, true);
-        }
-      }
+  if (isClassicDecorator(desc)) {
+    defineDecorator(obj, keyName, desc, meta$$1);
+  } else if (desc === null || desc === undefined) {
+    defineValue(obj, keyName, data, wasDescriptor, true);
+  } else {
+    // fallback to ES5
+    Object.defineProperty(obj, keyName, desc);
+  } // if key is being watched, override chains that
+  // were initialized with the prototype
 
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
-    } finally {
-      endPropertyChanges();
-    }
 
-    return ret;
+  if (!meta$$1.isPrototypeMeta(obj)) {
+    revalidateObservers(obj);
   }
+}
+function defineDecorator(obj, keyName, desc, meta$$1) {
+  let propertyDesc;
 
-  _throwReadOnlyError(obj, keyName) {
-    throw new EmberError(`Cannot set read-only property "${keyName}" on object: ${inspect(obj)}`);
+  if (DEBUG) {
+    propertyDesc = desc(obj, keyName, undefined, meta$$1, true);
+  } else {
+    propertyDesc = desc(obj, keyName, undefined, meta$$1);
   }
 
-  clobberSet(obj, keyName, value) {
-    deprecate(`The ${toString(obj)}#${keyName} computed property was just overridden. This removes the computed property and replaces it with a plain value, and has been deprecated. If you want this behavior, consider defining a setter which does it manually.`, false, {
-      id: 'computed-property.override',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_computed-property-override',
-      for: 'ember-source',
-      since: {
-        enabled: '3.9.0-beta.1'
-      }
+  Object.defineProperty(obj, keyName, propertyDesc); // pass the decorator function forward for backwards compat
+
+  return desc;
+}
+function defineValue(obj, keyName, value, wasDescriptor, enumerable = true) {
+  if (wasDescriptor === true || enumerable === false) {
+    Object.defineProperty(obj, keyName, {
+      configurable: true,
+      enumerable,
+      writable: true,
+      value
     });
-    let cachedValue = meta(obj).valueFor(keyName);
-    defineProperty(obj, keyName, null, cachedValue);
-    set(obj, keyName, value);
-    return value;
+  } else {
+    if (DEBUG) {
+      setWithMandatorySetter(obj, keyName, value);
+    } else {
+      obj[keyName] = value;
+    }
   }
 
-  volatileSet(obj, keyName, value) {
-    return this._setter.call(obj, keyName, value);
-  }
+  return value;
+}
 
-  _set(obj, keyName, value, meta$$1) {
-    let hadCachedValue = meta$$1.revisionFor(keyName) !== undefined;
-    let cachedValue = meta$$1.valueFor(keyName);
-    let ret;
-    let {
-      _setter
-    } = this;
-    setObserverSuspended(obj, keyName, true);
+const firstDotIndexCache = new Cache(1000, key => key.indexOf('.'));
+function isPath(path) {
+  return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
+}
 
-    try {
-      ret = _setter.call(obj, keyName, value, cachedValue);
-    } finally {
-      setObserverSuspended(obj, keyName, false);
-    } // allows setter to return the same value that is cached already
+/**
+@module @ember/object
+*/
+const PROXY_CONTENT = symbol('PROXY_CONTENT');
+let getPossibleMandatoryProxyValue;
 
+if (DEBUG) {
+  getPossibleMandatoryProxyValue = function getPossibleMandatoryProxyValue(obj, keyName) {
+    let content = obj[PROXY_CONTENT];
 
-    if (hadCachedValue && cachedValue === ret) {
-      return ret;
+    if (content === undefined) {
+      return obj[keyName];
+    } else {
+      /* global Reflect */
+      return Reflect.get(content, keyName, obj);
     }
+  };
+} // ..........................................................
+// GET AND SET
+//
+// If we are on a platform that supports accessors we can use those.
+// Otherwise simulate accessors by looking up the property directly on the
+// object.
 
-    meta$$1.setValueFor(keyName, ret);
-    notifyPropertyChange(obj, keyName, meta$$1, value);
-    return ret;
-  }
-  /* called before property is overridden */
+/**
+  Gets the value of a property on an object. If the property is computed,
+  the function will be invoked. If the property is not defined but the
+  object implements the `unknownProperty` method then that will be invoked.
 
+  ```javascript
+  import { get } from '@ember/object';
+  get(obj, "name");
+  ```
 
-  teardown(obj, keyName, meta$$1) {
-    if (!this._volatile) {
-      if (meta$$1.revisionFor(keyName) !== undefined) {
-        meta$$1.setRevisionFor(keyName, undefined);
-        meta$$1.setValueFor(keyName, undefined);
-      }
-    }
+  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.)
 
-    super.teardown(obj, keyName, meta$$1);
-  }
+  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.
 
-}
+  Note that if the object itself is `undefined`, this method will throw
+  an error.
 
-class AutoComputedProperty extends ComputedProperty {
-  get(obj, keyName) {
-    if (this._volatile) {
-      return this._getter.call(obj, keyName);
-    }
+  @method get
+  @for @ember/object
+  @static
+  @param {Object} obj The object to retrieve from.
+  @param {String} keyName The property key to retrieve
+  @return {Object} the property value or `null`.
+  @public
+*/
 
-    let meta$$1 = meta(obj);
-    let tagMeta = tagMetaFor(obj);
-    let propertyTag = tagFor(obj, keyName, tagMeta);
-    let ret;
-    let revision = meta$$1.revisionFor(keyName);
 
-    if (revision !== undefined && validateTag(propertyTag, revision)) {
-      ret = meta$$1.valueFor(keyName);
-    } else {
-      assert(`Attempted to access the computed ${obj}.${keyName} on a destroyed object, which is not allowed`, !isDestroyed(obj));
-      let {
-        _getter
-      } = this; // Create a tracker that absorbs any trackable actions inside the CP
+function get(obj, keyName) {
+  assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2);
+  assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
+  assert(`The key provided to get must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName));
+  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) {
+  let type = typeof obj;
+  let isObject$$1 = type === 'object';
+  let isFunction = type === 'function';
+  let isObjectLike = isObject$$1 || isFunction;
+  let value;
 
-      let tag = track(() => {
-        ret = _getter.call(obj, keyName);
-      });
-      updateTag(propertyTag, tag);
-      meta$$1.setValueFor(keyName, ret);
-      meta$$1.setRevisionFor(keyName, valueForTag(propertyTag));
-      finishLazyChains(meta$$1, keyName, ret);
+  if (isObjectLike) {
+    if (DEBUG) {
+      value = getPossibleMandatoryProxyValue(obj, keyName);
+    } else {
+      value = obj[keyName];
     }
 
-    consumeTag(propertyTag); // Add the tag of the returned value if it is an array, since arrays
-    // should always cause updates if they are consumed and then changed
-
-    if (Array.isArray(ret)) {
-      consumeTag(tagFor(ret, '[]', tagMeta));
+    if (value === undefined && isObject$$1 && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
+      value = obj.unknownProperty(keyName);
     }
 
-    return ret;
-  }
-
-} // TODO: This class can be svelted once `meta` has been deprecated
-
+    if (isTracking()) {
+      consumeTag(tagFor(obj, keyName));
 
-class ComputedDecoratorImpl extends Function {
-  /**
-    Call on a computed property to set it into read-only mode. When in this
-    mode the computed property will throw an error when set.
-       Example:
-       ```javascript
-    import { computed, set } from '@ember/object';
-       class Person {
-      @computed().readOnly()
-      get guid() {
-        return 'guid-guid-guid';
+      if (Array.isArray(value) || isEmberArray(value)) {
+        // Add the tag of the returned value if it is an array, since arrays
+        // should always cause updates if they are consumed and then changed
+        consumeTag(tagFor(value, '[]'));
       }
     }
-       let person = new Person();
-    set(person, 'guid', 'new-guid'); // will throw an exception
-    ```
-       Classic Class Example:
-       ```javascript
-    import EmberObject, { computed } from '@ember/object';
-       let Person = EmberObject.extend({
-      guid: computed(function() {
-        return 'guid-guid-guid';
-      }).readOnly()
-    });
-       let person = Person.create();
-    person.set('guid', 'new-guid'); // will throw an exception
-    ```
-       @method readOnly
-    @return {ComputedProperty} this
-    @chainable
-    @public
-  */
-  readOnly() {
-    let desc = descriptorForDecorator(this);
-    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;
+  } else {
+    value = obj[keyName];
   }
-  /**
-    Call on a computed property to set it into non-cached mode. When in this
-    mode the computed property will not automatically cache the return value.
-    It also does not automatically fire any change events. You must manually notify
-    any changes if you want to observe this property.
-       Dependency keys have no effect on volatile properties as they are for cache
-    invalidation and notification when cached value is invalidated.
-       Example:
-       ```javascript
-    import { computed } from '@ember/object';
-       class CallCounter {
-      _calledCount = 0;
-         @computed().volatile()
-      get calledCount() {
-        return this._calledCount++;
-      }
-    }
-    ```
-       Classic Class Example:
-       ```javascript
-    import EmberObject, { computed } from '@ember/object';
-       let CallCounter = EmberObject.extend({
-      _calledCount: 0,
-         value: computed(function() {
-        return this._calledCount++;
-      }).volatile()
-    });
-    ```
-    @method volatile
-    @deprecated
-    @return {ComputedProperty} this
-    @chainable
-    @public
-  */
 
+  return value;
+}
+function _getPath(root, path) {
+  let obj = root;
+  let parts = typeof path === 'string' ? path.split('.') : path;
 
-  volatile() {
-    deprecate('Setting a computed property as volatile has been deprecated. Instead, consider using a native getter with native class syntax.', false, {
-      id: 'computed-property.volatile',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_computed-property-volatile',
-      for: 'ember-source',
-      since: {
-        enabled: '3.9.0-beta.1'
-      }
-    });
-    descriptorForDecorator(this)._volatile = true;
-    return this;
-  }
-  /**
-    Sets the dependent keys on this computed property. Pass any number of
-    arguments containing key paths that this computed property depends on.
-       Example:
-       ```javascript
-    import EmberObject, { computed } from '@ember/object';
-       class President {
-      constructor(firstName, lastName) {
-        set(this, 'firstName', firstName);
-        set(this, 'lastName', lastName);
-      }
-         // Tell Ember that this computed property depends on firstName
-      // and lastName
-      @computed().property('firstName', 'lastName')
-      get fullName() {
-        return `${this.firstName} ${this.lastName}`;
-      }
-    }
-       let president = new President('Barack', 'Obama');
-       president.fullName; // 'Barack Obama'
-    ```
-       Classic Class Example:
-       ```javascript
-    import EmberObject, { computed } from '@ember/object';
-       let President = EmberObject.extend({
-      fullName: computed(function() {
-        return this.get('firstName') + ' ' + this.get('lastName');
-           // Tell Ember that this computed property depends on firstName
-        // and lastName
-      }).property('firstName', 'lastName')
-    });
-       let president = President.create({
-      firstName: 'Barack',
-      lastName: 'Obama'
-    });
-       president.get('fullName'); // 'Barack Obama'
-    ```
-       @method property
-    @deprecated
-    @param {String} path* zero or more property paths
-    @return {ComputedProperty} this
-    @chainable
-    @public
-  */
+  for (let i = 0; i < parts.length; i++) {
+    if (obj === undefined || obj === null || obj.isDestroyed) {
+      return undefined;
+    }
 
+    obj = _getProp(obj, parts[i]);
+  }
 
-  property(...keys) {
-    deprecate('Setting dependency keys using the `.property()` modifier has been deprecated. Pass the dependency keys directly to computed as arguments instead. If you are using `.property()` on a computed property macro, consider refactoring your macro to receive additional dependent keys in its initial declaration.', false, {
-      id: 'computed-property.property',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_computed-property-property',
-      for: 'ember-source',
-      since: {
-        enabled: '3.9.0-beta.1'
-      }
-    });
+  return obj;
+}
 
-    descriptorForDecorator(this)._property(...keys);
+_getProp('foo', 'a');
 
-    return this;
-  }
-  /**
-    In some cases, you may want to annotate computed properties with additional
-    metadata about how they function or what values they operate on. For example,
-    computed property functions may close over variables that are then no longer
-    available for introspection. You can pass a hash of these values to a
-    computed property.
-       Example:
-       ```javascript
-    import { computed } from '@ember/object';
-    import Person from 'my-app/utils/person';
-       class Store {
-      @computed().meta({ type: Person })
-      get person() {
-        let personId = this.personId;
-        return Person.create({ id: personId });
-      }
-    }
-    ```
-       Classic Class Example:
-       ```javascript
-    import { computed } from '@ember/object';
-    import Person from 'my-app/utils/person';
-       const Store = EmberObject.extend({
-      person: computed(function() {
-        let personId = this.get('personId');
-        return Person.create({ id: personId });
-      }).meta({ type: Person })
-    });
-    ```
-       The hash that you pass to the `meta()` function will be saved on the
-    computed property descriptor under the `_meta` key. Ember runtime
-    exposes a public API for retrieving these values from classes,
-    via the `metaForProperty()` function.
-       @method meta
-    @param {Object} meta
-    @chainable
-    @public
-  */
+_getProp('foo', 1);
 
+_getProp({}, 'a');
 
-  meta(meta$$1) {
-    let prop = descriptorForDecorator(this);
+_getProp({}, 1);
 
-    if (arguments.length === 0) {
-      return prop._meta || {};
-    } else {
-      prop._meta = meta$$1;
-      return this;
-    }
-  } // TODO: Remove this when we can provide alternatives in the ecosystem to
-  // addons such as ember-macro-helpers that use it.
+_getProp({
+  unkonwnProperty() {}
 
+}, 'a');
 
-  get _getter() {
-    return descriptorForDecorator(this)._getter;
-  } // TODO: Refactor this, this is an internal API only
+_getProp({
+  unkonwnProperty() {}
 
+}, 1);
 
-  set enumerable(value) {
-    descriptorForDecorator(this).enumerable = value;
+get({}, 'foo');
+get({}, 'foo.bar');
+let fakeProxy = {};
+setProxy(fakeProxy);
+track(() => _getProp({}, 'a'));
+track(() => _getProp({}, 1));
+track(() => _getProp({
+  a: []
+}, 'a'));
+track(() => _getProp({
+  a: fakeProxy
+}, 'a'));
+
+/**
+ @module @ember/object
+*/
+
+/**
+  Sets the value of a property on an object, respecting computed properties
+  and notifying observers and other listeners of the change.
+  If the specified property is not defined on the object and the object
+  implements the `setUnknownProperty` method, then instead of setting the
+  value of the property on the object, its `setUnknownProperty` handler
+  will be invoked with the two parameters `keyName` and `value`.
+
+  ```javascript
+  import { set } from '@ember/object';
+  set(obj, "name", value);
+  ```
+
+  @method set
+  @static
+  @for @ember/object
+  @param {Object} obj The object to modify.
+  @param {String} keyName The property key to set
+  @param {Object} value The value to set
+  @return {Object} the passed value.
+  @public
+*/
+
+function set(obj, keyName, value, tolerant) {
+  assert(`Set must be called with three or four arguments; an object, a property key, a value and tolerant true/false`, arguments.length === 3 || arguments.length === 4);
+  assert(`Cannot call set with '${keyName}' on an undefined object.`, obj && typeof obj === 'object' || typeof obj === 'function');
+  assert(`The key provided to set must be a string or number, you passed ${keyName}`, typeof keyName === 'string' || typeof keyName === 'number' && !isNaN(keyName));
+  assert(`'this' in paths is not supported`, typeof keyName !== 'string' || keyName.lastIndexOf('this.', 0) !== 0);
+
+  if (obj.isDestroyed) {
+    assert(`calling set on destroyed object: ${toString(obj)}.${keyName} = ${toString(value)}`, tolerant);
+    return value;
   }
 
+  return isPath(keyName) ? _setPath(obj, keyName, value, tolerant) : _setProp(obj, keyName, value);
 }
+function _setProp(obj, keyName, value) {
+  let descriptor = lookupDescriptor(obj, keyName);
 
-function computed(...args) {
-  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 (descriptor !== null && COMPUTED_SETTERS.has(descriptor.set)) {
+    obj[keyName] = value;
+    return value;
+  }
 
-  if (isElementDescriptor(args)) {
-    let decorator = makeComputedDecorator(new ComputedProperty([]), ComputedDecoratorImpl);
-    return decorator(args[0], args[1], args[2]);
+  let currentValue;
+
+  if (DEBUG) {
+    currentValue = getPossibleMandatoryProxyValue(obj, keyName);
+  } else {
+    currentValue = obj[keyName];
   }
 
-  return makeComputedDecorator(new ComputedProperty(args), ComputedDecoratorImpl);
+  if (currentValue === undefined && 'object' === typeof obj && !(keyName in obj) && typeof obj.setUnknownProperty === 'function') {
+    /* unknown property */
+    obj.setUnknownProperty(keyName, value);
+  } else {
+    if (DEBUG) {
+      setWithMandatorySetter(obj, keyName, value);
+    } else {
+      obj[keyName] = value;
+    }
+
+    if (currentValue !== value) {
+      notifyPropertyChange(obj, keyName);
+    }
+  }
+
+  return value;
 }
-function autoComputed(...config) {
-  return makeComputedDecorator(new AutoComputedProperty(config), ComputedDecoratorImpl);
+
+function _setPath(root, path, value, tolerant) {
+  let parts = path.split('.');
+  let keyName = parts.pop();
+  assert('Property set failed: You passed an empty path', keyName.trim().length > 0);
+  let newRoot = _getPath(root, parts);
+
+  if (newRoot !== null && newRoot !== undefined) {
+    return set(newRoot, keyName, value);
+  } else if (!tolerant) {
+    throw new EmberError(`Property set failed: object in path "${parts.join('.')}" could not be found.`);
+  }
 }
 /**
-  Allows checking if a given property on an object is a computed property. For the most part,
-  this doesn't matter (you would normally just access the property directly and use its value),
-  but for some tooling specific scenarios (e.g. the ember-inspector) it is important to
-  differentiate if a property is a computed property or a "normal" property.
+  Error-tolerant form of `set`. Will not blow up if any part of the
+  chain is `undefined`, `null`, or destroyed.
 
-  This will work on either a class's prototype or an instance itself.
+  This is primarily used when syncing bindings, which may try to update after
+  an object has been destroyed.
 
-  @static
-  @method isComputed
-  @for @ember/debug
-  @private
- */
+  ```javascript
+  import { trySet } from '@ember/object';
 
-function isComputed(obj, key) {
-  return Boolean(descriptorForProperty(obj, key));
-}
+  let obj = { name: "Zoey" };
+  trySet(obj, "contacts.twitter", "@emberjs");
+  ```
 
-function getCachedValueFor(obj, key) {
-  let meta$$1 = peekMeta(obj);
+  @method trySet
+  @static
+  @for @ember/object
+  @param {Object} root The object to modify.
+  @param {String} path The property path to set
+  @param {Object} value The value to set
+  @public
+*/
 
-  if (meta$$1) {
-    return meta$$1.valueFor(key);
-  }
+
+function trySet(root, path, value) {
+  return set(root, path, value, true);
 }
 
 function alias(altKey) {
@@ -2966,7 +2747,6 @@ function giveDecoratorSuper(key, decorator, property, descs) {
       set
     }]);
     newProperty._readOnly = property._readOnly;
-    newProperty._volatile = property._volatile;
     newProperty._meta = property._meta;
     newProperty.enumerable = property.enumerable;
     return makeComputedDecorator(newProperty, ComputedProperty);
@@ -3015,7 +2795,7 @@ function applyMergedProperties(key, value, values) {
     return value;
   }
 
-  let newBase = assign({}, baseValue);
+  let newBase = Object.assign({}, baseValue);
   let hasFunction = false;
   let props = Object.keys(value);
 
@@ -3136,31 +2916,6 @@ function mergeProps(meta$$1, props, descs, values, base, keys, keysWithSuper) {
   }
 }
 
-let followMethodAlias;
-
-if (ALIAS_METHOD) {
-  followMethodAlias = function (obj, alias, descs, values) {
-    let altKey = alias.methodName;
-    let possibleDesc;
-    let desc = descs[altKey];
-    let value = values[altKey];
-
-    if (desc !== undefined || value !== undefined) {// do nothing
-    } else if ((possibleDesc = descriptorForProperty(obj, altKey)) !== undefined) {
-      desc = possibleDesc;
-      value = undefined;
-    } else {
-      desc = undefined;
-      value = obj[altKey];
-    }
-
-    return {
-      desc,
-      value
-    };
-  };
-}
-
 function updateObserversAndListeners(obj, key, fn, add) {
   let meta$$1 = observerListenerMetaFor(fn);
   if (meta$$1 === undefined) return;
@@ -3207,14 +2962,6 @@ function applyMixin(obj, mixins, _hideKeys = false) {
     let value = values[key];
     let desc = descs[key];
 
-    if (ALIAS_METHOD) {
-      while (value !== undefined && isAlias(value)) {
-        let followed = followMethodAlias(obj, value, descs, values);
-        desc = followed.desc;
-        value = followed.value;
-      }
-    }
-
     if (value !== undefined) {
       if (typeof value === 'function') {
         updateObserversAndListeners(obj, key, value, true);
@@ -3348,9 +3095,7 @@ class Mixin {
 
       guidFor(this);
 
-      if (true
-      /* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-      && Mixin._disableDebugSeal !== true) {
+      if (Mixin._disableDebugSeal !== true) {
         Object.seal(this);
       }
     }
@@ -3473,9 +3218,7 @@ class Mixin {
 
 }
 
-if (DEBUG && true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
+if (DEBUG) {
   Object.defineProperty(Mixin, '_disableDebugSeal', {
     configurable: true,
     enumerable: false,
@@ -3550,73 +3293,6 @@ function _keys(mixin, ret = new Set(), seen = new Set()) {
   return ret;
 }
 
-let AliasImpl;
-let isAlias;
-
-if (ALIAS_METHOD) {
-  const ALIASES = new _WeakSet();
-
-  isAlias = alias => {
-    return ALIASES.has(alias);
-  };
-
-  AliasImpl = class AliasImpl {
-    constructor(methodName) {
-      this.methodName = methodName;
-      ALIASES.add(this);
-    }
-
-  };
-}
-/**
-  Makes a method available via an additional name.
-
-  ```app/utils/person.js
-  import EmberObject, {
-    aliasMethod
-  } from '@ember/object';
-
-  export default EmberObject.extend({
-    name() {
-      return 'Tomhuda Katzdale';
-    },
-    moniker: aliasMethod('name')
-  });
-  ```
-
-  ```javascript
-  let goodGuy = Person.create();
-
-  goodGuy.name();    // 'Tomhuda Katzdale'
-  goodGuy.moniker(); // 'Tomhuda Katzdale'
-  ```
-
-  @method aliasMethod
-  @static
-  @deprecated Use a shared utility method instead
-  @for @ember/object
-  @param {String} methodName name of the method to alias
-  @public
-*/
-
-
-let aliasMethod;
-
-if (ALIAS_METHOD) {
-  aliasMethod = function aliasMethod(methodName) {
-    deprecate(`You attempted to alias '${methodName}, but aliasMethod has been deprecated. Consider extracting the method into a shared utility function.`, false, {
-      id: 'object.alias-method',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_object-alias-method',
-      for: 'ember-source',
-      since: {
-        enabled: '3.9.0'
-      }
-    });
-    return new AliasImpl(methodName);
-  };
-}
-
 function observer(...args) {
   let funcOrDef = args.pop();
   assert('observer must be provided a function or an observer definition', typeof funcOrDef === 'function' || typeof funcOrDef === 'object' && funcOrDef !== null);
@@ -3900,4 +3576,4 @@ class TrackedDescriptor {
   @public
 */
 
-export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, getWithDefault, _getProp, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, isNone, isEmpty, isBlank, isPresent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, Mixin, aliasMethod, mixin, observer, applyMixin, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };
+export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, isNone, isEmpty, isBlank, isPresent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, Mixin, mixin, observer, applyMixin, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };