ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

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

@@ -1,5 +1,5 @@
 import { meta, peekMeta } from '@ember/-internals/meta';
-import { setListeners, isObject, setupMandatorySetter, symbol, toString, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
+import { setListeners, isObject, setupMandatorySetter, symbol, toString, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName } from '@ember/-internals/utils';
 import { assert, deprecate, debug, warn } from '@ember/debug';
 import { ENV, context } from '@ember/-internals/environment';
 import { schedule } from '@ember/runloop';
@@ -11,7 +11,6 @@ import { getCustomTagFor } from '@glimmer/manager';
 import { _WeakSet } from '@glimmer/util';
 import EmberError from '@ember/error';
 import VERSION from 'ember/version';
-import { INIT_FACTORY } from '@ember/-internals/container';
 import { getOwner } from '@ember/-internals/owner';
 
 /*
@@ -2125,174 +2124,6 @@ function eachProxyArrayDidChange(array, idx, removedCnt, addedCnt) {
   }
 }
 
-/**
- @module @ember/utils
-*/
-
-/**
-  Returns true if the passed value is null or undefined. This avoids errors
-  from JSLint complaining about use of ==, which can be technically
-  confusing.
-
-  ```javascript
-  isNone(null);          // true
-  isNone(undefined);     // true
-  isNone('');            // false
-  isNone([]);            // false
-  isNone(function() {}); // false
-  ```
-
-  @method isNone
-  @static
-  @for @ember/utils
-  @param {Object} obj Value to test
-  @return {Boolean}
-  @public
-*/
-function isNone(obj) {
-  return obj === null || obj === undefined;
-}
-
-/**
- @module @ember/utils
-*/
-
-/**
-  Verifies that a value is `null` or `undefined`, an empty string, or an empty
-  array.
-
-  Constrains the rules on `isNone` by returning true for empty strings and
-  empty arrays.
-
-  If the value is an object with a `size` property of type number, it is used
-  to check emptiness.
-
-  ```javascript
-  isEmpty(null);             // true
-  isEmpty(undefined);        // true
-  isEmpty('');               // true
-  isEmpty([]);               // true
-  isEmpty({ size: 0});       // true
-  isEmpty({});               // false
-  isEmpty('Adam Hawkins');   // false
-  isEmpty([0,1,2]);          // false
-  isEmpty('\n\t');           // false
-  isEmpty('  ');             // false
-  isEmpty({ size: 1 })       // false
-  isEmpty({ size: () => 0 }) // false
-  ```
-
-  @method isEmpty
-  @static
-  @for @ember/utils
-  @param {Object} obj Value to test
-  @return {Boolean}
-  @public
-*/
-
-function isEmpty(obj) {
-  if (obj === null || obj === undefined) {
-    return true;
-  }
-
-  if (!hasUnknownProperty(obj) && typeof obj.size === 'number') {
-    return !obj.size;
-  }
-
-  if (typeof obj === 'object') {
-    let size = get(obj, 'size');
-
-    if (typeof size === 'number') {
-      return !size;
-    }
-
-    let length = get(obj, 'length');
-
-    if (typeof length === 'number') {
-      return !length;
-    }
-  }
-
-  if (typeof obj.length === 'number' && typeof obj !== 'function') {
-    return !obj.length;
-  }
-
-  return false;
-}
-
-/**
- @module @ember/utils
-*/
-
-/**
-  A value is blank if it is empty or a whitespace string.
-
-  ```javascript
-  import { isBlank } from '@ember/utils';
-
-  isBlank(null);            // true
-  isBlank(undefined);       // true
-  isBlank('');              // true
-  isBlank([]);              // true
-  isBlank('\n\t');          // true
-  isBlank('  ');            // true
-  isBlank({});              // false
-  isBlank('\n\t Hello');    // false
-  isBlank('Hello world');   // false
-  isBlank([1,2,3]);         // false
-  ```
-
-  @method isBlank
-  @static
-  @for @ember/utils
-  @param {Object} obj Value to test
-  @return {Boolean}
-  @since 1.5.0
-  @public
-*/
-
-function isBlank(obj) {
-  return isEmpty(obj) || typeof obj === 'string' && /\S/.test(obj) === false;
-}
-
-/**
- @module @ember/utils
-*/
-
-/**
-  A value is present if it not `isBlank`.
-
-  ```javascript
-  isPresent(null);            // false
-  isPresent(undefined);       // false
-  isPresent('');              // false
-  isPresent('  ');            // false
-  isPresent('\n\t');          // false
-  isPresent([]);              // false
-  isPresent({ length: 0 });   // false
-  isPresent(false);           // true
-  isPresent(true);            // true
-  isPresent('string');        // true
-  isPresent(0);               // true
-  isPresent(function() {});   // true
-  isPresent({});              // true
-  isPresent('\n\t Hello');    // true
-  isPresent([1, 2, 3]);       // true
-  ```
-
-  @method isPresent
-  @static
-  @for @ember/utils
-  @param {Object} obj Value to test
-  @return {Boolean}
-  @since 1.8.0
-  @public
-*/
-
-function isPresent(obj) {
-  return !isBlank(obj);
-}
-
 /**
  @module ember
 */
@@ -2333,972 +2164,116 @@ class Libraries {
         index = this._coreLibIndex++;
       }
 
-      this._registry.splice(index, 0, {
-        name,
-        version
-      });
-    } else {
-      warn(`Library "${name}" is already registered with Ember.`, false, {
-        id: 'ember-metal.libraries-register'
-      });
-    }
-  }
-
-  registerCoreLibrary(name, version) {
-    this.register(name, version, true);
-  }
-
-  deRegister(name) {
-    let lib = this._getLibraryByName(name);
-
-    let index;
-
-    if (lib) {
-      index = this._registry.indexOf(lib);
-
-      this._registry.splice(index, 1);
-    }
-  }
-
-}
-
-if (DEBUG) {
-  Libraries.prototype.logVersions = function () {
-    let libs = this._registry;
-    let nameLengths = libs.map(item => get(item, 'name.length'));
-    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) {
-      let spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
-      debug([lib.name, spaces, ' : ', lib.version].join(''));
-    }
-
-    debug('-------------------------------');
-  };
-}
-
-const LIBRARIES = new Libraries();
-LIBRARIES.registerCoreLibrary('Ember', VERSION);
-
-function getProperties(obj, keys) {
-  let ret = {};
-  let propertyNames;
-  let i = 1;
-
-  if (arguments.length === 2 && Array.isArray(keys)) {
-    i = 0;
-    propertyNames = arguments[1];
-  } else {
-    propertyNames = Array.from(arguments);
-  }
-
-  for (; i < propertyNames.length; i++) {
-    ret[propertyNames[i]] = get(obj, propertyNames[i]);
-  }
-
-  return ret;
-}
-
-/**
- @module @ember/object
-*/
-
-/**
-  Set a list of properties on an object. These properties are set inside
-  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-  observers will be buffered.
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  let anObject = EmberObject.create();
-
-  anObject.setProperties({
-    firstName: 'Stanley',
-    lastName: 'Stuart',
-    age: 21
-  });
-  ```
-
-  @method setProperties
-  @static
-  @for @ember/object
-  @param obj
-  @param {Object} properties
-  @return properties
-  @public
-*/
-
-function setProperties(obj, properties) {
-  if (properties === null || typeof properties !== 'object') {
-    return properties;
-  }
-
-  changeProperties(() => {
-    let props = Object.keys(properties);
-
-    for (let propertyName of props) {
-      set(obj, propertyName, properties[propertyName]);
-    }
-  });
-  return properties;
-}
-
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-let searchDisabled = false;
-const flags = {
-  _set: 0,
-  _unprocessedNamespaces: false,
-
-  get unprocessedNamespaces() {
-    return this._unprocessedNamespaces;
-  },
-
-  set unprocessedNamespaces(v) {
-    this._set++;
-    this._unprocessedNamespaces = v;
-  }
-
-};
-let unprocessedMixins = false;
-const NAMESPACES = [];
-const NAMESPACES_BY_ID = Object.create(null);
-function addNamespace(namespace) {
-  flags.unprocessedNamespaces = true;
-  NAMESPACES.push(namespace);
-}
-function removeNamespace(namespace) {
-  let name = getName(namespace);
-  delete NAMESPACES_BY_ID[name];
-  NAMESPACES.splice(NAMESPACES.indexOf(namespace), 1);
-
-  if (name in context.lookup && namespace === context.lookup[name]) {
-    context.lookup[name] = undefined;
-  }
-}
-function findNamespaces() {
-  if (!flags.unprocessedNamespaces) {
-    return;
-  }
-
-  let lookup = context.lookup;
-  let keys = Object.keys(lookup);
-
-  for (let key of keys) {
-    // Only process entities that start with uppercase A-Z
-    if (!isUppercase(key.charCodeAt(0))) {
-      continue;
-    }
-
-    let obj = tryIsNamespace(lookup, key);
-
-    if (obj) {
-      setName(obj, key);
-    }
-  }
-}
-function findNamespace(name) {
-  if (!searchDisabled) {
-    processAllNamespaces();
-  }
-
-  return NAMESPACES_BY_ID[name];
-}
-function processNamespace(namespace) {
-  _processNamespace([namespace.toString()], namespace, new Set());
-}
-function processAllNamespaces() {
-  let unprocessedNamespaces = flags.unprocessedNamespaces;
-
-  if (unprocessedNamespaces) {
-    findNamespaces();
-    flags.unprocessedNamespaces = false;
-  }
-
-  if (unprocessedNamespaces || unprocessedMixins) {
-    let namespaces = NAMESPACES;
-
-    for (let namespace of namespaces) {
-      processNamespace(namespace);
-    }
-
-    unprocessedMixins = false;
-  }
-}
-function isSearchDisabled() {
-  return searchDisabled;
-}
-function setSearchDisabled(flag) {
-  searchDisabled = Boolean(flag);
-}
-function setUnprocessedMixins() {
-  unprocessedMixins = true;
-}
-
-function _processNamespace(paths, root, seen) {
-  let idx = paths.length;
-  let id = paths.join('.');
-  NAMESPACES_BY_ID[id] = root;
-  setName(root, id); // Loop over all of the keys in the namespace, looking for classes
-
-  for (let key in root) {
-    if (!hasOwnProperty.call(root, key)) {
-      continue;
-    }
-
-    let obj = root[key]; // If we are processing the `Ember` namespace, for example, the
-    // `paths` will start with `["Ember"]`. Every iteration through
-    // the loop will update the **second** element of this list with
-    // the key, so processing `Ember.View` will make the Array
-    // `['Ember', 'View']`.
-
-    paths[idx] = key; // If we have found an unprocessed class
-
-    if (obj && getName(obj) === void 0) {
-      // Replace the class' `toString` with the dot-separated path
-      setName(obj, paths.join('.')); // Support nested namespaces
-    } else if (obj && isNamespace(obj)) {
-      // Skip aliased namespaces
-      if (seen.has(obj)) {
-        continue;
-      }
-
-      seen.add(obj); // Process the child namespace
-
-      _processNamespace(paths, obj, seen);
-    }
-  }
-
-  paths.length = idx; // cut out last item
-}
-
-function isNamespace(obj) {
-  return obj != null && typeof obj === 'object' && obj.isNamespace;
-}
-
-function isUppercase(code) {
-  return code >= 65 && code <= 90 // A
-  ; // Z
-}
-
-function tryIsNamespace(lookup, prop) {
-  try {
-    let obj = lookup[prop];
-    return (obj !== null && typeof obj === 'object' || typeof obj === 'function') && obj.isNamespace && obj;
-  } catch (e) {// continue
-  }
-}
-
-/**
-@module @ember/object
-*/
-const a_concat = Array.prototype.concat;
-const {
-  isArray
-} = Array;
-
-function extractAccessors(properties) {
-  if (properties !== undefined) {
-    for (let key of Object.keys(properties)) {
-      let desc = Object.getOwnPropertyDescriptor(properties, key);
-
-      if (desc.get !== undefined || desc.set !== undefined) {
-        Object.defineProperty(properties, key, {
-          value: nativeDescDecorator(desc)
-        });
-      }
-    }
-  }
-
-  return properties;
-}
-
-function concatenatedMixinProperties(concatProp, props, values, base) {
-  // reset before adding each new mixin to pickup concats from previous
-  let concats = values[concatProp] || base[concatProp];
-
-  if (props[concatProp]) {
-    concats = concats ? a_concat.call(concats, props[concatProp]) : props[concatProp];
-  }
-
-  return concats;
-}
-
-function giveDecoratorSuper(key, decorator, property, descs) {
-  if (property === true) {
-    return decorator;
-  }
-
-  let originalGetter = property._getter;
-
-  if (originalGetter === undefined) {
-    return decorator;
-  }
-
-  let superDesc = descs[key]; // Check to see if the super property is a decorator first, if so load its descriptor
-
-  let superProperty = typeof superDesc === 'function' ? descriptorForDecorator(superDesc) : superDesc;
-
-  if (superProperty === undefined || superProperty === true) {
-    return decorator;
-  }
-
-  let superGetter = superProperty._getter;
-
-  if (superGetter === undefined) {
-    return decorator;
-  }
-
-  let get = wrap(originalGetter, superGetter);
-  let set;
-  let originalSetter = property._setter;
-  let superSetter = superProperty._setter;
-
-  if (superSetter !== undefined) {
-    if (originalSetter !== undefined) {
-      set = wrap(originalSetter, superSetter);
-    } else {
-      // If the super property has a setter, we default to using it no matter what.
-      // This is clearly very broken and weird, but it's what was here so we have
-      // to keep it until the next major at least.
-      //
-      // TODO: Add a deprecation here.
-      set = superSetter;
-    }
-  } else {
-    set = originalSetter;
-  } // only create a new CP if we must
-
-
-  if (get !== originalGetter || set !== originalSetter) {
-    // Since multiple mixins may inherit from the same parent, we need
-    // to clone the computed property so that other mixins do not receive
-    // the wrapped version.
-    let dependentKeys = property._dependentKeys || [];
-    let newProperty = new ComputedProperty([...dependentKeys, {
-      get,
-      set
-    }]);
-    newProperty._readOnly = property._readOnly;
-    newProperty._meta = property._meta;
-    newProperty.enumerable = property.enumerable; // SAFETY: We passed in the impl for this class
-
-    return makeComputedDecorator(newProperty, ComputedProperty);
-  }
-
-  return decorator;
-}
-
-function giveMethodSuper(key, method, values, descs) {
-  // Methods overwrite computed properties, and do not call super to them.
-  if (descs[key] !== undefined) {
-    return method;
-  } // Find the original method in a parent mixin
-
-
-  let superMethod = values[key]; // Only wrap the new method if the original method was a function
-
-  if (typeof superMethod === 'function') {
-    return wrap(method, superMethod);
-  }
-
-  return method;
-}
-
-function applyConcatenatedProperties(key, value, values) {
-  let baseValue = values[key];
-  let ret = makeArray(baseValue).concat(makeArray(value));
-
-  if (DEBUG) {
-    // it is possible to use concatenatedProperties with strings (which cannot be frozen)
-    // only freeze objects...
-    if (typeof ret === 'object' && ret !== null) {
-      // prevent mutating `concatenatedProperties` array after it is applied
-      Object.freeze(ret);
-    }
-  }
-
-  return ret;
-}
-
-function applyMergedProperties(key, value, values) {
-  let baseValue = values[key];
-  assert(`You passed in \`${JSON.stringify(value)}\` as the value for \`${key}\` but \`${key}\` cannot be an Array`, !isArray(value));
-
-  if (!baseValue) {
-    return value;
-  }
-
-  let newBase = Object.assign({}, baseValue);
-  let hasFunction = false;
-  let props = Object.keys(value);
-
-  for (let prop of props) {
-    let propValue = value[prop];
-
-    if (typeof propValue === 'function') {
-      hasFunction = true;
-      newBase[prop] = giveMethodSuper(prop, propValue, baseValue, {});
-    } else {
-      newBase[prop] = propValue;
-    }
-  }
-
-  if (hasFunction) {
-    newBase._super = ROOT;
-  }
-
-  return newBase;
-}
-
-function mergeMixins(mixins, meta$$1, descs, values, base, keys, keysWithSuper) {
-  let currentMixin;
-
-  for (let i = 0; i < mixins.length; i++) {
-    currentMixin = mixins[i];
-    assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(currentMixin)}`, typeof currentMixin === 'object' && currentMixin !== null && Object.prototype.toString.call(currentMixin) !== '[object Array]');
-
-    if (MIXINS.has(currentMixin)) {
-      if (meta$$1.hasMixin(currentMixin)) {
-        continue;
-      }
-
-      meta$$1.addMixin(currentMixin);
-      let {
-        properties,
-        mixins
-      } = currentMixin;
-
-      if (properties !== undefined) {
-        mergeProps(meta$$1, properties, descs, values, base, keys, keysWithSuper);
-      } else if (mixins !== undefined) {
-        mergeMixins(mixins, meta$$1, descs, values, base, keys, keysWithSuper);
-
-        if (currentMixin instanceof Mixin && currentMixin._without !== undefined) {
-          currentMixin._without.forEach(keyName => {
-            // deleting the key means we won't process the value
-            let index = keys.indexOf(keyName);
-
-            if (index !== -1) {
-              keys.splice(index, 1);
-            }
-          });
-        }
-      }
-    } else {
-      mergeProps(meta$$1, currentMixin, descs, values, base, keys, keysWithSuper);
-    }
-  }
-}
-
-function mergeProps(meta$$1, props, descs, values, base, keys, keysWithSuper) {
-  let concats = concatenatedMixinProperties('concatenatedProperties', props, values, base);
-  let mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
-  let propKeys = Object.keys(props);
-
-  for (let key of propKeys) {
-    let value = props[key];
-    if (value === undefined) continue;
-
-    if (keys.indexOf(key) === -1) {
-      keys.push(key);
-      let desc = meta$$1.peekDescriptors(key);
-
-      if (desc === undefined) {
-        // The superclass did not have a CP, which means it may have
-        // observers or listeners on that property.
-        let prev = values[key] = base[key];
-
-        if (typeof prev === 'function') {
-          updateObserversAndListeners(base, key, prev, false);
-        }
-      } else {
-        descs[key] = desc; // The super desc will be overwritten on descs, so save off the fact that
-        // there was a super so we know to Object.defineProperty when writing
-        // the value
-
-        keysWithSuper.push(key);
-        desc.teardown(base, key, meta$$1);
-      }
-    }
-
-    let isFunction = typeof value === 'function';
-
-    if (isFunction) {
-      let desc = descriptorForDecorator(value);
-
-      if (desc !== undefined) {
-        // Wrap descriptor function to implement _super() if needed
-        descs[key] = giveDecoratorSuper(key, value, desc, descs);
-        values[key] = undefined;
-        continue;
-      }
-    }
-
-    if (concats && concats.indexOf(key) >= 0 || key === 'concatenatedProperties' || key === 'mergedProperties') {
-      value = applyConcatenatedProperties(key, value, values);
-    } else if (mergings && mergings.indexOf(key) > -1) {
-      value = applyMergedProperties(key, value, values);
-    } else if (isFunction) {
-      value = giveMethodSuper(key, value, values, descs);
-    }
-
-    values[key] = value;
-    descs[key] = undefined;
-  }
-}
-
-function updateObserversAndListeners(obj, key, fn, add) {
-  let meta$$1 = observerListenerMetaFor(fn);
-  if (meta$$1 === undefined) return;
-  let {
-    observers,
-    listeners
-  } = meta$$1;
-
-  if (observers !== undefined) {
-    let updateObserver = add ? addObserver : removeObserver;
-
-    for (let path of observers.paths) {
-      updateObserver(obj, path, null, key, observers.sync);
-    }
-  }
-
-  if (listeners !== undefined) {
-    let updateListener = add ? addListener : removeListener;
-
-    for (let listener of listeners) {
-      updateListener(obj, listener, null, key);
-    }
-  }
-}
-
-function applyMixin(obj, mixins, _hideKeys = false) {
-  let descs = Object.create(null);
-  let values = Object.create(null);
-  let meta$$1 = meta(obj);
-  let keys = [];
-  let keysWithSuper = [];
-  obj._super = ROOT; // Go through all mixins and hashes passed in, and:
-  //
-  // * Handle concatenated properties
-  // * Handle merged properties
-  // * Set up _super wrapping if necessary
-  // * Set up computed property descriptors
-  // * Copying `toString` in broken browsers
-
-  mergeMixins(mixins, meta$$1, descs, values, obj, keys, keysWithSuper);
-
-  for (let key of keys) {
-    let value = values[key];
-    let desc = descs[key];
-
-    if (value !== undefined) {
-      if (typeof value === 'function') {
-        updateObserversAndListeners(obj, key, value, true);
-      }
-
-      defineValue(obj, key, value, keysWithSuper.indexOf(key) !== -1, !_hideKeys);
-    } else if (desc !== undefined) {
-      defineDecorator(obj, key, desc, meta$$1);
-    }
-  }
-
-  if (!meta$$1.isPrototypeMeta(obj)) {
-    revalidateObservers(obj);
-  }
-
-  return obj;
-}
-/**
-  @method mixin
-  @param obj
-  @param mixins*
-  @return obj
-  @private
-*/
-
-function mixin(obj, ...args) {
-  applyMixin(obj, args);
-  return obj;
-}
-const MIXINS = new _WeakSet();
-/**
-  The `Mixin` class allows you to create mixins, whose properties can be
-  added to other classes. For instance,
-
-  ```javascript
-  import Mixin from '@ember/object/mixin';
-
-  const EditableMixin = Mixin.create({
-    edit() {
-      console.log('starting to edit');
-      this.set('isEditing', true);
-    },
-    isEditing: false
-  });
-  ```
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import EditableMixin from '../mixins/editable';
-
-  // Mix mixins into classes by passing them as the first arguments to
-  // `.extend.`
-  const Comment = EmberObject.extend(EditableMixin, {
-    post: null
-  });
-
-  let comment = Comment.create({
-    post: somePost
-  });
-
-  comment.edit(); // outputs 'starting to edit'
-  ```
-
-  Note that Mixins are created with `Mixin.create`, not
-  `Mixin.extend`.
-
-  Note that mixins extend a constructor's prototype so arrays and object literals
-  defined as properties will be shared amongst objects that implement the mixin.
-  If you want to define a property in a mixin that is not shared, you can define
-  it either as a computed property or have it be created on initialization of the object.
-
-  ```javascript
-  // filters array will be shared amongst any object implementing mixin
-  import Mixin from '@ember/object/mixin';
-  import { A } from '@ember/array';
-
-  const FilterableMixin = Mixin.create({
-    filters: A()
-  });
-  ```
-
-  ```javascript
-  import Mixin from '@ember/object/mixin';
-  import { A } from '@ember/array';
-  import { computed } from '@ember/object';
-
-  // filters will be a separate array for every object implementing the mixin
-  const FilterableMixin = Mixin.create({
-    filters: computed(function() {
-      return A();
-    })
-  });
-  ```
-
-  ```javascript
-  import Mixin from '@ember/object/mixin';
-  import { A } from '@ember/array';
-
-  // filters will be created as a separate array during the object's initialization
-  const Filterable = Mixin.create({
-    filters: null,
-
-    init() {
-      this._super(...arguments);
-      this.set("filters", A());
-    }
-  });
-  ```
-
-  @class Mixin
-  @public
-*/
-
-class Mixin {
-  /** @internal */
-  constructor(mixins, properties) {
-    MIXINS.add(this);
-    this.properties = extractAccessors(properties);
-    this.mixins = buildMixinsArray(mixins);
-    this.ownerConstructor = undefined;
-    this._without = undefined;
-
-    if (DEBUG) {
-      // Eagerly add INIT_FACTORY to avoid issues in DEBUG as a result of Object.seal(mixin)
-      this[INIT_FACTORY] = null;
-      /*
-        In debug builds, we seal mixins to help avoid performance pitfalls.
-               In IE11 there is a quirk that prevents sealed objects from being added
-        to a WeakMap. Unfortunately, the mixin system currently relies on
-        weak maps in `guidFor`, so we need to prime the guid cache weak map.
-      */
-
-      guidFor(this);
-
-      if (Mixin._disableDebugSeal !== true) {
-        Object.seal(this);
-      }
-    }
-  }
-  /**
-    @method create
-    @for @ember/object/mixin
-    @static
-    @param arguments*
-    @public
-  */
-
-
-  static create(...args) {
-    setUnprocessedMixins();
-    let M = this;
-    return new M(args, undefined);
-  } // returns the mixins currently applied to the specified object
-  // TODO: Make `mixin`
-
-  /** @internal */
-
-
-  static mixins(obj) {
-    let meta$$1 = peekMeta(obj);
-    let ret = [];
-
-    if (meta$$1 === null) {
-      return ret;
-    }
-
-    meta$$1.forEachMixins(currentMixin => {
-      // skip primitive mixins since these are always anonymous
-      if (!currentMixin.properties) {
-        ret.push(currentMixin);
-      }
-    });
-    return ret;
-  }
-  /**
-    @method reopen
-    @param arguments*
-    @private
-    @internal
-  */
-
-
-  reopen(...args) {
-    if (args.length === 0) {
-      return;
-    }
-
-    if (this.properties) {
-      let currentMixin = new Mixin(undefined, this.properties);
-      this.properties = undefined;
-      this.mixins = [currentMixin];
-    } else if (!this.mixins) {
-      this.mixins = [];
-    }
-
-    this.mixins = this.mixins.concat(buildMixinsArray(args));
-    return this;
-  }
-  /**
-    @method apply
-    @param obj
-    @return applied object
-    @private
-    @internal
-  */
-
-
-  apply(obj, _hideKeys = false) {
-    // Ember.NativeArray is a normal Ember.Mixin that we mix into `Array.prototype` when prototype extensions are enabled
-    // mutating a native object prototype like this should _not_ result in enumerable properties being added (or we have significant
-    // issues with things like deep equality checks from test frameworks, or things like jQuery.extend(true, [], [])).
-    //
-    // _hideKeys disables enumerablity when applying the mixin. This is a hack, and we should stop mutating the array prototype by default 😫
-    return applyMixin(obj, [this], _hideKeys);
-  }
-  /** @internal */
-
-
-  applyPartial(obj) {
-    return applyMixin(obj, [this]);
-  }
-  /**
-    @method detect
-    @param obj
-    @return {Boolean}
-    @private
-    @internal
-  */
-
-
-  detect(obj) {
-    if (typeof obj !== 'object' || obj === null) {
-      return false;
-    }
-
-    if (MIXINS.has(obj)) {
-      return _detect(obj, this);
-    }
-
-    let meta$$1 = peekMeta(obj);
-
-    if (meta$$1 === null) {
-      return false;
+      this._registry.splice(index, 0, {
+        name,
+        version
+      });
+    } else {
+      warn(`Library "${name}" is already registered with Ember.`, false, {
+        id: 'ember-metal.libraries-register'
+      });
     }
-
-    return meta$$1.hasMixin(this);
   }
-  /** @internal */
 
-
-  without(...args) {
-    let ret = new Mixin([this]);
-    ret._without = args;
-    return ret;
+  registerCoreLibrary(name, version) {
+    this.register(name, version, true);
   }
-  /** @internal */
-
 
-  keys() {
-    let keys = _keys(this);
+  deRegister(name) {
+    let lib = this._getLibraryByName(name);
 
-    assert('[BUG] Missing keys for mixin!', keys);
-    return keys;
-  }
-  /** @internal */
+    let index;
 
+    if (lib) {
+      index = this._registry.indexOf(lib);
 
-  toString() {
-    return '(unknown mixin)';
+      this._registry.splice(index, 1);
+    }
   }
 
 }
 
 if (DEBUG) {
-  Object.defineProperty(Mixin, '_disableDebugSeal', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: false
-  });
-}
-
-function buildMixinsArray(mixins) {
-  let length = mixins && mixins.length || 0;
-  let m = undefined;
-
-  if (length > 0) {
-    m = new Array(length);
-
-    for (let i = 0; i < length; i++) {
-      let x = mixins[i];
-      assert(`Expected hash or Mixin instance, got ${Object.prototype.toString.call(x)}`, typeof x === 'object' && x !== null && Object.prototype.toString.call(x) !== '[object Array]');
+  Libraries.prototype.logVersions = function () {
+    let libs = this._registry;
+    let nameLengths = libs.map(item => get(item, 'name.length'));
+    assert('nameLengths is number array', nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number'));
+    let maxNameLength = Math.max.apply(null, nameLengths);
+    debug('-------------------------------');
 
-      if (MIXINS.has(x)) {
-        m[i] = x;
-      } else {
-        m[i] = new Mixin(undefined, x);
-      }
+    for (let lib of libs) {
+      let spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
+      debug([lib.name, spaces, ' : ', lib.version].join(''));
     }
-  }
-
-  return m;
-}
 
-if (DEBUG) {
-  Object.seal(Mixin.prototype);
+    debug('-------------------------------');
+  };
 }
 
-function _detect(curMixin, targetMixin, seen = new Set()) {
-  if (seen.has(curMixin)) {
-    return false;
-  }
+const LIBRARIES = new Libraries();
+LIBRARIES.registerCoreLibrary('Ember', VERSION);
 
-  seen.add(curMixin);
+function getProperties(obj, keys) {
+  let ret = {};
+  let propertyNames;
+  let i = 1;
 
-  if (curMixin === targetMixin) {
-    return true;
+  if (arguments.length === 2 && Array.isArray(keys)) {
+    i = 0;
+    propertyNames = arguments[1];
+  } else {
+    propertyNames = Array.from(arguments);
   }
 
-  let mixins = curMixin.mixins;
-
-  if (mixins) {
-    return mixins.some(mixin => _detect(mixin, targetMixin, seen));
+  for (; i < propertyNames.length; i++) {
+    ret[propertyNames[i]] = get(obj, propertyNames[i]);
   }
 
-  return false;
+  return ret;
 }
 
-function _keys(mixin, ret = new Set(), seen = new Set()) {
-  if (seen.has(mixin)) {
-    return;
-  }
-
-  seen.add(mixin);
-
-  if (mixin.properties) {
-    let props = Object.keys(mixin.properties);
-
-    for (let prop of props) {
-      ret.add(prop);
-    }
-  } else if (mixin.mixins) {
-    mixin.mixins.forEach(x => _keys(x, ret, seen));
-  }
+/**
+ @module @ember/object
+*/
 
-  return ret;
-}
 /**
-  Specify a method that observes property changes.
+  Set a list of properties on an object. These properties are set inside
+  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+  observers will be buffered.
 
   ```javascript
   import EmberObject from '@ember/object';
-  import { observer } from '@ember/object';
+  let anObject = EmberObject.create();
 
-  export default EmberObject.extend({
-    valueObserver: observer('value', function() {
-      // Executes whenever the "value" property changes
-    })
+  anObject.setProperties({
+    firstName: 'Stanley',
+    lastName: 'Stuart',
+    age: 21
   });
   ```
 
-  Also available as `Function.prototype.observes` if prototype extensions are
-  enabled.
-
-  @method observer
+  @method setProperties
+  @static
   @for @ember/object
-  @param {String} propertyNames*
-  @param {Function} func
-  @return func
+  @param obj
+  @param {Object} properties
+  @return properties
   @public
-  @static
 */
 
-
-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);
-  let func;
-  let dependentKeys;
-  let sync;
-
-  if (typeof funcOrDef === 'function') {
-    func = funcOrDef;
-    dependentKeys = args;
-    sync = !ENV._DEFAULT_ASYNC_OBSERVERS;
-  } else {
-    func = funcOrDef.fn;
-    dependentKeys = funcOrDef.dependentKeys;
-    sync = funcOrDef.sync;
+function setProperties(obj, properties) {
+  if (properties === null || typeof properties !== 'object') {
+    return properties;
   }
 
-  assert('observer called without a function', typeof func === 'function');
-  assert('observer called without valid path', Array.isArray(dependentKeys) && dependentKeys.length > 0 && dependentKeys.every(p => typeof p === 'string' && Boolean(p.length)));
-  assert('observer called without sync', typeof sync === 'boolean');
-  let paths = [];
-
-  for (let dependentKey of dependentKeys) {
-    expandProperties(dependentKey, path => paths.push(path));
-  }
+  changeProperties(() => {
+    let props = Object.keys(properties);
 
-  setObservers(func, {
-    paths,
-    sync
+    for (let propertyName of props) {
+      set(obj, propertyName, properties[propertyName]);
+    }
   });
-  return func;
+  return properties;
 }
 
 let DEBUG_INJECTION_FUNCTIONS;
@@ -3598,4 +2573,149 @@ function throwCachedInvalidArgsError(args = []) {
   @public
 */
 
-export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, hasUnknownProperty, 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, cached, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+let searchDisabled = false;
+const flags = {
+  _set: 0,
+  _unprocessedNamespaces: false,
+
+  get unprocessedNamespaces() {
+    return this._unprocessedNamespaces;
+  },
+
+  set unprocessedNamespaces(v) {
+    this._set++;
+    this._unprocessedNamespaces = v;
+  }
+
+};
+let unprocessedMixins = false;
+const NAMESPACES = [];
+const NAMESPACES_BY_ID = Object.create(null);
+function addNamespace(namespace) {
+  flags.unprocessedNamespaces = true;
+  NAMESPACES.push(namespace);
+}
+function removeNamespace(namespace) {
+  let name = getName(namespace);
+  delete NAMESPACES_BY_ID[name];
+  NAMESPACES.splice(NAMESPACES.indexOf(namespace), 1);
+
+  if (name in context.lookup && namespace === context.lookup[name]) {
+    context.lookup[name] = undefined;
+  }
+}
+function findNamespaces() {
+  if (!flags.unprocessedNamespaces) {
+    return;
+  }
+
+  let lookup = context.lookup;
+  let keys = Object.keys(lookup);
+
+  for (let key of keys) {
+    // Only process entities that start with uppercase A-Z
+    if (!isUppercase(key.charCodeAt(0))) {
+      continue;
+    }
+
+    let obj = tryIsNamespace(lookup, key);
+
+    if (obj) {
+      setName(obj, key);
+    }
+  }
+}
+function findNamespace(name) {
+  if (!searchDisabled) {
+    processAllNamespaces();
+  }
+
+  return NAMESPACES_BY_ID[name];
+}
+function processNamespace(namespace) {
+  _processNamespace([namespace.toString()], namespace, new Set());
+}
+function processAllNamespaces() {
+  let unprocessedNamespaces = flags.unprocessedNamespaces;
+
+  if (unprocessedNamespaces) {
+    findNamespaces();
+    flags.unprocessedNamespaces = false;
+  }
+
+  if (unprocessedNamespaces || unprocessedMixins) {
+    let namespaces = NAMESPACES;
+
+    for (let namespace of namespaces) {
+      processNamespace(namespace);
+    }
+
+    unprocessedMixins = false;
+  }
+}
+function isSearchDisabled() {
+  return searchDisabled;
+}
+function setSearchDisabled(flag) {
+  searchDisabled = Boolean(flag);
+}
+function setUnprocessedMixins() {
+  unprocessedMixins = true;
+}
+
+function _processNamespace(paths, root, seen) {
+  let idx = paths.length;
+  let id = paths.join('.');
+  NAMESPACES_BY_ID[id] = root;
+  setName(root, id); // Loop over all of the keys in the namespace, looking for classes
+
+  for (let key in root) {
+    if (!hasOwnProperty.call(root, key)) {
+      continue;
+    }
+
+    let obj = root[key]; // If we are processing the `Ember` namespace, for example, the
+    // `paths` will start with `["Ember"]`. Every iteration through
+    // the loop will update the **second** element of this list with
+    // the key, so processing `Ember.View` will make the Array
+    // `['Ember', 'View']`.
+
+    paths[idx] = key; // If we have found an unprocessed class
+
+    if (obj && getName(obj) === void 0) {
+      // Replace the class' `toString` with the dot-separated path
+      setName(obj, paths.join('.')); // Support nested namespaces
+    } else if (obj && isNamespace(obj)) {
+      // Skip aliased namespaces
+      if (seen.has(obj)) {
+        continue;
+      }
+
+      seen.add(obj); // Process the child namespace
+
+      _processNamespace(paths, obj, seen);
+    }
+  }
+
+  paths.length = idx; // cut out last item
+}
+
+function isNamespace(obj) {
+  return obj != null && typeof obj === 'object' && obj.isNamespace;
+}
+
+function isUppercase(code) {
+  return code >= 65 && code <= 90 // A
+  ; // Z
+}
+
+function tryIsNamespace(lookup, prop) {
+  try {
+    let obj = lookup[prop];
+    return (obj !== null && typeof obj === 'object' || typeof obj === 'function') && obj.isNamespace && obj;
+  } catch (e) {// continue
+  }
+}
+
+export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, hasUnknownProperty, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, defineDecorator, defineValue, ComputedDescriptor, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, makeComputedDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, revalidateObservers, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, cached, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, setUnprocessedMixins };