discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-metal/lib/expand_properties.js

@@ -1,64 +0,0 @@
-import { assert } from '@ember/debug';
-/**
-@module @ember/object
-*/
-const END_WITH_EACH_REGEX = /\.@each$/;
-/**
-  Expands `pattern`, invoking `callback` for each expansion.
-
-  The only pattern supported is brace-expansion, anything else will be passed
-  once to `callback` directly.
-
-  Example
-
-  ```js
-  import { expandProperties } from '@ember/object/computed';
-
-  function echo(arg){ console.log(arg); }
-
-  expandProperties('foo.bar', echo);              //=> 'foo.bar'
-  expandProperties('{foo,bar}', echo);            //=> 'foo', 'bar'
-  expandProperties('foo.{bar,baz}', echo);        //=> 'foo.bar', 'foo.baz'
-  expandProperties('{foo,bar}.baz', echo);        //=> 'foo.baz', 'bar.baz'
-  expandProperties('foo.{bar,baz}.[]', echo)      //=> 'foo.bar.[]', 'foo.baz.[]'
-  expandProperties('{foo,bar}.{spam,eggs}', echo) //=> 'foo.spam', 'foo.eggs', 'bar.spam', 'bar.eggs'
-  expandProperties('{foo}.bar.{baz}')             //=> 'foo.bar.baz'
-  ```
-
-  @method expandProperties
-  @static
-  @for @ember/object/computed
-  @public
-  @param {String} pattern The property pattern to expand.
-  @param {Function} callback The callback to invoke.  It is invoked once per
-  expansion, and is passed the expansion.
-*/
-export default function expandProperties(pattern, callback) {
-    assert(`A computed property key must be a string, you passed ${typeof pattern} ${pattern}`, typeof pattern === 'string');
-    assert('Brace expanded properties cannot contain spaces, e.g. "user.{firstName, lastName}" should be "user.{firstName,lastName}"', pattern.indexOf(' ') === -1);
-    // regex to look for double open, double close, or unclosed braces
-    assert(`Brace expanded properties have to be balanced and cannot be nested, pattern: ${pattern}`, pattern.match(/\{[^}{]*\{|\}[^}{]*\}|\{[^}]*$/g) === null);
-    let start = pattern.indexOf('{');
-    if (start < 0) {
-        callback(pattern.replace(END_WITH_EACH_REGEX, '.[]'));
-    }
-    else {
-        dive('', pattern, start, callback);
-    }
-}
-function dive(prefix, pattern, start, callback) {
-    let end = pattern.indexOf('}'), i = 0, newStart, arrayLength;
-    let tempArr = pattern.substring(start + 1, end).split(',');
-    let after = pattern.substring(end + 1);
-    prefix = prefix + pattern.substring(0, start);
-    arrayLength = tempArr.length;
-    while (i < arrayLength) {
-        newStart = after.indexOf('{');
-        if (newStart < 0) {
-            callback((prefix + tempArr[i++] + after).replace(END_WITH_EACH_REGEX, '.[]'));
-        }
-        else {
-            dive(prefix + tempArr[i++], after, newStart, callback);
-        }
-    }
-}

data/dist/es/ember-metal/lib/get_properties.js

@@ -1,45 +0,0 @@
-import { get } from './property_get';
-/**
- @module @ember/object
-*/
-/**
-  To get multiple properties at once, call `getProperties`
-  with an object followed by a list of strings or an array:
-
-  ```javascript
-  import { getProperties } from '@ember/object';
-
-  getProperties(record, 'firstName', 'lastName', 'zipCode');
-  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-  ```
-
-  is equivalent to:
-
-  ```javascript
-  import { getProperties } from '@ember/object';
-
-  getProperties(record, ['firstName', 'lastName', 'zipCode']);
-  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-  ```
-
-  @method getProperties
-  @static
-  @for @ember/object
-  @param {Object} obj
-  @param {String...|Array} list of keys to get
-  @return {Object}
-  @public
-*/
-export default function getProperties(obj) {
-    let ret = {};
-    let propertyNames = arguments;
-    let i = 1;
-    if (arguments.length === 2 && Array.isArray(arguments[1])) {
-        i = 0;
-        propertyNames = arguments[1];
-    }
-    for (; i < propertyNames.length; i++) {
-        ret[propertyNames[i]] = get(obj, propertyNames[i]);
-    }
-    return ret;
-}

data/dist/es/ember-metal/lib/injected_property.js

@@ -1,53 +0,0 @@
-import { EMBER_MODULE_UNIFICATION } from '@ember/canary-features';
-import { assert } from '@ember/debug';
-import { descriptorFor } from 'ember-meta';
-import { getOwner } from 'ember-owner';
-import { ComputedProperty } from './computed';
-/**
- @module ember
- @private
- */
-/**
-  Read-only property that returns the result of a container lookup.
-
-  @class InjectedProperty
-  @namespace Ember
-  @constructor
-  @param {String} type The container type the property will lookup
-  @param {String} name (optional) The name the property will lookup, defaults
-         to the property's name
-  @private
-*/
-export default class InjectedProperty extends ComputedProperty {
-    constructor(type, name, options) {
-        super(injectedPropertyGet);
-        this.type = type;
-        this.name = name;
-        if (EMBER_MODULE_UNIFICATION) {
-            this.source = options ? options.source : undefined;
-            this.namespace = undefined;
-            if (name) {
-                let namespaceDelimiterOffset = name.indexOf('::');
-                if (namespaceDelimiterOffset === -1) {
-                    this.name = name;
-                    this.namespace = undefined;
-                }
-                else {
-                    this.name = name.slice(namespaceDelimiterOffset + 2);
-                    this.namespace = name.slice(0, namespaceDelimiterOffset);
-                }
-            }
-        }
-    }
-}
-function injectedPropertyGet(keyName) {
-    let desc = descriptorFor(this, keyName);
-    let owner = getOwner(this) || this.container; // fallback to `container` for backwards compat
-    assert(`InjectedProperties should be defined with the inject computed property macros.`, desc && desc.type);
-    assert(`Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container.`, !!owner);
-    let specifier = `${desc.type}:${desc.name || keyName}`;
-    return owner.lookup(specifier, {
-        source: desc.source,
-        namespace: desc.namespace,
-    });
-}

data/dist/es/ember-metal/lib/is_blank.js

@@ -1,34 +0,0 @@
-import isEmpty from './is_empty';
-/**
- @module @ember/utils
-*/
-/**
-  A value is blank if it is empty or a whitespace string.
-
-  ```javascript
-  import { isBlank } from '@ember/utils';
-
-  isBlank();                // true
-  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
-*/
-export default function isBlank(obj) {
-    return isEmpty(obj) || (typeof obj === 'string' && /\S/.test(obj) === false);
-}

data/dist/es/ember-metal/lib/is_empty.js

@@ -1,63 +0,0 @@
-import { get } from './property_get';
-/**
- @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();                 // true
-  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
-*/
-export default function isEmpty(obj) {
-    let none = obj === null || obj === undefined;
-    if (none) {
-        return none;
-    }
-    if (typeof obj.size === 'number') {
-        return !obj.size;
-    }
-    let objectType = typeof obj;
-    if (objectType === 'object') {
-        let size = get(obj, 'size');
-        if (typeof size === 'number') {
-            return !size;
-        }
-    }
-    if (typeof obj.length === 'number' && objectType !== 'function') {
-        return !obj.length;
-    }
-    if (objectType === 'object') {
-        let length = get(obj, 'length');
-        if (typeof length === 'number') {
-            return !length;
-        }
-    }
-    return false;
-}

data/dist/es/ember-metal/lib/is_none.js

@@ -1,27 +0,0 @@
-/**
- @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();              // true
-  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
-*/
-export default function isNone(obj) {
-    return obj === null || obj === undefined;
-}

data/dist/es/ember-metal/lib/is_present.js

@@ -1,38 +0,0 @@
-import isBlank from './is_blank';
-/**
- @module @ember/utils
-*/
-/**
-  A value is present if it not `isBlank`.
-
-  ```javascript
-  isPresent();                // false
-  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(false);           // 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
-*/
-export default function isPresent(obj) {
-    return !isBlank(obj);
-}

data/dist/es/ember-metal/lib/libraries.js

@@ -1,80 +0,0 @@
-import { EMBER_LIBRARIES_ISREGISTERED } from '@ember/canary-features';
-import { debug, warn } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
-import VERSION from 'ember/version';
-import { get } from './property_get';
-/**
- @module ember
-*/
-/**
-  Helper class that allows you to register your library with Ember.
-
-  Singleton created at `Ember.libraries`.
-
-  @class Libraries
-  @constructor
-  @private
-*/
-export class Libraries {
-    constructor() {
-        this._registry = [];
-        this._coreLibIndex = 0;
-    }
-    _getLibraryByName(name) {
-        let libs = this._registry;
-        let count = libs.length;
-        for (let i = 0; i < count; i++) {
-            if (libs[i].name === name) {
-                return libs[i];
-            }
-        }
-        return undefined;
-    }
-    register(name, version, isCoreLibrary) {
-        let index = this._registry.length;
-        if (!this._getLibraryByName(name)) {
-            if (isCoreLibrary) {
-                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 (EMBER_LIBRARIES_ISREGISTERED) {
-    Libraries.prototype.isRegistered = function (name) {
-        return !!this._getLibraryByName(name);
-    };
-}
-if (DEBUG) {
-    Libraries.prototype.logVersions = function () {
-        let libs = this._registry;
-        let nameLengths = libs.map(item => get(item, 'name.length'));
-        let maxNameLength = Math.max.apply(null, nameLengths);
-        debug('-------------------------------');
-        for (let i = 0; i < libs.length; i++) {
-            let lib = libs[i];
-            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);
-export default LIBRARIES;

data/dist/es/ember-metal/lib/mixin.js

@@ -1,646 +0,0 @@
-/**
-@module @ember/object
-*/
-import { assert } from '@ember/debug';
-import { BINDING_SUPPORT } from '@ember/deprecated-features';
-import { assign } from '@ember/polyfills';
-import { DEBUG } from '@glimmer/env';
-import { ENV } from 'ember-environment';
-import { descriptorFor, meta as metaFor, peekMeta } from 'ember-meta';
-import { getListeners, getObservers, guidFor, makeArray, NAME_KEY, ROOT, setObservers, wrap, } from 'ember-utils';
-import { ComputedProperty } from './computed';
-import { addListener, removeListener } from './events';
-import expandProperties from './expand_properties';
-import { classToString, setUnprocessedMixins } from './namespace_search';
-import { addObserver, removeObserver } from './observer';
-import { defineProperty, Descriptor } from './properties';
-const a_concat = Array.prototype.concat;
-const { isArray } = Array;
-function isMethod(obj) {
-    return ('function' === typeof obj &&
-        obj.isMethod !== false &&
-        obj !== Boolean &&
-        obj !== Object &&
-        obj !== Number &&
-        obj !== Array &&
-        obj !== Date &&
-        obj !== String);
-}
-const CONTINUE = {};
-function mixinProperties(mixinsMeta, mixin) {
-    if (mixin instanceof Mixin) {
-        if (mixinsMeta.hasMixin(mixin)) {
-            return CONTINUE;
-        }
-        mixinsMeta.addMixin(mixin);
-        return mixin.properties;
-    }
-    else {
-        return mixin; // apply anonymous mixin 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 giveDescriptorSuper(meta, key, property, values, descs, base) {
-    let superProperty;
-    // Computed properties override methods, and do not call super to them
-    if (values[key] === undefined) {
-        // Find the original descriptor in a parent mixin
-        superProperty = descs[key];
-    }
-    // If we didn't find the original descriptor in a parent mixin, find
-    // it on the original object.
-    if (!superProperty) {
-        superProperty = descriptorFor(base, key, meta);
-    }
-    if (superProperty === undefined || !(superProperty instanceof ComputedProperty)) {
-        return property;
-    }
-    // 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.
-    property = Object.create(property);
-    property._getter = wrap(property._getter, superProperty._getter);
-    if (superProperty._setter) {
-        if (property._setter) {
-            property._setter = wrap(property._setter, superProperty._setter);
-        }
-        else {
-            property._setter = superProperty._setter;
-        }
-    }
-    return property;
-}
-function giveMethodSuper(obj, 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];
-    // If we didn't find the original value in a parent mixin, find it in
-    // the original object
-    if (superMethod === undefined && descriptorFor(obj, key) === undefined) {
-        superMethod = obj[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(obj, key, value, values) {
-    let baseValue = values[key] || obj[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(obj, key, value, values) {
-    let baseValue = values[key] || obj[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 = assign({}, baseValue);
-    let hasFunction = false;
-    for (let prop in value) {
-        if (!value.hasOwnProperty(prop)) {
-            continue;
-        }
-        let propValue = value[prop];
-        if (isMethod(propValue)) {
-            // TODO: support for Computed Properties, etc?
-            hasFunction = true;
-            newBase[prop] = giveMethodSuper(obj, prop, propValue, baseValue, {});
-        }
-        else {
-            newBase[prop] = propValue;
-        }
-    }
-    if (hasFunction) {
-        newBase._super = ROOT;
-    }
-    return newBase;
-}
-function addNormalizedProperty(base, key, value, meta, descs, values, concats, mergings) {
-    if (value instanceof Descriptor) {
-        // Wrap descriptor function to implement
-        // _super() if needed
-        if (value._getter) {
-            value = giveDescriptorSuper(meta, key, value, values, descs, base);
-        }
-        descs[key] = value;
-        values[key] = undefined;
-    }
-    else {
-        if ((concats && concats.indexOf(key) >= 0) ||
-            key === 'concatenatedProperties' ||
-            key === 'mergedProperties') {
-            value = applyConcatenatedProperties(base, key, value, values);
-        }
-        else if (mergings && mergings.indexOf(key) > -1) {
-            value = applyMergedProperties(base, key, value, values);
-        }
-        else if (isMethod(value)) {
-            value = giveMethodSuper(base, key, value, values, descs);
-        }
-        descs[key] = undefined;
-        values[key] = value;
-    }
-}
-function mergeMixins(mixins, meta, descs, values, base, keys) {
-    let currentMixin, props, key, concats, mergings;
-    function removeKeys(keyName) {
-        delete descs[keyName];
-        delete values[keyName];
-    }
-    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]');
-        props = mixinProperties(meta, currentMixin);
-        if (props === CONTINUE) {
-            continue;
-        }
-        if (props) {
-            // remove willMergeMixin after 3.4 as it was used for _actions
-            if (base.willMergeMixin) {
-                base.willMergeMixin(props);
-            }
-            concats = concatenatedMixinProperties('concatenatedProperties', props, values, base);
-            mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
-            for (key in props) {
-                if (!props.hasOwnProperty(key)) {
-                    continue;
-                }
-                keys.push(key);
-                addNormalizedProperty(base, key, props[key], meta, descs, values, concats, mergings);
-            }
-            // manually copy toString() because some JS engines do not enumerate it
-            if (props.hasOwnProperty('toString')) {
-                base.toString = props.toString;
-            }
-        }
-        else if (currentMixin.mixins) {
-            mergeMixins(currentMixin.mixins, meta, descs, values, base, keys);
-            if (currentMixin._without) {
-                currentMixin._without.forEach(removeKeys);
-            }
-        }
-    }
-}
-function followAlias(obj, desc, descs, values) {
-    let altKey = desc.methodName;
-    let value;
-    let possibleDesc;
-    if (descs[altKey] || values[altKey]) {
-        value = values[altKey];
-        desc = descs[altKey];
-    }
-    else if ((possibleDesc = descriptorFor(obj, altKey)) !== undefined) {
-        desc = possibleDesc;
-        value = undefined;
-    }
-    else {
-        desc = undefined;
-        value = obj[altKey];
-    }
-    return { desc, value };
-}
-function updateObserversAndListeners(obj, key, paths, updateMethod) {
-    if (paths) {
-        for (let i = 0; i < paths.length; i++) {
-            updateMethod(obj, paths[i], null, key);
-        }
-    }
-}
-function replaceObserversAndListeners(obj, key, prev, next) {
-    if (typeof prev === 'function') {
-        updateObserversAndListeners(obj, key, getObservers(prev), removeObserver);
-        updateObserversAndListeners(obj, key, getListeners(prev), removeListener);
-    }
-    if (typeof next === 'function') {
-        updateObserversAndListeners(obj, key, getObservers(next), addObserver);
-        updateObserversAndListeners(obj, key, getListeners(next), addListener);
-    }
-}
-export function applyMixin(obj, mixins, partial) {
-    let descs = {};
-    let values = {};
-    let meta = metaFor(obj);
-    let keys = [];
-    let key, value, desc;
-    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, descs, values, obj, keys);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        if (key === 'constructor' || !values.hasOwnProperty(key)) {
-            continue;
-        }
-        desc = descs[key];
-        value = values[key];
-        while (desc && desc instanceof Alias) {
-            let followed = followAlias(obj, desc, descs, values);
-            desc = followed.desc;
-            value = followed.value;
-        }
-        if (desc === undefined && value === undefined) {
-            continue;
-        }
-        if (descriptorFor(obj, key) !== undefined) {
-            replaceObserversAndListeners(obj, key, null, value);
-        }
-        else {
-            replaceObserversAndListeners(obj, key, obj[key], value);
-        }
-        if (BINDING_SUPPORT &&
-            ENV._ENABLE_BINDING_SUPPORT &&
-            typeof Mixin.detectBinding === 'function' &&
-            Mixin.detectBinding(key)) {
-            meta.writeBindings(key, value);
-        }
-        defineProperty(obj, key, desc, value, meta);
-    }
-    if (BINDING_SUPPORT &&
-        ENV._ENABLE_BINDING_SUPPORT &&
-        !partial &&
-        typeof Mixin.finishPartial === 'function') {
-        Mixin.finishPartial(obj, meta);
-    }
-    return obj;
-}
-/**
-  @method mixin
-  @param obj
-  @param mixins*
-  @return obj
-  @private
-*/
-export function mixin(obj, ...args) {
-    applyMixin(obj, args, false);
-    return obj;
-}
-/**
-  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
-*/
-export default class Mixin {
-    constructor(mixins, properties) {
-        this.properties = properties;
-        this.mixins = buildMixinsArray(mixins);
-        this.ownerConstructor = undefined;
-        this._without = undefined;
-        if (DEBUG) {
-            this[NAME_KEY] = undefined;
-            /*
-              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);
-            Object.seal(this);
-        }
-    }
-    /**
-      @method create
-      @for @ember/object/mixin
-      @static
-      @param arguments*
-      @public
-    */
-    static create(...args) {
-        // ES6TODO: this relies on a global state?
-        setUnprocessedMixins();
-        let M = this;
-        return new M(args, undefined);
-    }
-    // returns the mixins currently applied to the specified object
-    // TODO: Make `mixin`
-    static mixins(obj) {
-        let meta = peekMeta(obj);
-        let ret = [];
-        if (meta === undefined) {
-            return ret;
-        }
-        meta.forEachMixins((currentMixin) => {
-            // skip primitive mixins since these are always anonymous
-            if (!currentMixin.properties) {
-                ret.push(currentMixin);
-            }
-        });
-        return ret;
-    }
-    /**
-      @method reopen
-      @param arguments*
-      @private
-    */
-    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
-    */
-    apply(obj) {
-        return applyMixin(obj, [this], false);
-    }
-    applyPartial(obj) {
-        return applyMixin(obj, [this], true);
-    }
-    /**
-      @method detect
-      @param obj
-      @return {Boolean}
-      @private
-    */
-    detect(obj) {
-        if (typeof obj !== 'object' || obj === null) {
-            return false;
-        }
-        if (obj instanceof Mixin) {
-            return _detect(obj, this);
-        }
-        let meta = peekMeta(obj);
-        if (meta === undefined) {
-            return false;
-        }
-        return meta.hasMixin(this);
-    }
-    without(...args) {
-        let ret = new Mixin([this]);
-        ret._without = args;
-        return ret;
-    }
-    keys() {
-        return _keys(this);
-    }
-    toString() {
-        return '(unknown mixin)';
-    }
-}
-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]');
-            if (x instanceof Mixin) {
-                m[i] = x;
-            }
-            else {
-                m[i] = new Mixin(undefined, x);
-            }
-        }
-    }
-    return m;
-}
-if (BINDING_SUPPORT && ENV._ENABLE_BINDING_SUPPORT) {
-    // slotting this so that the legacy addon can add the function here
-    // without triggering an error due to the Object.seal done below
-    Mixin.finishPartial = null;
-    Mixin.detectBinding = null;
-}
-Mixin.prototype.toString = classToString;
-if (DEBUG) {
-    Mixin.prototype[NAME_KEY] = undefined;
-    Object.seal(Mixin.prototype);
-}
-function _detect(curMixin, targetMixin, seen = new Set()) {
-    if (seen.has(curMixin)) {
-        return false;
-    }
-    seen.add(curMixin);
-    if (curMixin === targetMixin) {
-        return true;
-    }
-    let mixins = curMixin.mixins;
-    if (mixins) {
-        return mixins.some(mixin => _detect(mixin, targetMixin, seen));
-    }
-    return false;
-}
-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 i = 0; i < props.length; i++) {
-            ret.add(props[i]);
-        }
-    }
-    else if (mixin.mixins) {
-        mixin.mixins.forEach((x) => _keys(x, ret, seen));
-    }
-    return ret;
-}
-class Alias extends Descriptor {
-    constructor(methodName) {
-        super();
-        this.methodName = methodName;
-    }
-    teardown(_obj, _keyName, _meta) {
-        throw new Error('Method not implemented.');
-    }
-    get(_obj, _keyName) {
-        throw new Error('Method not implemented.');
-    }
-    set(_obj, _keyName, _value) {
-        throw new Error('Method not implemented.');
-    }
-}
-/**
-  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
-  @for @ember/object
-  @param {String} methodName name of the method to alias
-  @public
-*/
-export function aliasMethod(methodName) {
-    return new Alias(methodName);
-}
-// ..........................................................
-// OBSERVER HELPER
-//
-/**
-  Specify a method that observes property changes.
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  import { observer } from '@ember/object';
-
-  export default EmberObject.extend({
-    valueObserver: observer('value', function() {
-      // Executes whenever the "value" property changes
-    })
-  });
-  ```
-
-  Also available as `Function.prototype.observes` if prototype extensions are
-  enabled.
-
-  @method observer
-  @for @ember/object
-  @param {String} propertyNames*
-  @param {Function} func
-  @return func
-  @public
-  @static
-*/
-export function observer(...args) {
-    let func = args.pop();
-    let _paths = args;
-    assert('observer called without a function', typeof func === 'function');
-    assert('observer called without valid path', _paths.length > 0 && _paths.every(p => typeof p === 'string' && !!p.length));
-    let paths = [];
-    let addWatchedProperty = (path) => paths.push(path);
-    for (let i = 0; i < _paths.length; ++i) {
-        expandProperties(_paths[i], addWatchedProperty);
-    }
-    setObservers(func, paths);
-    return func;
-}
-export { Mixin };