.......................................................... COMPUTED PROPERTY  
@class ComputedProperty
@namespace Ember
@extends Ember.Descriptor
@constructor
12445
function ComputedProperty(func, opts) {
  this.func = func;

  this._cacheable = (opts && opts.cacheable !== undefined) ? opts.cacheable : true;
  this._dependentKeys = opts && opts.dependentKeys;
  this._readOnly = opts && (opts.readOnly !== undefined || !!opts.readOnly);
}
408635
function define(obj, key, val) {
  Reflect.defineProperty(obj, key, {
    configurable: true,
    enumerable: false,
    writeable: true,
    value: val
  });
}
111045
function(prop, val) {
                    if (this._computedBindings[prop]) {
                        this[prop](val);
                    } else {
                        this._data[prop] = val;
                    }
                    // Add property directly for easy writing.
                    // Check if its on the `prototype` so we don't overwrite methods like `attrs`.
                    if (!can.isFunction(this.constructor.prototype[prop]) && !this._computedBindings[prop]) {
                        this[prop] = val;
                    }
                }
800371
function defineProperties(obj, props) {
        props = angular.copy(props);
        angular.forEach(props, function (prop) {
          if (!('writable' in prop)) prop.writable = true;
        });
        Object.defineProperties(obj, props);
      }
615355
function Model(defaults){

    // Make sure "new" is always used,
    // so we can use "instanceof" to check if something is a Model.
    if (!(this instanceof Model)) {
      return new Model(defaults);
    }

    // `model` is the public API object returned from invoking `new Model()`.
    var model = this,

        // The internal stored values for tracked properties. { property -> value }
        values = {},

        // The callback functions for each tracked property. { property -> [callback] }
        listeners = {},

        // The set of tracked properties. { property -> true }
        trackedProperties = {};

    // The functional reactive "when" operator.
    //
    //  * `properties` An array of property names (can also be a single property string).
    //  * `callback` A callback function that is called:
    //    * with property values as arguments, ordered corresponding to the properties array,
    //    * only if all specified properties have values,
    //    * once for initialization,
    //    * whenever one or more specified properties change,
    //    * on the next tick of the JavaScript event loop after properties change,
    //    * only once as a result of one or more synchronous changes to dependency properties.
    function when(properties, callback, thisArg){
      
      // Make sure the default `this` becomes 
      // the object you called `.on` on.
      thisArg = thisArg || this;

      // Handle either an array or a single string.
      properties = (properties instanceof Array) ? properties : [properties];

      // This function will trigger the callback to be invoked.
      var listener = debounce(function (){
        var args = properties.map(function(property){
          return values[property];
        });
        if(allAreDefined(args)){
          callback.apply(thisArg, args);
        }
      });

      // Trigger the callback once for initialization.
      listener();
      
      // Trigger the callback whenever specified properties change.
      properties.forEach(function(property){
        on(property, listener);
      });

      // Return this function so it can be removed later with `model.cancel(listener)`.
      return listener;
    }

    // Adds a change listener for a given property with Backbone-like behavior.
    // Similar to http://backbonejs.org/#Events-on
    function on(property, callback, thisArg){
      thisArg = thisArg || this;
      getListeners(property).push(callback);
      track(property, thisArg);
    }
    
    // Gets or creates the array of listener functions for a given property.
    function getListeners(property){
      return listeners[property] || (listeners[property] = []);
    }

    // Tracks a property if it is not already tracked.
    function track(property, thisArg){
      if(!(property in trackedProperties)){
        trackedProperties[property] = true;
        values[property] = model[property];
        Object.defineProperty(model, property, {
          get: function () { return values[property]; },
          set: function(newValue) {
            var oldValue = values[property];
            values[property] = newValue;
            getListeners(property).forEach(function(callback){
              callback.call(thisArg, newValue, oldValue);
            });
          }
        });
      }
    }

    // Cancels a listener returned by a call to `model.when(...)`.
    function cancel(listener){
      for(var property in listeners){
        off(property, listener);
      }
    }

    // Removes a change listener added using `on`.
    function off(property, callback){
      listeners[property] = listeners[property].filter(function (listener) {
        return listener !== callback;
      });
    }

    // Sets all of the given values on the model.
    // `newValues` is an object { property -> value }.
    function set(newValues){
      for(var property in newValues){
        model[property] = newValues[property];
      }
    }

    // Transfer defaults passed into the constructor to the model.
    set(defaults);

    // Public API.
    model.when = when;
    model.cancel = cancel;
    model.on = on;
    model.off = off;
    model.set = set;
  }
697169
function (property) {
      var view = _emberMetalProperty_get.get(this, 'parentView');

      while (view) {
        if (property in view) {
          return view;
        }
        view = _emberMetalProperty_get.get(view, 'parentView');
      }
    }
879860
function getProperties(model) {
    const modelName = model.constructor.name;
    const properties = typed_conversions_1.hashToArray(exports.propertiesByModel[modelName], "property") || [];
    let parent = Object.getPrototypeOf(model.constructor);
    while (parent.name) {
        const subClass = new parent();
        const subClassName = subClass.constructor.name;
        properties.push(...typed_conversions_1.hashToArray(exports.propertiesByModel[subClassName], "property"));
        parent = Object.getPrototypeOf(subClass.constructor);
    }
    return properties;
}
865967
function(elem, prop, delta, getter, setter) {
          var from = elem[getter](prop, 'start');
          var to = elem[getter](prop, 'end');
          elem[setter](prop, this.compute(from, to, delta));
        }
360901
function(name, object, property) {
        var method = this.createMethod(name, property);
        object[method.name] = method.body;
    }
74654
function proxyProperty(proto, property, type) {
    let desc = {};
    if (type === 0) {
        desc.value = function(...args) {
            checkNode.call(this);
            return this.node[property].call(this.node, ...args);
        };
    } else if (type > 0) {
        desc.get = function() {
            checkNode.call(this);
            return this.node[property];
        };
        if (type > 1) {
            desc.set = function(val) {
                checkNode.call(this);
                return this.node[property] = val;
            };
        }
    }
    Object.defineProperty(proto, property, desc);
}
1322947
function castProperty(type, value) {
  // Some special handling is needed for some properties as they may be delivered
  // as strings HTML delivers attributes as strings.
  switch (type) {
    // Translate strings into booleans
    case Boolean:
      if (['false', '0', 'null', 'undefined'].indexOf(value) !== -1) {
        return false;
      } else {
        return Boolean(value);
      }

    case Number:
      return Number(value);

    // Translate strings into functions
    case Function:
      /* eslint-disable-next-line */
      return typeof value === 'string' ? eval('(' + value + ')') : value;
    case Object:
      if (value && typeof value === 'string') {
        try {
          return JSON.parse(value);
        } catch (e) {
          // no-op
        }
      }
  }
  return value;
}
1068052
function(name, val, desc){
        if (this.negate && undefined !== val) {
            if (undefined === this.obj[name]) {
                throw new Error(this.inspect + ' has no property ' + i(name) + (desc ? " | " + desc : ""));
            }
        } else {
            this.assert(
                undefined !== this.obj[name]
                , function(){ return 'expected ' + this.inspect + ' to have a property ' + i(name) + (desc ? " | " + desc : "") }
                , function(){ return 'expected ' + this.inspect + ' to not have a property ' + i(name) + (desc ? " | " + desc : "") });
        }

        if (undefined !== val) {
            this.assert(
                val === this.obj[name]
                , function(){ return 'expected ' + this.inspect + ' to have a property ' + i(name)
                    + ' of ' + i(val) + ', but got ' + i(this.obj[name]) + (desc ? " | " + desc : "") }
                , function(){ return 'expected ' + this.inspect + ' to not have a property ' + i(name) + ' of ' + i(val) + (desc ? " | " + desc : "") });
        }

        this.obj = this.obj[name];
        return this;
    }
296364
function(property) {
    var prop = $.splat(property || [ 'current', 'start', 'end' ]);
    NodeDim.compute(this.graph, prop, this.config);
    this.graph.computeLevels(this.root, 0, "ignore");
    var lengthFunc = this.createLevelDistanceFunc(); 
    this.computeAngularWidths(prop);
    this.computePositions(prop, lengthFunc);
  }
281584
function(def, withArray) {
    def = def ? def : _.result(this, 'definition');

    return _.reduce(def, function(defaults, attr, key) {
      if (attr.computed) {
        return defaults;
      }
      if (attr.default !== undefined) {
        defaults[key] = _.result(attr, 'default');
      } else if (attr.type === 'object') {
        defaults[key] = this.defaults(attr.fields || {});
      } else if (attr.type === 'array') {
        // withArray to populate nested array values for _validateAttributes
        defaults[key] = withArray ? [this.defaults(attr.fields || {})] : [];
      } else {
        defaults[key] = this._defaultVal(attr.type);
      }
      return defaults;
    }.bind(this), {});
  }
1128705
private void visitNonMethodMember(Node member, ClassDeclarationMetadata metadata) {
    if (member.isComputedProp() && member.isStaticMember()) {
      cannotConvertYet(compiler, member, "Static computed property");
      return;
    }
    if (member.isComputedProp() && !member.getFirstChild().isQualifiedName()) {
      cannotConvert(
          compiler, member.getFirstChild(), "Computed property with non-qualified-name key");
      return;
    }

    JSTypeExpression typeExpr = getTypeFromGetterOrSetter(member);
    addToDefinePropertiesObject(metadata, member);

    Map<String, ClassProperty> membersToDeclare =
        member.isStaticMember()
            ? metadata.getClassMembersToDeclare()
            : metadata.getPrototypeMembersToDeclare();
    ClassProperty.Builder builder = ClassProperty.builder();
    String memberName;

    if (member.isComputedProp()) {
      checkState(!member.isStaticMember());
      memberName = member.getFirstChild().getQualifiedName();
      builder.kind(ClassProperty.PropertyKind.COMPUTED_PROPERTY);
    } else if (member.isQuotedString()) {
      memberName = member.getString();
      builder.kind(ClassProperty.PropertyKind.QUOTED_PROPERTY);
    } else {
      memberName = member.getString();
      builder.kind(ClassProperty.PropertyKind.NORMAL_PROPERTY);
    }

    builder.propertyKey(memberName);
    ClassProperty existingProperty = membersToDeclare.get(memberName);
    JSTypeExpression existingType =
        existingProperty == null ? null : existingProperty.jsDocInfo().getType();
    if (existingProperty != null && typeExpr != null && !existingType.equals(typeExpr)) {
      compiler.report(JSError.make(member, CONFLICTING_GETTER_SETTER_TYPE, memberName));
    } else {
      JSDocInfoBuilder jsDoc = new JSDocInfoBuilder(false);
      if (member.getJSDocInfo() != null && member.getJSDocInfo().isExport()) {
        jsDoc.recordExport();
        jsDoc.recordVisibility(Visibility.PUBLIC);
      }
      if (member.getJSDocInfo() != null && member.getJSDocInfo().isOverride()) {
        jsDoc.recordOverride();
      } else if (typeExpr == null) {
        typeExpr = new JSTypeExpression(new Node(Token.QMARK), member.getSourceFileName());
      }
      if (typeExpr != null) {
        jsDoc.recordType(typeExpr.copy());
      }
      if (member.isStaticMember() && !member.isComputedProp()) {
        jsDoc.recordNoCollapse();
      }
      builder.jsDocInfo(jsDoc.build());
      membersToDeclare.put(memberName, builder.build());
    }
  }
128976
function (prop, val) {
            this._data[prop] = val;
            // Add property directly for easy writing.
            // Check if its on the `prototype` so we don't overwrite methods like `attrs`.
            if (!(prop in this.constructor.prototype)) {
                this[prop] = val
            }
        }
501732
function css(elm, property, value) {
        if (arguments.length < 3) {
            var computedStyle,
                computedStyle = getComputedStyle(elm, '')
            if (langx.isString(property)) {
                return elm.style[camelCase(property)] || computedStyle.getPropertyValue(dasherize(property))
            } else if (langx.isArrayLike(property)) {
                var props = {}
                forEach.call(property, function(prop) {
                    props[prop] = (elm.style[camelCase(prop)] || computedStyle.getPropertyValue(dasherize(prop)))
                })
                return props
            }
        }

        var css = '';
        if (typeof(property) == 'string') {
            if (!value && value !== 0) {
                elm.style.removeProperty(dasherize(property));
            } else {
                css = dasherize(property) + ":" + maybeAddPx(property, value)
            }
        } else {
            for (key in property) {
                if (property[key] === undefined) {
                    continue;
                }
                if (!property[key] && property[key] !== 0) {
                    elm.style.removeProperty(dasherize(key));
                } else {
                    css += dasherize(key) + ':' + maybeAddPx(key, property[key]) + ';'
                }
            }
        }

        elm.style.cssText += ';' + css;
        return this;
    }