Define getter function on object as a configurable and enumerable property.

@param  {Object} `obj` Object to define property on.
@param  {String} `prop` Property to define.
@param  {Function} `getter` Getter function to define.
4277
function defineProperty(obj, prop, getter) {
  Object.defineProperty(obj, prop, {
    configurable: true,
    enumerable: true,
    get: getter
  });
}
336914
function(object, getters, property) {

        _.each(getters, function(getter, name) {
            object.__addGetter(property, name, getter);
        });
    }
796779
function(obj, propName, message) {	
	assert(typeof(propName) === 'string');
	if ( ! message) message = "Using this property indicates old/broken code.";
	// already blocked?	
	bphush = true;
	try {
		let v = obj[propName];
	} catch (err) {
		return obj;
	}
	bphush = false;
	if (obj[propName] !== undefined) {
		// already set to a value :(
		const ex = new Error("Having "+propName+" is blocked! "+message);
		if ( ! bphush) console.error(ex, this); // react can swallow stuff
		throw ex;
	}
	if ( ! Object.isExtensible(obj)) {	
		// no need -- frozen or sealed	
		return;
	}
	Object.defineProperty(obj, propName, { 
		get: function () { 
			const ex = new Error(propName+" is blocked! "+message); 
			if ( ! bphush) console.error(ex, this); // react can swallow stuff
			throw ex;					
		},
		set: function () { 
			const ex = new Error("Set "+propName+" is blocked! "+message);
			if ( ! bphush) console.error(ex, this); // react can swallow stuff
			throw ex;		
		} 
	});
	return obj;
}
1171600
function Property( field, value, params ) {

  if( !(this instanceof Property) )
    return new Property( value )

  if( params != null )
    Object.assign( this, params )

  this._field = field
  this._data = value

  Object.defineProperty( this, '_field', { enumerable: false })
  Object.defineProperty( this, '_data', { enumerable: false })

}
357253
function() {
			var value = fn( object , property ) ;

			Object.defineProperty( object , property , {
				configurable: true ,
				enumerable: !! enumerable ,
				writable: false ,
				value: value
			} ) ;

			return value ;
		}
22949
function(obj, prop, add) {
                var result = obj[prop];
                if (result === undefined && add === true) {
                    result = obj[prop] = {};
                }
                return result;
            }
873561
function getValue(object, prop) {
  if (!(object && object[prop])) {
    return null;
  }
  return _.isFunction(object[prop]) ? object[prop]() : object[prop];
}
1259143
function(object, property, value, setter) {
      try { object[property] = value; } catch(e) {}

      try { object.__defineGetter__(property, function() { return value; }); } catch(e) {}
      if (setter) {
        try { object.__defineSetter__(property, function() {}); } catch(e) {}
      }

      if (!wysihtml5.browser.crashesWhenDefineProperty(property)) {
        try {
          var config = {
            get: function() { return value; }
          };
          if (setter) {
            config.set = function() {};
          }
          Object.defineProperty(object, property, config);
        } catch(e) {}
      }
    }
930081
function defineComponentGetter(object, key, path, _inner) {
  Object.defineProperty(object, key, {
    enumerable: true,
    get: function() {
      if(typeof _cache[path] === 'undefined') {
        _cache[path] = require(path);
        if(typeof _inner === 'string') {
          _cache[path] = _cache[path][_inner];
        }
      }
      return _cache[path];
    },
    set: function(v) {
      _cache[path] = v;
    }
  });
}
567417
public static void setPropertyEL(Object obj, String prop, Object value) {

	// first check for field
	Field[] fields = getFieldsIgnoreCase(obj.getClass(), prop, null);
	if (!ArrayUtil.isEmpty(fields)) {
	    try {
		fields[0].set(obj, value);
		return;
	    }
	    catch (Throwable t) {
		ExceptionUtil.rethrowIfNecessary(t);
	    }
	}

	// then check for setter
	try {
	    getSetter(obj, prop, value).invoke(obj);
	}
	catch (Throwable t) {
	    ExceptionUtil.rethrowIfNecessary(t);
	}

    }
644159
function preDefine(obj: Object, key: string, val: any) {
  if (key in obj) return
  Object.defineProperty(obj, key, {
    enumerable: false,
    configurable: true,
    writable: true,
    value: val,
  })
}
1317467
function (obj) {
    return {
        getOwnPropertyDescriptor: function (name) {
            var desc = Object.getOwnPropertyDescriptor(obj, name);
            // a trapping proxy's properties must always be configurable
            if (desc !== undefined) {
                desc.configurable = true;
            }
            return desc;
        },
        getPropertyDescriptor: function (name) {
            var desc = Object.getPropertyDescriptor(obj, name); // not in ES5
            // a trapping proxy's properties must always be configurable
            if (desc !== undefined) {
                desc.configurable = true;
            }
            return desc;
        },
        getOwnPropertyNames: function () {
            return Object.getOwnPropertyNames(obj);
        },
        getPropertyNames: function () {
            return Object.getPropertyNames(obj);                // not in ES5
        },
        defineProperty: function (name, desc) {
            Object.defineProperty(obj, name, desc);
        },
        delete: function (name) {
            return delete obj[name];
        },
        fix: function () {
            if (Object.isFrozen(obj)) {
                var result = {};
                Object.getOwnPropertyNames(obj).forEach(function (name) {
                    result[name] = Object.getOwnPropertyDescriptor(obj, name);
                });
                return result;
            }
            // As long as obj is not frozen, the proxy won't allow itself to be fixed
            return undefined; // will cause a TypeError to be thrown
        },

        has: function (name) {
            return name in obj;
        },
        hasOwn: function (name) {
            return ({}).hasOwnProperty.call(obj, name);
        },
        get: function (receiver, name) {
            return obj[name];
        },
        set: function (receiver, name, val) {
            obj[name] = val;
            return true;
        }, // bad behavior when set fails in non-strict mode
        enumerate: function () {
            var result = [];
            for (var name in obj) {
                result.push(name);
            }
            return result;
        },
        keys: function () {
            return Object.keys(obj);
        }

    };
}
293418
function definePropertyHolder(object) {
                let holder = defaultValue;

                Object.defineProperty(object, id, {
                    enumerable: false,
                    configurable: true,
                    get: function getterWrapper() {
                        if (checkIfWrapped(getterWrapper.caller)) {
                            return holder;
                        }
                        throw new ReferenceError(`Access violation for private property: 
                            ${id}`);
                    },
                    set: function setterWrapper(value) {
                        if (checkIfWrapped(setterWrapper.caller)) {
                            holder = value;
                        } else {
                            throw new ReferenceError(`Access violation for private property:
                                 ${id}`);
                        }
                    }
                });
                propertyHolderDefined = true;
            }
326095
function assignProps(obj, key, val, opts) {
	var k;

	// accept object syntax
	if (typeof key === "object") {
		for (k in key) {
			if (hasOwn.call(key, k)) assignProps(obj, k, key[k], val);
		}
		return;
	}

	var desc = {};
	opts = opts || {};

	// build base descriptor
	for (k in defaults) {
		desc[k] = typeof opts[k] === "boolean" ? opts[k] : defaults[k];
	}

	// set descriptor props based on value
	if (!opts.forceStatic && typeof val === "function") {
		desc.get = val;
	} else {
		desc.value = val;
		desc.writable = false;
	}

	// define the property
	Object.defineProperty(obj, key, desc);
}
15835
function (obj, meta) {
    // if `null` already, just set it to the new value
    // otherwise define property first
    if (obj[META_FIELD] !== null) {
      if (obj.__defineNonEnumerable) {
        obj.__defineNonEnumerable(EMBER_META_PROPERTY);
      } else {
        Object.defineProperty(obj, META_FIELD, META_DESC);
      }
    }

    obj[META_FIELD] = meta;
  }
736146
function(object) {
		var name, value, desc, obj = object,
			result = [];
		for (name in object) {
			// make sure that we don't poke any getter type properties...
			while (!(desc = Object.getOwnPropertyDescriptor(obj, name))) {
				obj = Object.getPrototypeOf(obj);
			}
			if (typeof desc.value === 'function') {
				value = object[name];
				if (gui.Type.isMethod(value)) {
					result.push(name);
				}
			}
		}
		return result;
	}
857721
function(obj)
{
	var regExp = arguments[1];
	
	var keys = regExp instanceof RegExp
		? conbo.filter(conbo.keys(obj), function(key) { return regExp.test(key); })
		: (arguments.length > 1 ? conbo.rest(arguments) : conbo.keys(obj));
	
	keys.forEach(function(key)
	{
		var descriptor = Object.getOwnPropertyDescriptor(obj, key) 
			|| {value:obj[key], configurable:true, writable:true};
		
		descriptor.enumerable = false;
		Object.defineProperty(obj, key, descriptor);
	});
}