return new Promise<IRequestContext>((resolve, reject) => {

		xhr.open(options.type || 'GET', options.url, true, options.user, options.password);
		setRequestHeaders(xhr, options);

		xhr.responseType = 'arraybuffer';
		xhr.onerror = e => reject(new Error(xhr.statusText && ('XHR failed: ' + xhr.statusText)));
		xhr.onload = (e) => {
			resolve({
				res: {
					statusCode: xhr.status,
					headers: getResponseHeaders(xhr)
				},
				stream: new class ArrayBufferStream extends Readable {

					private _buffer: Buffer;
					private _offset: number;
					private _length: number;

					constructor(arraybuffer: ArrayBuffer) {
						super();
						this._buffer = Buffer.from(new Uint8Array(arraybuffer));
						this._offset = 0;
						this._length = this._buffer.length;
					}

					_read(size: number) {
						if (this._offset < this._length) {
							this.push(this._buffer.slice(this._offset, (this._offset + size)));
							this._offset += size;
						} else {
							this.push(null);
						}
					}

				}(xhr.response)
			});
		};
		xhr.ontimeout = e => reject(new Error(`XHR timeout: ${options.timeout}ms`));

		if (options.timeout) {
			xhr.timeout = options.timeout;
		}

		// TODO: remove any
		xhr.send(options.data as any);

		// cancel
		token.onCancellationRequested(() => {
			xhr.abort();
			reject(canceled());
		});
	});

    return new Promise<string>((resolve, reject) => {
        options.env = options.env || {};
        options.env['PYTHONIOENCODING'] = 'UTF-8';
        let proc = child_process.spawn(file, args, options);
        let error = '';
        let exited = false;
        if (token && token.onCancellationRequested) {
            token.onCancellationRequested(() => {
                if (!exited && proc) {
                    proc.kill();
                    proc = null;
                }
            });
        }
        proc.on('error', error => {
            reject(error);
        });
        proc.stdout.setEncoding('utf8');
        proc.stderr.setEncoding('utf8');
        proc.stdout.on('data', function (data: string) {
            if (token && token.isCancellationRequested) {
                return;
            }
            stdOut(data);
        });

        proc.stderr.on('data', function (data: string) {
            if (token && token.isCancellationRequested) {
                return;
            }
            if (includeErrorAsResponse) {
                stdOut(data);
            }
            else {
                error += data;
            }
        });

        proc.on('exit', function (code) {
            exited = true;

            if (token && token.isCancellationRequested) {
                return reject();
            }
            if (error.length > 0) {
                return reject(error);
            }

            resolve();
        });

    });

 return new Promise<string>((resolve, reject) => {
     let proc = child_process.execFile(file, args, options, (error, stdout, stderr) => {
         handleResponse(file, includeErrorAsResponse, error, stdout, stderr, token)
             .then(data => resolve(data))
             .catch(err => reject(err));
     });
     if (token && token.onCancellationRequested) {
         token.onCancellationRequested(() => {
             if (proc) {
                 proc.kill();
                 proc = null;
             }
         });
     }
 });

        return new Promise<T | undefined>((resolve, reject) => {
            token.onCancellationRequested(() => resolve(undefined));

            promise.then(resolve, reject);
        });