src/third_party/devtools/node_modules/rxjs/src/internal/observable/dom/AjaxObservable.ts - cobalt - Git at Google

 import { root } from '../../util/root';
 import { Observable } from '../../Observable';
 import { Subscriber } from '../../Subscriber';
 import { TeardownLogic } from '../../types';
 import { map } from '../../operators/map';

 export interface AjaxRequest {
   url?: string;
   body?: any;
   user?: string;
   async?: boolean;
   method?: string;
   headers?: Object;
   timeout?: number;
   password?: string;
   hasContent?: boolean;
   crossDomain?: boolean;
   withCredentials?: boolean;
   createXHR?: () => XMLHttpRequest;
   progressSubscriber?: Subscriber<any>;
   responseType?: string;
 }

 function getCORSRequest(): XMLHttpRequest {
   if (root.XMLHttpRequest) {
     return new root.XMLHttpRequest();
   } else if (!!root.XDomainRequest) {
     return new root.XDomainRequest();
   } else {
     throw new Error('CORS is not supported by your browser');
   }
 }

 function getXMLHttpRequest(): XMLHttpRequest {
   if (root.XMLHttpRequest) {
     return new root.XMLHttpRequest();
   } else {
     let progId: string;
     try {
       const progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
       for (let i = 0; i < 3; i++) {
         try {
           progId = progIds[i];
           if (new root.ActiveXObject(progId)) {
             break;
           }
         } catch (e) {
           //suppress exceptions
         }
       }
       return new root.ActiveXObject(progId);
     } catch (e) {
       throw new Error('XMLHttpRequest is not supported by your browser');
     }
   }
 }

 export interface AjaxCreationMethod {
   (urlOrRequest: string | AjaxRequest): Observable<AjaxResponse>;
   get(url: string, headers?: Object): Observable<AjaxResponse>;
   post(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
   put(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
   patch(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
   delete(url: string, headers?: Object): Observable<AjaxResponse>;
   getJSON<T>(url: string, headers?: Object): Observable<T>;
 }

 export function ajaxGet(url: string, headers: Object = null) {
   return new AjaxObservable<AjaxResponse>({ method: 'GET', url, headers });
 }

 export function ajaxPost(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
   return new AjaxObservable<AjaxResponse>({ method: 'POST', url, body, headers });
 }

 export function ajaxDelete(url: string, headers?: Object): Observable<AjaxResponse> {
   return new AjaxObservable<AjaxResponse>({ method: 'DELETE', url, headers });
 }

 export function ajaxPut(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
   return new AjaxObservable<AjaxResponse>({ method: 'PUT', url, body, headers });
 }

 export function ajaxPatch(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
   return new AjaxObservable<AjaxResponse>({ method: 'PATCH', url, body, headers });
 }

 const mapResponse = map((x: AjaxResponse, index: number) => x.response);

 export function ajaxGetJSON<T>(url: string, headers?: Object): Observable<T> {
   return mapResponse(
     new AjaxObservable<AjaxResponse>({
       method: 'GET',
       url,
       responseType: 'json',
       headers
     })
   );
 }

 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @extends {Ignored}
  * @hide true
  */
 export class AjaxObservable<T> extends Observable<T> {
   /**
    * Creates an observable for an Ajax request with either a request object with
    * url, headers, etc or a string for a URL.
    *
    * ## Example
    * ```ts
    * import { ajax } from 'rxjs/ajax';
  *
    * const source1 = ajax('/products');
    * const source2 = ajax({ url: 'products', method: 'GET' });
    * ```
    *
    * @param {string|Object} request Can be one of the following:
    *   A string of the URL to make the Ajax call.
    *   An object with the following properties
    *   - url: URL of the request
    *   - body: The body of the request
    *   - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE
    *   - async: Whether the request is async
    *   - headers: Optional headers
    *   - crossDomain: true if a cross domain request, else false
    *   - createXHR: a function to override if you need to use an alternate
    *   XMLHttpRequest implementation.
    *   - resultSelector: a function to use to alter the output value type of
    *   the Observable. Gets {@link AjaxResponse} as an argument.
    * @return {Observable} An observable sequence containing the XMLHttpRequest.
    * @static true
    * @name ajax
    * @owner Observable
    * @nocollapse
   */
   static create: AjaxCreationMethod = (() => {
     const create: any = (urlOrRequest: string | AjaxRequest) => {
       return new AjaxObservable(urlOrRequest);
     };

     create.get = ajaxGet;
     create.post = ajaxPost;
     create.delete = ajaxDelete;
     create.put = ajaxPut;
     create.patch = ajaxPatch;
     create.getJSON = ajaxGetJSON;

     return <AjaxCreationMethod>create;
   })();

   private request: AjaxRequest;

   constructor(urlOrRequest: string | AjaxRequest) {
     super();

     const request: AjaxRequest = {
       async: true,
       createXHR: function(this: AjaxRequest) {
         return this.crossDomain ? getCORSRequest() : getXMLHttpRequest();
       },
       crossDomain: true,
       withCredentials: false,
       headers: {},
       method: 'GET',
       responseType: 'json',
       timeout: 0
     };

     if (typeof urlOrRequest === 'string') {
       request.url = urlOrRequest;
     } else {
       for (const prop in urlOrRequest) {
         if (urlOrRequest.hasOwnProperty(prop)) {
           request[prop] = urlOrRequest[prop];
         }
       }
     }

     this.request = request;
   }

   /** @deprecated This is an internal implementation detail, do not use. */
   _subscribe(subscriber: Subscriber<T>): TeardownLogic {
     return new AjaxSubscriber(subscriber, this.request);
   }
 }

 /**
  * We need this JSDoc comment for affecting ESDoc.
  * @ignore
  * @extends {Ignored}
  */
 export class AjaxSubscriber<T> extends Subscriber<Event> {
   private xhr: XMLHttpRequest;
   private done: boolean = false;

   constructor(destination: Subscriber<T>, public request: AjaxRequest) {
     super(destination);

     const headers = request.headers = request.headers || {};

     // force CORS if requested
     if (!request.crossDomain && !this.getHeader(headers, 'X-Requested-With')) {
       headers['X-Requested-With'] = 'XMLHttpRequest';
     }

     // ensure content type is set
     let contentTypeHeader = this.getHeader(headers, 'Content-Type');
     if (!contentTypeHeader && !(root.FormData && request.body instanceof root.FormData) && typeof request.body !== 'undefined') {
       headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
     }

     // properly serialize body
     request.body = this.serializeBody(request.body, this.getHeader(request.headers, 'Content-Type'));

     this.send();
   }

   next(e: Event): void {
     this.done = true;
     const { xhr, request, destination } = this;
     let result;
     try {
       result = new AjaxResponse(e, xhr, request);
     } catch (err) {
       return destination.error(err);
     }
     destination.next(result);
   }

   private send(): void {
     const {
       request,
       request: { user, method, url, async, password, headers, body }
     } = this;
     try {
       const xhr = this.xhr = request.createXHR();

       // set up the events before open XHR
       // https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest
       // You need to add the event listeners before calling open() on the request.
       // Otherwise the progress events will not fire.
       this.setupEvents(xhr, request);
       // open XHR
       if (user) {
         xhr.open(method, url, async, user, password);
       } else {
         xhr.open(method, url, async);
       }

       // timeout, responseType and withCredentials can be set once the XHR is open
       if (async) {
         xhr.timeout = request.timeout;
         xhr.responseType = request.responseType as any;
       }

       if ('withCredentials' in xhr) {
         xhr.withCredentials = !!request.withCredentials;
       }

       // set headers
       this.setHeaders(xhr, headers);

       // finally send the request
       if (body) {
         xhr.send(body);
       } else {
         xhr.send();
       }
     } catch (err) {
       this.error(err);
     }
   }

   private serializeBody(body: any, contentType?: string) {
     if (!body || typeof body === 'string') {
       return body;
     } else if (root.FormData && body instanceof root.FormData) {
       return body;
     }

     if (contentType) {
       const splitIndex = contentType.indexOf(';');
       if (splitIndex !== -1) {
         contentType = contentType.substring(0, splitIndex);
       }
     }

     switch (contentType) {
       case 'application/x-www-form-urlencoded':
         return Object.keys(body).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(body[key])}`).join('&');
       case 'application/json':
         return JSON.stringify(body);
       default:
         return body;
     }
   }

   private setHeaders(xhr: XMLHttpRequest, headers: Object) {
     for (let key in headers) {
       if (headers.hasOwnProperty(key)) {
         xhr.setRequestHeader(key, headers[key]);
       }
     }
   }

   private getHeader(headers: {}, headerName: string): any {
     for (let key in headers) {
       if (key.toLowerCase() === headerName.toLowerCase()) {
         return headers[key];
       }
     }

     return undefined;
   }

   private setupEvents(xhr: XMLHttpRequest, request: AjaxRequest) {
     const progressSubscriber = request.progressSubscriber;

     function xhrTimeout(this: XMLHttpRequest, e: ProgressEvent): void {
       const {subscriber, progressSubscriber, request } = (<any>xhrTimeout);
       if (progressSubscriber) {
         progressSubscriber.error(e);
       }
       let error;
       try {
         error = new AjaxTimeoutError(this, request); // TODO: Make betterer.
       } catch (err) {
         error = err;
       }
       subscriber.error(error);
     }
     xhr.ontimeout = xhrTimeout;
     (<any>xhrTimeout).request = request;
     (<any>xhrTimeout).subscriber = this;
     (<any>xhrTimeout).progressSubscriber = progressSubscriber;
     if (xhr.upload && 'withCredentials' in xhr) {
       if (progressSubscriber) {
         let xhrProgress: (e: ProgressEvent) => void;
         xhrProgress = function(e: ProgressEvent) {
           const { progressSubscriber } = (<any>xhrProgress);
           progressSubscriber.next(e);
         };
         if (root.XDomainRequest) {
           xhr.onprogress = xhrProgress;
         } else {
           xhr.upload.onprogress = xhrProgress;
         }
         (<any>xhrProgress).progressSubscriber = progressSubscriber;
       }
       let xhrError: (e: any) => void;
       xhrError = function(this: XMLHttpRequest, e: ErrorEvent) {
         const { progressSubscriber, subscriber, request } = (<any>xhrError);
         if (progressSubscriber) {
           progressSubscriber.error(e);
         }
         let error;
         try {
           error = new AjaxError('ajax error', this, request);
         } catch (err) {
           error = err;
         }
         subscriber.error(error);
       };
       xhr.onerror = xhrError;
       (<any>xhrError).request = request;
       (<any>xhrError).subscriber = this;
       (<any>xhrError).progressSubscriber = progressSubscriber;
     }

     function xhrReadyStateChange(this: XMLHttpRequest, e: Event) {
       return;
     }
     xhr.onreadystatechange = xhrReadyStateChange;
     (<any>xhrReadyStateChange).subscriber = this;
     (<any>xhrReadyStateChange).progressSubscriber = progressSubscriber;
     (<any>xhrReadyStateChange).request = request;

     function xhrLoad(this: XMLHttpRequest, e: Event) {
       const { subscriber, progressSubscriber, request } = (<any>xhrLoad);
       if (this.readyState === 4) {
         // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
         let status: number = this.status === 1223 ? 204 : this.status;
         let response: any = (this.responseType === 'text' ?  (
           this.response || this.responseText) : this.response);

         // fix status code when it is 0 (0 status is undocumented).
         // Occurs when accessing file resources or on Android 4.1 stock browser
         // while retrieving files from application cache.
         if (status === 0) {
           status = response ? 200 : 0;
         }

         // 4xx and 5xx should error (https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
         if (status < 400) {
           if (progressSubscriber) {
             progressSubscriber.complete();
           }
           subscriber.next(e);
           subscriber.complete();
         } else {
           if (progressSubscriber) {
             progressSubscriber.error(e);
           }
           let error;
           try {
             error = new AjaxError('ajax error ' + status, this, request);
           } catch (err) {
             error = err;
           }
           subscriber.error(error);
         }
       }
     }
     xhr.onload = xhrLoad;
     (<any>xhrLoad).subscriber = this;
     (<any>xhrLoad).progressSubscriber = progressSubscriber;
     (<any>xhrLoad).request = request;
   }

   unsubscribe() {
     const { done, xhr } = this;
     if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {
       xhr.abort();
     }
     super.unsubscribe();
   }
 }

 /**
  * A normalized AJAX response.
  *
  * @see {@link ajax}
  *
  * @class AjaxResponse
  */
 export class AjaxResponse {
   /** @type {number} The HTTP status code */
   status: number;

   /** @type {string|ArrayBuffer|Document|object|any} The response data */
   response: any;

   /** @type {string} The raw responseText */
   responseText: string;

   /** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */
   responseType: string;

   constructor(public originalEvent: Event, public xhr: XMLHttpRequest, public request: AjaxRequest) {
     this.status = xhr.status;
     this.responseType = xhr.responseType || request.responseType;
     this.response = parseXhrResponse(this.responseType, xhr);
   }
 }

 export type AjaxErrorNames = 'AjaxError' | 'AjaxTimeoutError';

 /**
  * A normalized AJAX error.
  *
  * @see {@link ajax}
  *
  * @class AjaxError
  */
 export interface AjaxError extends Error {
   /** @type {XMLHttpRequest} The XHR instance associated with the error */
   xhr: XMLHttpRequest;

   /** @type {AjaxRequest} The AjaxRequest associated with the error */
   request: AjaxRequest;

   /** @type {number} The HTTP status code */
   status: number;

   /** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */
   responseType: string;

   /** @type {string|ArrayBuffer|Document|object|any} The response data */
   response: any;
 }

 export interface AjaxErrorCtor {
   new(message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
 }

 const AjaxErrorImpl = (() => {
   function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError {
     Error.call(this);
     this.message = message;
     this.name = 'AjaxError';
     this.xhr = xhr;
     this.request = request;
     this.status = xhr.status;
     this.responseType = xhr.responseType || request.responseType;
     this.response = parseXhrResponse(this.responseType, xhr);
     return this;
   }
   AjaxErrorImpl.prototype = Object.create(Error.prototype);
   return AjaxErrorImpl;
 })();

 export const AjaxError: AjaxErrorCtor = AjaxErrorImpl as any;

 function parseJson(xhr: XMLHttpRequest) {
   // HACK(benlesh): TypeScript shennanigans
   // tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else clause.
   if ('response' in (xhr as any)) {
     //IE does not support json as responseType, parse it internally
     return xhr.responseType ? xhr.response : JSON.parse(xhr.response || xhr.responseText || 'null');
   } else {
     return JSON.parse((xhr as any).responseText || 'null');
   }
 }

 function parseXhrResponse(responseType: string, xhr: XMLHttpRequest) {
   switch (responseType) {
     case 'json':
         return parseJson(xhr);
       case 'xml':
         return xhr.responseXML;
       case 'text':
       default:
           // HACK(benlesh): TypeScript shennanigans
           // tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else sub-expression.
           return  ('response' in (xhr as any)) ? xhr.response : xhr.responseText;
   }
 }

 export interface AjaxTimeoutError extends AjaxError {
 }

 export interface AjaxTimeoutErrorCtor {
   new(xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
 }

 function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
   AjaxError.call(this, 'ajax timeout', xhr, request);
   this.name = 'AjaxTimeoutError';
   return this;
 }

 /**
  * @see {@link ajax}
  *
  * @class AjaxTimeoutError
  */
 export const AjaxTimeoutError: AjaxTimeoutErrorCtor = AjaxTimeoutErrorImpl as any;
	import { root } from '../../util/root';
	import { Observable } from '../../Observable';
	import { Subscriber } from '../../Subscriber';
	import { TeardownLogic } from '../../types';
	import { map } from '../../operators/map';

	export interface AjaxRequest {
	url?: string;
	body?: any;
	user?: string;
	async?: boolean;
	method?: string;
	headers?: Object;
	timeout?: number;
	password?: string;
	hasContent?: boolean;
	crossDomain?: boolean;
	withCredentials?: boolean;
	createXHR?: () => XMLHttpRequest;
	progressSubscriber?: Subscriber<any>;
	responseType?: string;
	}

	function getCORSRequest(): XMLHttpRequest {
	if (root.XMLHttpRequest) {
	return new root.XMLHttpRequest();
	} else if (!!root.XDomainRequest) {
	return new root.XDomainRequest();
	} else {
	throw new Error('CORS is not supported by your browser');
	}
	}

	function getXMLHttpRequest(): XMLHttpRequest {
	if (root.XMLHttpRequest) {
	return new root.XMLHttpRequest();
	} else {
	let progId: string;
	try {
	const progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];
	for (let i = 0; i < 3; i++) {
	try {
	progId = progIds[i];
	if (new root.ActiveXObject(progId)) {
	break;
	}
	} catch (e) {
	//suppress exceptions
	}
	}
	return new root.ActiveXObject(progId);
	} catch (e) {
	throw new Error('XMLHttpRequest is not supported by your browser');
	}
	}
	}

	export interface AjaxCreationMethod {
	(urlOrRequest: string \| AjaxRequest): Observable<AjaxResponse>;
	get(url: string, headers?: Object): Observable<AjaxResponse>;
	post(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
	put(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
	patch(url: string, body?: any, headers?: Object): Observable<AjaxResponse>;
	delete(url: string, headers?: Object): Observable<AjaxResponse>;
	getJSON<T>(url: string, headers?: Object): Observable<T>;
	}

	export function ajaxGet(url: string, headers: Object = null) {
	return new AjaxObservable<AjaxResponse>({ method: 'GET', url, headers });
	}

	export function ajaxPost(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
	return new AjaxObservable<AjaxResponse>({ method: 'POST', url, body, headers });
	}

	export function ajaxDelete(url: string, headers?: Object): Observable<AjaxResponse> {
	return new AjaxObservable<AjaxResponse>({ method: 'DELETE', url, headers });
	}

	export function ajaxPut(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
	return new AjaxObservable<AjaxResponse>({ method: 'PUT', url, body, headers });
	}

	export function ajaxPatch(url: string, body?: any, headers?: Object): Observable<AjaxResponse> {
	return new AjaxObservable<AjaxResponse>({ method: 'PATCH', url, body, headers });
	}

	const mapResponse = map((x: AjaxResponse, index: number) => x.response);

	export function ajaxGetJSON<T>(url: string, headers?: Object): Observable<T> {
	return mapResponse(
	new AjaxObservable<AjaxResponse>({
	method: 'GET',
	url,
	responseType: 'json',
	headers
	})
	);
	}

	/**
	* We need this JSDoc comment for affecting ESDoc.
	* @extends {Ignored}
	* @hide true
	*/
	export class AjaxObservable<T> extends Observable<T> {
	/**
	* Creates an observable for an Ajax request with either a request object with
	* url, headers, etc or a string for a URL.
	*
	* ## Example
	* ```ts
	* import { ajax } from 'rxjs/ajax';
	*
	* const source1 = ajax('/products');
	* const source2 = ajax({ url: 'products', method: 'GET' });
	* ```
	*
	* @param {string\|Object} request Can be one of the following:
	* A string of the URL to make the Ajax call.
	* An object with the following properties
	* - url: URL of the request
	* - body: The body of the request
	* - method: Method of the request, such as GET, POST, PUT, PATCH, DELETE
	* - async: Whether the request is async
	* - headers: Optional headers
	* - crossDomain: true if a cross domain request, else false
	* - createXHR: a function to override if you need to use an alternate
	* XMLHttpRequest implementation.
	* - resultSelector: a function to use to alter the output value type of
	* the Observable. Gets {@link AjaxResponse} as an argument.
	* @return {Observable} An observable sequence containing the XMLHttpRequest.
	* @static true
	* @name ajax
	* @owner Observable
	* @nocollapse
	*/
	static create: AjaxCreationMethod = (() => {
	const create: any = (urlOrRequest: string \| AjaxRequest) => {
	return new AjaxObservable(urlOrRequest);
	};

	create.get = ajaxGet;
	create.post = ajaxPost;
	create.delete = ajaxDelete;
	create.put = ajaxPut;
	create.patch = ajaxPatch;
	create.getJSON = ajaxGetJSON;

	return <AjaxCreationMethod>create;
	})();

	private request: AjaxRequest;

	constructor(urlOrRequest: string \| AjaxRequest) {
	super();

	const request: AjaxRequest = {
	async: true,
	createXHR: function(this: AjaxRequest) {
	return this.crossDomain ? getCORSRequest() : getXMLHttpRequest();
	},
	crossDomain: true,
	withCredentials: false,
	headers: {},
	method: 'GET',
	responseType: 'json',
	timeout: 0
	};

	if (typeof urlOrRequest === 'string') {
	request.url = urlOrRequest;
	} else {
	for (const prop in urlOrRequest) {
	if (urlOrRequest.hasOwnProperty(prop)) {
	request[prop] = urlOrRequest[prop];
	}
	}
	}

	this.request = request;
	}

	/** @deprecated This is an internal implementation detail, do not use. */
	_subscribe(subscriber: Subscriber<T>): TeardownLogic {
	return new AjaxSubscriber(subscriber, this.request);
	}
	}

	/**
	* We need this JSDoc comment for affecting ESDoc.
	* @ignore
	* @extends {Ignored}
	*/
	export class AjaxSubscriber<T> extends Subscriber<Event> {
	private xhr: XMLHttpRequest;
	private done: boolean = false;

	constructor(destination: Subscriber<T>, public request: AjaxRequest) {
	super(destination);

	const headers = request.headers = request.headers \|\| {};

	// force CORS if requested
	if (!request.crossDomain && !this.getHeader(headers, 'X-Requested-With')) {
	headers['X-Requested-With'] = 'XMLHttpRequest';
	}

	// ensure content type is set
	let contentTypeHeader = this.getHeader(headers, 'Content-Type');
	if (!contentTypeHeader && !(root.FormData && request.body instanceof root.FormData) && typeof request.body !== 'undefined') {
	headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=UTF-8';
	}

	// properly serialize body
	request.body = this.serializeBody(request.body, this.getHeader(request.headers, 'Content-Type'));

	this.send();
	}

	next(e: Event): void {
	this.done = true;
	const { xhr, request, destination } = this;
	let result;
	try {
	result = new AjaxResponse(e, xhr, request);
	} catch (err) {
	return destination.error(err);
	}
	destination.next(result);
	}

	private send(): void {
	const {
	request,
	request: { user, method, url, async, password, headers, body }
	} = this;
	try {
	const xhr = this.xhr = request.createXHR();

	// set up the events before open XHR
	// https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest
	// You need to add the event listeners before calling open() on the request.
	// Otherwise the progress events will not fire.
	this.setupEvents(xhr, request);
	// open XHR
	if (user) {
	xhr.open(method, url, async, user, password);
	} else {
	xhr.open(method, url, async);
	}

	// timeout, responseType and withCredentials can be set once the XHR is open
	if (async) {
	xhr.timeout = request.timeout;
	xhr.responseType = request.responseType as any;
	}

	if ('withCredentials' in xhr) {
	xhr.withCredentials = !!request.withCredentials;
	}

	// set headers
	this.setHeaders(xhr, headers);

	// finally send the request
	if (body) {
	xhr.send(body);
	} else {
	xhr.send();
	}
	} catch (err) {
	this.error(err);
	}
	}

	private serializeBody(body: any, contentType?: string) {
	if (!body \|\| typeof body === 'string') {
	return body;
	} else if (root.FormData && body instanceof root.FormData) {
	return body;
	}

	if (contentType) {
	const splitIndex = contentType.indexOf(';');
	if (splitIndex !== -1) {
	contentType = contentType.substring(0, splitIndex);
	}
	}

	switch (contentType) {
	case 'application/x-www-form-urlencoded':
	return Object.keys(body).map(key => `${encodeURIComponent(key)}=${encodeURIComponent(body[key])}`).join('&');
	case 'application/json':
	return JSON.stringify(body);
	default:
	return body;
	}
	}

	private setHeaders(xhr: XMLHttpRequest, headers: Object) {
	for (let key in headers) {
	if (headers.hasOwnProperty(key)) {
	xhr.setRequestHeader(key, headers[key]);
	}
	}
	}

	private getHeader(headers: {}, headerName: string): any {
	for (let key in headers) {
	if (key.toLowerCase() === headerName.toLowerCase()) {
	return headers[key];
	}
	}

	return undefined;
	}

	private setupEvents(xhr: XMLHttpRequest, request: AjaxRequest) {
	const progressSubscriber = request.progressSubscriber;

	function xhrTimeout(this: XMLHttpRequest, e: ProgressEvent): void {
	const {subscriber, progressSubscriber, request } = (<any>xhrTimeout);
	if (progressSubscriber) {
	progressSubscriber.error(e);
	}
	let error;
	try {
	error = new AjaxTimeoutError(this, request); // TODO: Make betterer.
	} catch (err) {
	error = err;
	}
	subscriber.error(error);
	}
	xhr.ontimeout = xhrTimeout;
	(<any>xhrTimeout).request = request;
	(<any>xhrTimeout).subscriber = this;
	(<any>xhrTimeout).progressSubscriber = progressSubscriber;
	if (xhr.upload && 'withCredentials' in xhr) {
	if (progressSubscriber) {
	let xhrProgress: (e: ProgressEvent) => void;
	xhrProgress = function(e: ProgressEvent) {
	const { progressSubscriber } = (<any>xhrProgress);
	progressSubscriber.next(e);
	};
	if (root.XDomainRequest) {
	xhr.onprogress = xhrProgress;
	} else {
	xhr.upload.onprogress = xhrProgress;
	}
	(<any>xhrProgress).progressSubscriber = progressSubscriber;
	}
	let xhrError: (e: any) => void;
	xhrError = function(this: XMLHttpRequest, e: ErrorEvent) {
	const { progressSubscriber, subscriber, request } = (<any>xhrError);
	if (progressSubscriber) {
	progressSubscriber.error(e);
	}
	let error;
	try {
	error = new AjaxError('ajax error', this, request);
	} catch (err) {
	error = err;
	}
	subscriber.error(error);
	};
	xhr.onerror = xhrError;
	(<any>xhrError).request = request;
	(<any>xhrError).subscriber = this;
	(<any>xhrError).progressSubscriber = progressSubscriber;
	}

	function xhrReadyStateChange(this: XMLHttpRequest, e: Event) {
	return;
	}
	xhr.onreadystatechange = xhrReadyStateChange;
	(<any>xhrReadyStateChange).subscriber = this;
	(<any>xhrReadyStateChange).progressSubscriber = progressSubscriber;
	(<any>xhrReadyStateChange).request = request;

	function xhrLoad(this: XMLHttpRequest, e: Event) {
	const { subscriber, progressSubscriber, request } = (<any>xhrLoad);
	if (this.readyState === 4) {
	// normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
	let status: number = this.status === 1223 ? 204 : this.status;
	let response: any = (this.responseType === 'text' ? (
	this.response \|\| this.responseText) : this.response);

	// fix status code when it is 0 (0 status is undocumented).
	// Occurs when accessing file resources or on Android 4.1 stock browser
	// while retrieving files from application cache.
	if (status === 0) {
	status = response ? 200 : 0;
	}

	// 4xx and 5xx should error (https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
	if (status < 400) {
	if (progressSubscriber) {
	progressSubscriber.complete();
	}
	subscriber.next(e);
	subscriber.complete();
	} else {
	if (progressSubscriber) {
	progressSubscriber.error(e);
	}
	let error;
	try {
	error = new AjaxError('ajax error ' + status, this, request);
	} catch (err) {
	error = err;
	}
	subscriber.error(error);
	}
	}
	}
	xhr.onload = xhrLoad;
	(<any>xhrLoad).subscriber = this;
	(<any>xhrLoad).progressSubscriber = progressSubscriber;
	(<any>xhrLoad).request = request;
	}

	unsubscribe() {
	const { done, xhr } = this;
	if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {
	xhr.abort();
	}
	super.unsubscribe();
	}
	}

	/**
	* A normalized AJAX response.
	*
	* @see {@link ajax}
	*
	* @class AjaxResponse
	*/
	export class AjaxResponse {
	/** @type {number} The HTTP status code */
	status: number;

	/** @type {string\|ArrayBuffer\|Document\|object\|any} The response data */
	response: any;

	/** @type {string} The raw responseText */
	responseText: string;

	/** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */
	responseType: string;

	constructor(public originalEvent: Event, public xhr: XMLHttpRequest, public request: AjaxRequest) {
	this.status = xhr.status;
	this.responseType = xhr.responseType \|\| request.responseType;
	this.response = parseXhrResponse(this.responseType, xhr);
	}
	}

	export type AjaxErrorNames = 'AjaxError' \| 'AjaxTimeoutError';

	/**
	* A normalized AJAX error.
	*
	* @see {@link ajax}
	*
	* @class AjaxError
	*/
	export interface AjaxError extends Error {
	/** @type {XMLHttpRequest} The XHR instance associated with the error */
	xhr: XMLHttpRequest;

	/** @type {AjaxRequest} The AjaxRequest associated with the error */
	request: AjaxRequest;

	/** @type {number} The HTTP status code */
	status: number;

	/** @type {string} The responseType (e.g. 'json', 'arraybuffer', or 'xml') */
	responseType: string;

	/** @type {string\|ArrayBuffer\|Document\|object\|any} The response data */
	response: any;
	}

	export interface AjaxErrorCtor {
	new(message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError;
	}

	const AjaxErrorImpl = (() => {
	function AjaxErrorImpl(this: any, message: string, xhr: XMLHttpRequest, request: AjaxRequest): AjaxError {
	Error.call(this);
	this.message = message;
	this.name = 'AjaxError';
	this.xhr = xhr;
	this.request = request;
	this.status = xhr.status;
	this.responseType = xhr.responseType \|\| request.responseType;
	this.response = parseXhrResponse(this.responseType, xhr);
	return this;
	}
	AjaxErrorImpl.prototype = Object.create(Error.prototype);
	return AjaxErrorImpl;
	})();

	export const AjaxError: AjaxErrorCtor = AjaxErrorImpl as any;

	function parseJson(xhr: XMLHttpRequest) {
	// HACK(benlesh): TypeScript shennanigans
	// tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else clause.
	if ('response' in (xhr as any)) {
	//IE does not support json as responseType, parse it internally
	return xhr.responseType ? xhr.response : JSON.parse(xhr.response \|\| xhr.responseText \|\| 'null');
	} else {
	return JSON.parse((xhr as any).responseText \|\| 'null');
	}
	}

	function parseXhrResponse(responseType: string, xhr: XMLHttpRequest) {
	switch (responseType) {
	case 'json':
	return parseJson(xhr);
	case 'xml':
	return xhr.responseXML;
	case 'text':
	default:
	// HACK(benlesh): TypeScript shennanigans
	// tslint:disable-next-line:no-any XMLHttpRequest is defined to always have 'response' inferring xhr as never for the else sub-expression.
	return ('response' in (xhr as any)) ? xhr.response : xhr.responseText;
	}
	}

	export interface AjaxTimeoutError extends AjaxError {
	}

	export interface AjaxTimeoutErrorCtor {
	new(xhr: XMLHttpRequest, request: AjaxRequest): AjaxTimeoutError;
	}

	function AjaxTimeoutErrorImpl(this: any, xhr: XMLHttpRequest, request: AjaxRequest) {
	AjaxError.call(this, 'ajax timeout', xhr, request);
	this.name = 'AjaxTimeoutError';
	return this;
	}

	/**
	* @see {@link ajax}
	*
	* @class AjaxTimeoutError
	*/
	export const AjaxTimeoutError: AjaxTimeoutErrorCtor = AjaxTimeoutErrorImpl as any;