245 function AsyncInvokeLater(fn, receiver, arg) {  argument
246     this._lateQueue.push(fn, receiver, arg);
250 function AsyncInvoke(fn, receiver, arg) {  argument
251     this._normalQueue.push(fn, receiver, arg);
265     Async.prototype.invokeLater = function (fn, receiver, arg) {  argument
267             AsyncInvokeLater.call(this, fn, receiver, arg);
271                     fn.call(receiver, arg);
277     Async.prototype.invoke = function (fn, receiver, arg) {  argument
279             AsyncInvoke.call(this, fn, receiver, arg);
282                 fn.call(receiver, arg);
309         var receiver = queue.shift();
311         fn.call(receiver, arg);
1560         return function(receiver, ignoreUntil) {  argument
1562             captureStackTrace(receiver, ignoreUntil);
2140 function PromiseSpawn(generatorFunction, receiver, yieldHandler, stack) {  argument
2155     this._receiver = receiver;
2420         var receiver = promise._boundValue();
2422         var ret = tryCatch(callback).call(receiver, value, index, length);
2661     var receiver = promise._boundValue();
2663         ? tryCatch(nodeback).call(receiver, null)
2664         : tryCatch(nodeback).call(receiver, null, val);
2923     _,    receiver,  argument
2934         if (receiver === undefined &&
2937                 receiver = this._boundValue();
2939                 receiver = target === this ? undefined : this._boundTo;
2967             receiver: receiver,
2971         target._addCallbacks(didFulfill, didReject, promise, receiver, domain);
3068     var receiver = follower._receiverAt(0);
3069     if (receiver === undefined) receiver = UNDEFINED_BINDING;
3070     this._addCallbacks(fulfill, reject, promise, receiver, null);
3077     var receiver = follower._receiverAt(index);
3078     if (receiver === undefined) receiver = UNDEFINED_BINDING;
3079     this._addCallbacks(fulfill, reject, promise, receiver, null);
3086     receiver,  argument
3098         this._receiver0 = receiver;
3110         this[base + 3] = receiver;
3198     handler, receiver, value, promise  argument
3204     if (receiver === APPLY) {
3213         x = tryCatch(handler).call(receiver, value);
3243 Promise.prototype._settlePromise = function(promise, handler, receiver, value) {  argument
3250         if (receiver instanceof PassThroughHandlerContext &&
3251             receiver.isFinallyHandler()) {
3252             receiver.cancelPromise = promise;
3253             if (tryCatch(handler).call(receiver, value) === errorObj) {
3257             promise._fulfill(reflectHandler.call(receiver));
3258         } else if (receiver instanceof Proxyable) {
3259             receiver._promiseCancelled(promise);
3263             receiver.cancel();
3267             handler.call(receiver, value, promise);
3270             this._settlePromiseFromHandler(handler, receiver, value, promise);
3272     } else if (receiver instanceof Proxyable) {
3273         if (!receiver._isResolved()) {
3275                 receiver._promiseFulfilled(value, promise);
3277                 receiver._promiseRejected(value, promise);
3293     var receiver = ctx.receiver;
3297             handler.call(receiver, value, promise);
3299             this._settlePromiseFromHandler(handler, receiver, value, promise);
3307     this._settlePromise(ctx.promise, ctx.handler, ctx.receiver, ctx.value);
3312     var receiver = this._receiverAt(0);
3315     this._settlePromise(promise, handler, receiver, value);
3368         var receiver = this._receiverAt(i);
3370         this._settlePromise(promise, handler, receiver, value);
3378         var receiver = this._receiverAt(i);
3380         this._settlePromise(promise, handler, receiver, reason);
3754 function makeNodePromisifiedClosure(callback, receiver, _, fn, __, multiArgs) {  argument
3761         var _receiver = receiver;
3762         if (receiver === THIS) _receiver = this;
3809 function promisify(callback, receiver, multiArgs) {  argument
3810     return makeNodePromisified(callback, receiver, undefined,
3822     var receiver = options.context === undefined ? THIS : options.context;
3824     var ret = promisify(fn, receiver, multiArgs);
4009 Queue.prototype.push = function (fn, receiver, arg) {  argument
4013         this._pushOne(receiver);
4021     this[(j + 1) & wrapMask] = receiver;
5254     var receiver = new FakeConstructor();
5256         return typeof receiver.foo;