'Range': 'bytes=0-1024'
							}
						});
					});
				}).then((response: any) => {
					return response.json().then((data: any) => {
						assert.isDefined(data.headers, 'range');
					});
				});
			},

			'default headers'(this: any) {
				if (!echoServerAvailable) {
					this.skip('No echo server available');
				}
				const options = has('formdata') ? { body: new FormData() } : {};
				return xhrRequest('/__echo/default', options).then(function (response: any) {
					return response.json().then((data: any) => {
						assert.strictEqual(data.headers[ 'x-requested-with' ], 'XMLHttpRequest');
						if (has('formdata')) {
							assert.include(data.headers[ 'content-type' ], 'application/x-www-form-urlencoded');
						}
					});
				});
			}
		}
	},

	'response object': {
		properties(this: any) {
			if (!echoServerAvailable) {

					return response.json().then((data: any) => {
						assert.strictEqual(data.headers[ 'x-requested-with' ], 'XMLHttpRequest');
						if (has('formdata')) {
							assert.include(data.headers[ 'content-type' ], 'application/x-www-form-urlencoded');
						}
					});

import global from '@dojo/shim/global';
import has, { add as hasAdd } from '@dojo/has/has';

hasAdd('btoa', 'btoa' in global, true);
hasAdd('atob', 'atob' in global, true);

/**
 * Take a string encoded in base64 and decode it
 * @param encodedString The base64 encoded string
 */
export const decode: (encodedString: string) => string = has('atob')
	? function(encodedString: string) {
			/* this allows for utf8 characters to be decoded properly */
			return decodeURIComponent(
				Array.prototype.map
					.call(
						atob(encodedString),
						(char: string) => '%' + ('00' + char.charCodeAt(0).toString(16)).slice(-2)
					)
					.join('')
			);
		}
	: function(encodedString: string): string {
			return new Buffer(encodedString.toString(), 'base64').toString('utf8');
		};

/**
 * Take a string and encode it to base64
 * @param rawString The string to encode
 */
export const encode: (rawString: string) => string = has('btoa')

			widget.sendEvent('blur', { selector: 'input' });
			assert.isTrue(onBlur.called, 'onBlur called');
			widget.sendEvent('change', { selector: 'input' });
			assert.isTrue(onChange.called, 'onChange called');
			widget.sendEvent('click', { selector: 'input' });
			assert.isTrue(onClick.called, 'onClick called');
			widget.sendEvent('focus', { selector: 'input' });
			assert.isTrue(onFocus.called, 'onFocus called');
			widget.sendEvent('mousedown', { selector: 'input' });
			assert.isTrue(onMouseDown.called, 'onMouseDown called');
			widget.sendEvent('mouseup', { selector: 'input' });
			assert.isTrue(onMouseUp.called, 'onMouseUp called');
		},

		'touch events'() {
			if (!has('touch')) {
				this.skip('Environment not support touch events');
			}

			const onTouchStart = sinon.stub();
			const onTouchEnd = sinon.stub();
			const onTouchCancel = sinon.stub();

			widget.setProperties({
				onTouchStart,
				onTouchEnd,
				onTouchCancel
			});

			widget.sendEvent('touchstart', { selector: 'input' });
			assert.isTrue(onTouchStart.called, 'onTouchStart called');

add('touch', () => {
	/* Since jsdom will fake it anyways, no problem pretending we can do touch in NodeJS */
	return Boolean('ontouchstart' in window || has('host-node'));
});

import global from '@dojo/shim/global';
import has, { add as hasAdd } from '@dojo/has/has';

hasAdd('btoa', 'btoa' in global, true);
hasAdd('atob', 'atob' in global, true);

/**
 * Take a string encoded in base64 and decode it
 * @param encodedString The base64 encoded string
 */
export const decode: (encodedString: string) => string = has('atob') ? function (encodedString: string) {
	/* this allows for utf8 characters to be decoded properly */
	return decodeURIComponent(Array.prototype.map.call(atob(encodedString), (char: string) => '%' + ('00' + char.charCodeAt(0).toString(16)).slice(-2)).join(''));
} : function (encodedString: string): string {
	return new Buffer(encodedString.toString(), 'base64').toString('utf8');
};

/**
 * Take a string and encode it to base64
 * @param rawString The string to encode
 */
export const encode: (rawString: string) => string = has('btoa') ? function (decodedString: string) {
	/* this allows for utf8 characters to be encoded properly */
	return btoa(encodeURIComponent(decodedString).replace(/%([0-9A-F]{2})/g, (match, code: string) => String.fromCharCode(Number('0x' + code))));
} : function (rawString: string): string {
	return new Buffer(rawString.toString(), 'utf8').toString('base64');
};

const store = new Store<State>();
const registry = new Registry();

const router = registerRouterInjector(getRouteConfig(store), registry);

registry.define('editor', () => import('./containers/EditorContainer'));
registry.define('article', () => import('./containers/ArticleContainer'));
registry.define('login', () => import('./containers/LoginContainer'));
registry.define('register', () => import('./containers/RegisterContainer'));
registry.define('profile', () => import('./containers/ProfileContainer'));
registry.define('settings', () => import('./containers/SettingsContainer'));

let session;

if (!has('build-time-render')) {
	session = global.sessionStorage.getItem('conduit-session');
}

getTagsProcess(store)({});
if (session) {
	setSessionProcess(store)({ session: JSON.parse(session) });
}

router.on('nav', ({ outlet, context }: any) => {
	changeRouteProcess(store)({ outlet, context });
});

function onRouteChange() {
	const outlet = store.get(store.path('routing', 'outlet'));
	const params = store.get(store.path('routing', 'params'));