Proxy a property, simillar to the proxy in ES6. Allows us to propagate changes to the target property.
546729
function (originalObj, originalProp, targetObj, targetProp) {
                Object.defineProperty(
                    originalObj,
                    originalProp,
                    {
                        get: function () {
                            return targetObj[targetProp];
                        },
                        set: function (newValue) {
                            targetObj[targetProp] = newValue;
                        }
                    }
                );
            }
909328
function init(obj = {}, prevName = '') {
    return new Proxy(obj, {
        get (target, name) {
            if (typeof name === 'symbol' || deflectedProperties.includes(name)) {
                return Reflect.get(target, name);
            }
            ns.resetTo(prevName);
            ns.push(name);
            let value = process.env[ns.serialize()];
            if (value) {
                ns.pop();
                return value;
            }
            return init(target, name);
        },
        set (target, name, val) {
            ns.resetTo(prevName);
            ns.push(name);
            let value = String(val);
            process.env[ns.serialize()] = value;
            ns.pop();
            return value;
        }
    });
}
1276319
function initApiProxy() {
  if (build.verbose)
    console.log('Proxying paths...');
  lodash.forEach(build.proxyMap, function (proxyOpts, urlPath) {
    if (build.verbose)
      console.log('  - url: "' + urlPath + '"');
    app.use(urlPath, proxy(proxyOpts));
    // e.g. `app.use('/api', proxy({target: "http://localhost:4321/api", 
    // changeOrigin: true});`
  });
}
141198
function extend (target, source) {
	var a = Object.create(target);

	Object.keys(source).map(function (prop) {
		prop in a && (a[prop] = source[prop]);
	});
	
	return a;
}
839456
function _setObjectProperty (object, index, replacement) {
  if (index.size().length !== 1) {
    throw new DimensionError(index.size(), 1)
  }

  const key = index.dimension(0)
  if (typeof key !== 'string') {
    throw new TypeError('String expected as index to retrieve an object property')
  }

  // clone the object, and apply the property to the clone
  const updated = clone(object)
  setSafeProperty(updated, key, replacement)

  return updated
}
1023019
function (name, module) {
        var _interface = makeInterface(this, name, module),
            proxy = makeProxy(this, name, _interface)

        extend(module, {
            emit: proxy.emit
        })

        this._modules[name] = module
        this._interfaces[name] = _interface
        this.proxies[name] = proxy

        return proxy
    }
648612
def proxy_global(name, no_expand_macro=False, fname='func', args=()):
    
    if no_expand_macro:  # pragma: no cover
        # handle older ROOT versions without _ExpandMacroFunction wrapping
        @property
        def gSomething_no_func(self):
            glob = self(getattr(ROOT, name))
            # create a fake func() that just returns self
            def func():
                return glob
            glob.func = func
            return glob
        return gSomething_no_func

    @property
    def gSomething(self):
        obj_func = getattr(getattr(ROOT, name), fname)
        try:
            obj = obj_func(*args)
        except ReferenceError:  # null pointer
            return None
        # asrootpy
        return self(obj)

    return gSomething
685325
function makeProxy(definition, names, send, rootDefinition) {
    if (! names) throw new Error("No name proxying definition " + JSON.stringify(definition));
    if (! Array.isArray(names)) names = [ names ];

    /* All definitions are objects! */
    if (typeof(definition) !== 'object') {
      throw new Error("Wrong proxy definition at " + names.join('.') + " for \n"
                    + JSON.stringify(rootDefinition, null, 1));
    }

    /* Initial object */
    var object = {};

    /* Function definitions, can be also at top level */
    if (definition['!$invocable$!'] === true) {
      var clone = names.slice(0);

      /* Can be called as "new F()" or "f()" */
      var Invocable = function() {

        /* Prepare our message */
        var message = { proxy: { proxy: clone, arguments: arguments }};

        /* Is this "new F()" or a normal call? */
        if (this instanceof Invocable) {
          message.newInstance = true;
          ProxyPromise.call(this, message, send);
          this.asProxy(true);
        } else {
          return new ProxyPromise(message, send);
        }
      }

      /* Functions can have members, so keep processing */
      object = Invocable;

    }

    /* Clone all the members of the definition */
    for (var i in definition) {
      (function(i) {
        var child = definition[i];
        var clone = names.slice(0);
        clone.push(i);

        /* Basic properties for the object to define */
        var props = { enumerable: true, configurable: false };

        /* Function definitions */
        if (child['!$invocable$!'] === true) {
          props.value = makeProxy(child, clone, send, rootDefinition);
        }

        /* Setters/getters definitions */
        else if (child.hasOwnProperty('!$value$!')) {
          var initialValue = child['!$value$!'];
          props['get'] = function() {
            var message = { proxy: { proxy: clone } };
            var promise = new ProxyPromise(message, send, initialValue);
            promise.asProxy = function() { return promise } // already a proxy
            promise.then(function(success) { initialValue = success });
            return promise; // return the original ProxyPromise instance
          };
          props['set'] = function(value) {
            initialValue = value;
            send({ proxy: { value: value, proxy: clone } })
              .then(function(success) { initialValue = success });
          };
        }

        /* Nested definitions get recursively processed */
        else if (typeof(child) === 'object') {
          props.value = makeProxy(child, clone, send, rootDefinition);
        }

        else if (i !== '!$invocable$!') {
          throw new Error("Wrong proxy definition at " + names.join('.') + "." + i + " for \n"
                        + JSON.stringify(rootDefinition, null, 1));
        }

        /* Define the properties for this */
        Object.defineProperty(object, i, props);
      })(i);
    }

    /* All done, return our object clone */
    return object;
  }
717925
function (name, meta, target) {
            if (!__define.defineProperty(target || this.prototype, name, meta)) {
                this._properties_.push(name);
            }

            return this;
        }
8754
function interceptPropertyGet(_ref7) {
  var _this2 = this;

  var entity = _ref7.entity,
      properties = _ref7.properties;

  // Create a proxy .interceptPropertyGet(...) methods, per property
  this.interceptPropertyGet = _lodash2.default.reduce(properties, function (interceptPropertyGet, propertyConfiguration, propertyName) {

    // Fetch extensions implementing .interceptPropertyGet(...) method for this property's interceptor functions
    var getterInterceptors = _lodash2.default.compact(_lodash2.default.map(_this2.extensions, function (extension) {
      // Check if implementing .interceptPropertyGet(...) method
      if (extension.implemented.interceptPropertyGet) {
        // Return the setter interceptor function (if returned for this property)
        return extension.interceptPropertyGet(propertyName, propertyConfiguration);
      }
    }));

    // Initialize a per-property setter intercepting function and returns the updated value
    interceptPropertyGet[propertyName] = function (currentValue, newValue) {

      // Initialize the EnTTExtValueEvent event
      var changes = [currentValue, newValue],
          event = new _enttext.EnTTExtValueEvent({
        changes: changes,
        currentValue: currentValue,
        value: newValue
      });

      // Cycle through all the setter interceptors
      _lodash2.default.forEach(getterInterceptors, function (getterInterceptor) {
        // Execute the extensino intercaptor
        getterInterceptor(entity, properties, event);
        // Update the changes array for the next interceptor
        changes.push(event.value);
      });

      // Return the updated value
      return event.value;
    };

    // Return composed interceptors
    return interceptPropertyGet;
  }, {});
}
735397
function HttpsProxyingAgent(options) {
  options.tunnel = true;
  ProxyingAgent.call(this, options, https.Agent);
}
359818
function mixin(target, properties) {
    Object.keys(properties).forEach(function(prop) {
      target[prop] = properties[prop];
    });
  }
628449
def set_value(self, value):
        """"""
        self._value = value

        for proxy in self.get_proxies():
            proxy.handler_block(self._changed_handlers[proxy])
            proxy.set_value(self._value)
            proxy.handler_unblock(self._changed_handlers[proxy])
            pass

        self.emit('changed')
        return
361473
def use(proxy, options = {}, &block)
      proxy = Moneta.const_get(proxy) if Symbol === proxy
      raise ArgumentError, 'You must give a Class or a Symbol' unless Class === proxy
      @proxies.unshift [proxy, options, block]
      nil
    end
630466
function createDefaultProxies(items, proxyRole) {
  const proxies = items ?
    items.map(() => template.createElement(proxyRole)) :
    [];
  // Make the array immutable to help update performance.
  Object.freeze(proxies);
  return proxies;
}
594735
function FixtureProxy(fixture, childIndex) {
  this.aabb = new AABB();
  this.fixture = fixture;
  this.childIndex = childIndex;
  this.proxyId;
}
1203587
function _proxyRequest(json, callback) {
	  var rollbarProxy = new RollbarProxy();
	  rollbarProxy.sendJsonPayload(
	    json,
	    function(_msg) { /* do nothing */ }, // eslint-disable-line no-unused-vars
	    function(err) {
	      callback(new Error(err));
	    }
	  );
	}