diff --git a/tests/init.js b/tests/init.js
index b77d049f..d2a9fe5d 100644
--- a/tests/init.js
+++ b/tests/init.js
@@ -30,14 +30,19 @@ require.config({
     baseUrl: (window.__karma__ ? 'base/' : '') + 'www/js/lib/',
     paths: {
         'jquery': 'jquery-3.2.1.slim',
-        'webpHeroBundle': 'webpHeroBundle_0.0.0-dev.27',
-        'webpHeroPolyfills': 'webpHeroPolyfills_0.0.0-dev.27'
+        'webpHeroBundle': 'webpHeroBundle_0.0.0-dev.27'
     },
     shim: {
-        'webpHeroBundle': {
-            deps: ['webpHeroPolyfills']
-        }
+        'webpHeroBundle': ''
     }
 });
 
-requirejs(['../../../tests/tests']);
\ No newline at end of file
+var req = []; // Baseline Require array
+
+// Add polyfills to the Require array only if needed
+if (!('Promise' in self)) req.push('promisePolyfill');
+if (!('from' in Array)) req.push('arrayFromPolyfill');
+
+requirejs(req, function () {
+    requirejs(['../../../tests/tests']);
+});
diff --git a/tests/tests.js b/tests/tests.js
index a9daea39..110af528 100644
--- a/tests/tests.js
+++ b/tests/tests.js
@@ -109,13 +109,13 @@ define(['jquery', 'zimArchive', 'zimDirEntry', 'util', 'uiUtil', 'utf8'],
             var testString3 = "le Couvre-chef Est sur le porte-manteaux";
             var testString4 = "épée";
             var testString5 = '$￥€“«xριστός» †¡Ἀνέστη!”';
-            var testString6 = "Καλά Νερά Μαγνησίας žižek";
+            var testString6 = "Καλά Νερά Μαγνησία žižek";
             assert.equal(util.allCaseFirstLetters(testString1).indexOf("Téléphone") >= 0, true, "The first letter should be uppercase");
             assert.equal(util.allCaseFirstLetters(testString2).indexOf("paris") >= 0, true, "The first letter should be lowercase");
             assert.equal(util.allCaseFirstLetters(testString3).indexOf("Le Couvre-Chef Est Sur Le Porte-Manteaux") >= 0, true, "The first letter of every word should be uppercase");
             assert.equal(util.allCaseFirstLetters(testString4).indexOf("Épée") >= 0, true, "The first letter should be uppercase (with accent)");
             assert.equal(util.allCaseFirstLetters(testString5).indexOf('$￥€“«Xριστός» †¡ἀνέστη!”') >= 0, true, "First non-punctuation/non-currency Unicode letter should be uppercase, second (with breath mark) lowercase");
-            assert.equal(util.allCaseFirstLetters(testString6, "full").indexOf("ΚΑΛΆ ΝΕΡΆ ΜΑΓΝΗΣΊΑΣ ŽIŽEK") >= 0, true, "All Unicode letters should be uppercase");
+            assert.equal(util.allCaseFirstLetters(testString6, "full").indexOf("ΚΑΛΆ ΝΕΡΆ ΜΑΓΝΗΣΊΑ ŽIŽEK") >= 0, true, "All Unicode letters should be uppercase");
         });
         QUnit.test("check removal of parameters in URL", function(assert) {
             var testUrl1 = "A/question.html";
diff --git a/www/js/app.js b/www/js/app.js
index abb7a13e..85d6d511 100644
--- a/www/js/app.js
+++ b/www/js/app.js
@@ -26,8 +26,8 @@
 // This uses require.js to structure javascript:
 // http://requirejs.org/docs/api.html#define
 
-define(['jquery', 'zimArchiveLoader', 'uiUtil', 'settingsStore','abstractFilesystemAccess','q'],
- function($, zimArchiveLoader, uiUtil, settingsStore, abstractFilesystemAccess, Q) {
+define(['jquery', 'zimArchiveLoader', 'uiUtil', 'settingsStore','abstractFilesystemAccess'],
+ function($, zimArchiveLoader, uiUtil, settingsStore, abstractFilesystemAccess) {
      
     /**
      * The delay (in milliseconds) between two "keepalive" messages sent to the ServiceWorker (so that it is not stopped
@@ -475,7 +475,7 @@ define(['jquery', 'zimArchiveLoader', 'uiUtil', 'settingsStore','abstractFilesys
      * @returns {Promise<Object>} A Promise for an object with cache attributes 'type', 'description', and 'count'
      */
     function getCacheAttributes() {
-        return Q.Promise(function (resolve, reject) {
+        return new Promise(function (resolve, reject) {
             if (contentInjectionMode === 'serviceworker') {
                 // Create a Message Channel
                 var channel = new MessageChannel();
@@ -963,26 +963,24 @@ define(['jquery', 'zimArchiveLoader', 'uiUtil', 'settingsStore','abstractFilesys
      * @returns {Promise<Blob>} A promise for the requested file (blob)
      */
     function readRemoteArchive(url) {
-        // DEV: This deferred can't be standardized to a Promise/A+ pattern (using Q) because
-        // IE11 is unable to scope the callbacks inside the Promise correctly. See [kiwix.js #589]
-        var deferred = Q.defer();
-        var request = new XMLHttpRequest();
-        request.open("GET", url);
-        request.responseType = "blob";
-        request.onreadystatechange = function () {
-            if (request.readyState === XMLHttpRequest.DONE) {
-                if (request.status >= 200 && request.status < 300 || request.status === 0) {
-                    // Hack to make this look similar to a file
-                    request.response.name = url;
-                    deferred.resolve(request.response);
-                } else {
-                    deferred.reject("HTTP status " + request.status + " when reading " + url);
+        return new Promise(function (resolve, reject) {
+            var request = new XMLHttpRequest();
+            request.open("GET", url);
+            request.responseType = "blob";
+            request.onreadystatechange = function () {
+                if (request.readyState === XMLHttpRequest.DONE) {
+                    if (request.status >= 200 && request.status < 300 || request.status === 0) {
+                        // Hack to make this look similar to a file
+                        request.response.name = url;
+                        resolve(request.response);
+                    } else {
+                        reject("HTTP status " + request.status + " when reading " + url);
+                    }
                 }
-            }
-        };
-        request.onabort = request.onerror = deferred.reject;
-        request.send();
-        return deferred.promise;
+            };
+            request.onabort = request.onerror = reject;
+            request.send();
+        });
     }
     
     /**
@@ -994,7 +992,7 @@ define(['jquery', 'zimArchiveLoader', 'uiUtil', 'settingsStore','abstractFilesys
         Array.prototype.slice.call(arguments).forEach(function (arg) {
             readRequests.push(readRemoteArchive(arg));
         });
-        return Q.all(readRequests).then(function (arrayOfArchives) {
+        return Promise.all(readRequests).then(function (arrayOfArchives) {
             setLocalArchiveFromFileList(arrayOfArchives);
         }).catch(function (e) {
             console.error('Unable to load remote archive(s)', e);
diff --git a/www/js/init.js b/www/js/init.js
index eb2f149a..5cd2c49b 100644
--- a/www/js/init.js
+++ b/www/js/init.js
@@ -36,7 +36,6 @@ require.config({
         'jquery': 'jquery-3.2.1.slim',
         'bootstrap': 'bootstrap.bundle',
         'webpHeroBundle': 'webpHeroBundle_0.0.0-dev.27',
-        'webpHeroPolyfills': 'webpHeroPolyfills_0.0.0-dev.27',
         'fontawesome': 'fontawesome/fontawesome',
         'fontawesome-solid': 'fontawesome/solid'
     },
@@ -47,13 +46,17 @@ require.config({
         'bootstrap': {
             deps: ['jquery', 'fontawesome', 'fontawesome-solid']
         },
-        'webpHeroBundle': {
-            deps: ['webpHeroPolyfills']
-        }
+        'webpHeroBundle': ''
     }
 });
 
-requirejs(['bootstrap'], function (bootstrap) {
+var req = ['bootstrap']; // Baseline Require array
+
+// Add polyfills to the Require array only if needed
+if (!('Promise' in self)) req.push('promisePolyfill');
+if (!('from' in Array)) req.push('arrayFromPolyfill');
+
+requirejs(req, function () {
     requirejs(['../app']);
 });
 
diff --git a/www/js/lib/abstractFilesystemAccess.js b/www/js/lib/abstractFilesystemAccess.js
index 088a8d96..b48eb010 100644
--- a/www/js/lib/abstractFilesystemAccess.js
+++ b/www/js/lib/abstractFilesystemAccess.js
@@ -25,7 +25,7 @@
  * along with Kiwix (file LICENSE-GPLv3.txt).  If not, see <http://www.gnu.org/licenses/>
  */
 'use strict';
-define(['q', 'jquery'], function(q, jQuery) {
+define([], function() {
     
     /**
      * Storage implemented by Firefox OS
@@ -50,11 +50,12 @@ define(['q', 'jquery'], function(q, jQuery) {
      *         rejected with an error message.
      */
     StorageFirefoxOS.prototype.get = function(path) {
-        var deferred = q.defer();
-        var request = this._storage.get(path);
-        request.onsuccess = function() { deferred.resolve(this.result); };
-        request.onerror = function() { deferred.reject(this.error.name); };
-        return deferred.promise;
+        var that = this;
+        return new Promise(function (resolve, reject){
+            var request = that._storage.get(path);
+            request.onsuccess = function() { resolve(this.result); };
+            request.onerror = function() { reject(this.error.name); };
+        });
     };
     
     // We try to match both a standalone ZIM file (.zim) or
@@ -67,26 +68,27 @@ define(['q', 'jquery'], function(q, jQuery) {
      *         paths and rejected with an error message.
      */
     StorageFirefoxOS.prototype.scanForArchives = function() {
-        var deferred = jQuery.Deferred();
-        var directories = [];
-        var cursor = this._storage.enumerate();
-        cursor.onerror = function() {
-            deferred.reject(cursor.error);
-        };
-        cursor.onsuccess = function() {
-            if (!cursor.result) {
-                deferred.resolve(directories);
-                return;
-            }
-            var file = cursor.result;
+        var that = this;
+        return new Promise(function (resolve, reject){
+            var directories = [];
+            var cursor = that._storage.enumerate();
+            cursor.onerror = function () {
+                reject(cursor.error);
+            };
+            cursor.onsuccess = function () {
+                if (!cursor.result) {
+                    resolve(directories);
+                    return;
+                }
+                var file = cursor.result;
 
-            if (regexpZIMFileName.test(file.name)) {
-                directories.push(file.name);
-            }
+                if (regexpZIMFileName.test(file.name)) {
+                    directories.push(file.name);
+                }
 
-            cursor.continue();
-        };
-        return deferred.promise();
+                cursor.continue();
+            };
+        });
     };
     
     /**
diff --git a/www/js/lib/arrayFromPolyfill.js b/www/js/lib/arrayFromPolyfill.js
new file mode 100644
index 00000000..6e2c11e2
--- /dev/null
+++ b/www/js/lib/arrayFromPolyfill.js
@@ -0,0 +1,33 @@
+/**
+ * Simple Array.from polyfill (with Set support) from https://stackoverflow.com/a/62682524/9727685
+ */
+(function () {
+
+	function arrayFrom(arr, callbackFn, thisArg) {
+		//if you need you can uncomment the following line
+		//if(!arr || typeof arr == 'function')throw new Error('This function requires an array-like object - not null, undefined or a function');
+
+		var arNew = [],
+			k = [], // used for convert Set to an Array
+			i = 0;
+
+		//if you do not need a Set object support then
+		//you can comment or delete the following if statement
+		if (window.Set && arr instanceof Set) {
+			//we use forEach from Set object
+			arr.forEach(function (v) {
+				k.push(v)
+			});
+			arr = k;
+		}
+
+		for (; i < arr.length; i++)
+			arNew[i] = callbackFn ?
+			callbackFn.call(thisArg, arr[i], i, arr) :
+			arr[i];
+
+		return arNew;
+	}
+	//You could also use it without the following line, but it is not recommended because native function is faster.
+	Array.from = Array.from || arrayFrom; //We set it as polyfill
+}());
\ No newline at end of file
diff --git a/www/js/lib/filecache.js b/www/js/lib/filecache.js
index f3bb87fa..040d3bf2 100644
--- a/www/js/lib/filecache.js
+++ b/www/js/lib/filecache.js
@@ -23,7 +23,7 @@
  */
 'use strict';
 
-define(['q'], function (Q) {
+define([], function () {
     /**
      * Set maximum number of cache blocks of BLOCK_SIZE bytes each
      * Maximum size of cache in bytes = MAX_CACHE_SIZE * BLOCK_SIZE
@@ -166,7 +166,7 @@ define(['q'], function (Q) {
         //     misses = 0;
         // }
         // Wait for all the blocks to be read either from the cache or from the archive
-        return Q.all(readRequests).then(function () {
+        return Promise.all(readRequests).then(function () {
             var result = new Uint8Array(end - begin);
             var pos = 0;
             // Stitch together the data parts in the right order
diff --git a/www/js/lib/promisePolyfill.js b/www/js/lib/promisePolyfill.js
new file mode 100644
index 00000000..734ff750
--- /dev/null
+++ b/www/js/lib/promisePolyfill.js
@@ -0,0 +1,878 @@
+/*
+	Yaku v0.19.3
+	(c) 2015 Yad Smood. http://ysmood.org
+	License MIT
+*/
+/*
+	Yaku v0.17.9
+	(c) 2015 Yad Smood. http://ysmood.org
+	License MIT
+*/
+
+(function () {
+	'use strict';
+
+	var $undefined
+	, $null = null
+	, isBrowser = typeof self === 'object'
+	, root = self
+	, nativePromise = root.Promise
+	, process = root.process
+	, console = root.console
+	, isLongStackTrace = true
+	, Arr = Array
+	, Err = Error
+
+	, $rejected = 1
+	, $resolved = 2
+	, $pending = 3
+
+	, $Symbol = 'Symbol'
+	, $iterator = 'iterator'
+	, $species = 'species'
+	, $speciesKey = $Symbol + '(' + $species + ')'
+	, $return = 'return'
+
+	, $unhandled = '_uh'
+	, $promiseTrace = '_pt'
+	, $settlerTrace = '_st'
+
+	, $invalidThis = 'Invalid this'
+	, $invalidArgument = 'Invalid argument'
+	, $fromPrevious = '\nFrom previous '
+	, $promiseCircularChain = 'Chaining cycle detected for promise'
+	, $unhandledRejectionMsg = 'Uncaught (in promise)'
+	, $rejectionHandled = 'rejectionHandled'
+	, $unhandledRejection = 'unhandledRejection'
+
+	, $tryCatchFn
+	, $tryCatchThis
+	, $tryErr = { e: $null }
+	, $noop = function () {}
+	, $cleanStackReg = /^.+\/node_modules\/yaku\/.+\n?/mg
+	;
+
+	/**
+	* This class follows the [Promises/A+](https://promisesaplus.com) and
+	* [ES6](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-promise-objects) spec
+	* with some extra helpers.
+	* @param  {Function} executor Function object with two arguments resolve, reject.
+	* The first argument fulfills the promise, the second argument rejects it.
+	* We can call these functions, once our operation is completed.
+	*/
+	var Yaku = function (executor) {
+	var self = this,
+		err;
+
+	// "this._s" is the internao state of: pending, resolved or rejected
+	// "this._v" is the internal value
+
+	if (!isObject(self) || self._s !== $undefined)
+		throw genTypeError($invalidThis);
+
+	self._s = $pending;
+
+	if (isLongStackTrace) self[$promiseTrace] = genTraceInfo();
+
+	if (executor !== $noop) {
+		if (!isFunction(executor))
+			throw genTypeError($invalidArgument);
+
+		err = genTryCatcher(executor)(
+			genSettler(self, $resolved),
+			genSettler(self, $rejected)
+		);
+
+		if (err === $tryErr)
+			settlePromise(self, $rejected, err.e);
+	}
+	};
+
+	Yaku['default'] = Yaku;
+
+	extend(Yaku.prototype, {
+	/**
+		* Appends fulfillment and rejection handlers to the promise,
+		* and returns a new promise resolving to the return value of the called handler.
+		* @param  {Function} onFulfilled Optional. Called when the Promise is resolved.
+		* @param  {Function} onRejected  Optional. Called when the Promise is rejected.
+		* @return {Yaku} It will return a new Yaku which will resolve or reject after
+		* @example
+		* the current Promise.
+		* ```js
+		* var Promise = require('yaku');
+		* var p = Promise.resolve(10);
+		*
+		* p.then((v) => {
+		*     console.log(v);
+		* });
+		* ```
+		*/
+	then: function (onFulfilled, onRejected) {
+		if (this._s === undefined) throw genTypeError();
+
+		return addHandler(
+			this,
+			newCapablePromise(Yaku.speciesConstructor(this, Yaku)),
+			onFulfilled,
+			onRejected
+		);
+	},
+
+	/**
+		* The `catch()` method returns a Promise and deals with rejected cases only.
+		* It behaves the same as calling `Promise.prototype.then(undefined, onRejected)`.
+		* @param  {Function} onRejected A Function called when the Promise is rejected.
+		* This function has one argument, the rejection reason.
+		* @return {Yaku} A Promise that deals with rejected cases only.
+		* @example
+		* ```js
+		* var Promise = require('yaku');
+		* var p = Promise.reject(new Error("ERR"));
+		*
+		* p['catch']((v) => {
+		*     console.log(v);
+		* });
+		* ```
+		*/
+	'catch': function (onRejected) {
+		return this.then($undefined, onRejected);
+	},
+
+	/**
+		* Register a callback to be invoked when a promise is settled (either fulfilled or rejected).
+		* Similar with the try-catch-finally, it's often used for cleanup.
+		* @param  {Function} onFinally A Function called when the Promise is settled.
+		* It will not receive any argument.
+		* @return {Yaku} A Promise that will reject if onFinally throws an error or returns a rejected promise.
+		* Else it will resolve previous promise's final state (either fulfilled or rejected).
+		* @example
+		* ```js
+		* var Promise = require('yaku');
+		* var p = Math.random() > 0.5 ? Promise.resolve() : Promise.reject();
+		* p.finally(() => {
+		*     console.log('finally');
+		* });
+		* ```
+		*/
+	'finally': function (onFinally) {
+		return this.then(function (val) {
+			return Yaku.resolve(onFinally()).then(function () {
+				return val;
+			});
+		}, function (err) {
+			return Yaku.resolve(onFinally()).then(function () {
+				throw err;
+			});
+		});
+	},
+
+	// The number of current promises that attach to this Yaku instance.
+	_c: 0,
+
+	// The parent Yaku.
+	_p: $null
+	});
+
+	/**
+	* The `Promise.resolve(value)` method returns a Promise object that is resolved with the given value.
+	* If the value is a thenable (i.e. has a then method), the returned promise will "follow" that thenable,
+	* adopting its eventual state; otherwise the returned promise will be fulfilled with the value.
+	* @param  {Any} value Argument to be resolved by this Promise.
+	* Can also be a Promise or a thenable to resolve.
+	* @return {Yaku}
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* var p = Promise.resolve(10);
+	* ```
+	*/
+	Yaku.resolve = function (val) {
+	return isYaku(val) ? val : settleWithX(newCapablePromise(this), val);
+	};
+
+	/**
+	* The `Promise.reject(reason)` method returns a Promise object that is rejected with the given reason.
+	* @param  {Any} reason Reason why this Promise rejected.
+	* @return {Yaku}
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* var p = Promise.reject(new Error("ERR"));
+	* ```
+	*/
+	Yaku.reject = function (reason) {
+	return settlePromise(newCapablePromise(this), $rejected, reason);
+	};
+
+	/**
+	* The `Promise.race(iterable)` method returns a promise that resolves or rejects
+	* as soon as one of the promises in the iterable resolves or rejects,
+	* with the value or reason from that promise.
+	* @param  {iterable} iterable An iterable object, such as an Array.
+	* @return {Yaku} The race function returns a Promise that is settled
+	* the same way as the first passed promise to settle.
+	* It resolves or rejects, whichever happens first.
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.race([
+	*     123,
+	*     Promise.resolve(0)
+	* ])
+	* .then((value) => {
+	*     console.log(value); // => 123
+	* });
+	* ```
+	*/
+	Yaku.race = function (iterable) {
+	var self = this
+		, p = newCapablePromise(self)
+
+		, resolve = function (val) {
+			settlePromise(p, $resolved, val);
+		}
+
+		, reject = function (val) {
+			settlePromise(p, $rejected, val);
+		}
+
+		, ret = genTryCatcher(each)(iterable, function (v) {
+			self.resolve(v).then(resolve, reject);
+		});
+
+	if (ret === $tryErr) return self.reject(ret.e);
+
+	return p;
+	};
+
+	/**
+	* The `Promise.all(iterable)` method returns a promise that resolves when
+	* all of the promises in the iterable argument have resolved.
+	*
+	* The result is passed as an array of values from all the promises.
+	* If something passed in the iterable array is not a promise,
+	* it's converted to one by Promise.resolve. If any of the passed in promises rejects,
+	* the all Promise immediately rejects with the value of the promise that rejected,
+	* discarding all the other promises whether or not they have resolved.
+	* @param  {iterable} iterable An iterable object, such as an Array.
+	* @return {Yaku}
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.all([
+	*     123,
+	*     Promise.resolve(0)
+	* ])
+	* .then((values) => {
+	*     console.log(values); // => [123, 0]
+	* });
+	* ```
+	* @example
+	* Use with iterable.
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.all((function * () {
+	*     yield 10;
+	*     yield new Promise(function (r) { setTimeout(r, 1000, "OK") });
+	* })())
+	* .then((values) => {
+	*     console.log(values); // => [123, 0]
+	* });
+	* ```
+	*/
+	Yaku.all = function (iterable) {
+	var self = this
+		, p1 = newCapablePromise(self)
+		, res = []
+		, ret
+	;
+
+	function reject (reason) {
+		settlePromise(p1, $rejected, reason);
+	}
+
+	ret = genTryCatcher(each)(iterable, function (item, i) {
+		self.resolve(item).then(function (value) {
+			res[i] = value;
+			if (!--ret) settlePromise(p1, $resolved, res);
+		}, reject);
+	});
+
+	if (ret === $tryErr) return self.reject(ret.e);
+
+	if (!ret) settlePromise(p1, $resolved, []);
+
+	return p1;
+	};
+
+	/**
+	* The ES6 Symbol object that Yaku should use, by default it will use the
+	* global one.
+	* @type {Object}
+	* @example
+	* ```js
+	* var core = require("core-js/library");
+	* var Promise = require("yaku");
+	* Promise.Symbol = core.Symbol;
+	* ```
+	*/
+	Yaku.Symbol = root[$Symbol] || {};
+
+	// To support browsers that don't support `Object.defineProperty`.
+	genTryCatcher(function () {
+	Object.defineProperty(Yaku, getSpecies(), {
+		get: function () { return this; }
+	});
+	})();
+
+	/**
+	* Use this api to custom the species behavior.
+	* https://tc39.github.io/ecma262/#sec-speciesconstructor
+	* @param {Any} O The current this object.
+	* @param {Function} defaultConstructor
+	*/
+	Yaku.speciesConstructor = function (O, D) {
+	var C = O.constructor;
+
+	return C ? (C[getSpecies()] || D) : D;
+	};
+
+	/**
+	* Catch all possibly unhandled rejections. If you want to use specific
+	* format to display the error stack, overwrite it.
+	* If it is set, auto `console.error` unhandled rejection will be disabled.
+	* @param {Any} reason The rejection reason.
+	* @param {Yaku} p The promise that was rejected.
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.unhandledRejection = (reason) => {
+	*     console.error(reason);
+	* };
+	*
+	* // The console will log an unhandled rejection error message.
+	* Promise.reject('my reason');
+	*
+	* // The below won't log the unhandled rejection error message.
+	* Promise.reject('v')["catch"](() => {});
+	* ```
+	*/
+	Yaku.unhandledRejection = function (reason, p) {
+	console && console.error(
+		$unhandledRejectionMsg,
+		isLongStackTrace ? p.longStack : genStackInfo(reason, p)
+	);
+	};
+
+	/**
+	* Emitted whenever a Promise was rejected and an error handler was
+	* attached to it (for example with `["catch"]()`) later than after an event loop turn.
+	* @param {Any} reason The rejection reason.
+	* @param {Yaku} p The promise that was rejected.
+	*/
+	Yaku.rejectionHandled = $noop;
+
+	/**
+	* It is used to enable the long stack trace.
+	* Once it is enabled, it can't be reverted.
+	* While it is very helpful in development and testing environments,
+	* it is not recommended to use it in production. It will slow down
+	* application and eat up memory.
+	* It will add an extra property `longStack` to the Error object.
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.enableLongStackTrace();
+	* Promise.reject(new Error("err"))["catch"]((err) => {
+	*     console.log(err.longStack);
+	* });
+	* ```
+	*/
+	Yaku.enableLongStackTrace = function () {
+	isLongStackTrace = true;
+	};
+
+	/**
+	* Only Node has `process.nextTick` function. For browser there are
+	* so many ways to polyfill it. Yaku won't do it for you, instead you
+	* can choose what you prefer. For example, this project
+	* [next-tick](https://github.com/medikoo/next-tick).
+	* By default, Yaku will use `process.nextTick` on Node, `setTimeout` on browser.
+	* @type {Function}
+	* @example
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.nextTick = require('next-tick');
+	* ```
+	* @example
+	* You can even use sync resolution if you really know what you are doing.
+	* ```js
+	* var Promise = require('yaku');
+	* Promise.nextTick = fn => fn();
+	* ```
+	*/
+	Yaku.nextTick = isBrowser ?
+	function (fn) {
+		nativePromise ?
+			new nativePromise(function (resolve) { resolve(); }).then(fn) :
+			setTimeout(fn);
+	} :
+	process.nextTick;
+
+	// ********************** Private **********************
+
+	Yaku._s = 1;
+
+	/**
+	* All static variable name will begin with `$`. Such as `$rejected`.
+	* @private
+	*/
+
+	// ******************************* Utils ********************************
+
+	function getSpecies () {
+	return Yaku[$Symbol][$species] || $speciesKey;
+	}
+
+	function extend (src, target) {
+	for (var k in target) {
+		src[k] = target[k];
+	}
+	}
+
+	function isObject (obj) {
+	return obj && typeof obj === 'object';
+	}
+
+	function isFunction (obj) {
+	return typeof obj === 'function';
+	}
+
+	function isInstanceOf (a, b) {
+	return a instanceof b;
+	}
+
+	function isError (obj) {
+	return isInstanceOf(obj, Err);
+	}
+
+	function ensureType (obj, fn, msg) {
+	if (!fn(obj)) throw genTypeError(msg);
+	}
+
+	/**
+	* Wrap a function into a try-catch.
+	* @private
+	* @return {Any | $tryErr}
+	*/
+	function tryCatcher () {
+	try {
+		return $tryCatchFn.apply($tryCatchThis, arguments);
+	} catch (e) {
+		$tryErr.e = e;
+		return $tryErr;
+	}
+	}
+
+	/**
+	* Generate a try-catch wrapped function.
+	* @private
+	* @param  {Function} fn
+	* @return {Function}
+	*/
+	function genTryCatcher (fn, self) {
+	$tryCatchFn = fn;
+	$tryCatchThis = self;
+	return tryCatcher;
+	}
+
+	/**
+	* Generate a scheduler.
+	* @private
+	* @param  {Integer}  initQueueSize
+	* @param  {Function} fn `(Yaku, Value) ->` The schedule handler.
+	* @return {Function} `(Yaku, Value) ->` The scheduler.
+	*/
+	function genScheduler (initQueueSize, fn) {
+	/**
+		* All async promise will be scheduled in
+		* here, so that they can be execute on the next tick.
+		* @private
+		*/
+	var fnQueue = Arr(initQueueSize)
+		, fnQueueLen = 0;
+
+	/**
+		* Run all queued functions.
+		* @private
+		*/
+	function flush () {
+		var i = 0;
+		while (i < fnQueueLen) {
+			fn(fnQueue[i], fnQueue[i + 1]);
+			fnQueue[i++] = $undefined;
+			fnQueue[i++] = $undefined;
+		}
+
+		fnQueueLen = 0;
+		if (fnQueue.length > initQueueSize) fnQueue.length = initQueueSize;
+	}
+
+	return function (v, arg) {
+		fnQueue[fnQueueLen++] = v;
+		fnQueue[fnQueueLen++] = arg;
+
+		if (fnQueueLen === 2) Yaku.nextTick(flush);
+	};
+	}
+
+	/**
+	* Generate a iterator
+	* @param  {Any} obj
+	* @private
+	* @return {Object || TypeError}
+	*/
+	function each (iterable, fn) {
+	var len
+		, i = 0
+		, iter
+		, item
+		, ret
+	;
+
+	if (!iterable) throw genTypeError($invalidArgument);
+
+	var gen = iterable[Yaku[$Symbol][$iterator]];
+	if (isFunction(gen))
+		iter = gen.call(iterable);
+	else if (isFunction(iterable.next)) {
+		iter = iterable;
+	}
+	else if (isInstanceOf(iterable, Arr)) {
+		len = iterable.length;
+		while (i < len) {
+			fn(iterable[i], i++);
+		}
+		return i;
+	} else
+		throw genTypeError($invalidArgument);
+
+	while (!(item = iter.next()).done) {
+		ret = genTryCatcher(fn)(item.value, i++);
+		if (ret === $tryErr) {
+			isFunction(iter[$return]) && iter[$return]();
+			throw ret.e;
+		}
+	}
+
+	return i;
+	}
+
+	/**
+	* Generate type error object.
+	* @private
+	* @param  {String} msg
+	* @return {TypeError}
+	*/
+	function genTypeError (msg) {
+	return new TypeError(msg);
+	}
+
+	function genTraceInfo (noTitle) {
+	return (noTitle ? '' : $fromPrevious) + new Err().stack;
+	}
+
+
+	// *************************** Promise Helpers ****************************
+
+	/**
+	* Resolve the value returned by onFulfilled or onRejected.
+	* @private
+	* @param {Yaku} p1
+	* @param {Yaku} p2
+	*/
+	var scheduleHandler = genScheduler(999, function (p1, p2) {
+	var x, handler;
+
+	// 2.2.2
+	// 2.2.3
+	handler = p1._s !== $rejected ? p2._onFulfilled : p2._onRejected;
+
+	// 2.2.7.3
+	// 2.2.7.4
+	if (handler === $undefined) {
+		settlePromise(p2, p1._s, p1._v);
+		return;
+	}
+
+	// 2.2.7.1
+	x = genTryCatcher(callHanler)(handler, p1._v);
+	if (x === $tryErr) {
+		// 2.2.7.2
+		settlePromise(p2, $rejected, x.e);
+		return;
+	}
+
+	settleWithX(p2, x);
+	});
+
+	var scheduleUnhandledRejection = genScheduler(9, function (p) {
+	if (!hashOnRejected(p)) {
+		p[$unhandled] = 1;
+		emitEvent($unhandledRejection, p);
+	}
+	});
+
+	function emitEvent (name, p) {
+	var browserEventName = 'on' + name.toLowerCase()
+		, browserHandler = root[browserEventName];
+
+	if (process && process.listeners(name).length)
+		name === $unhandledRejection ?
+			process.emit(name, p._v, p) : process.emit(name, p);
+	else if (browserHandler)
+		browserHandler({ reason: p._v, promise: p });
+	else
+		Yaku[name](p._v, p);
+	}
+
+	function isYaku (val) { return val && val._s; }
+
+	function newCapablePromise (Constructor) {
+	if (isYaku(Constructor)) return new Constructor($noop);
+
+	var p, r, j;
+	p = new Constructor(function (resolve, reject) {
+		if (p) throw genTypeError();
+
+		r = resolve;
+		j = reject;
+	});
+
+	ensureType(r, isFunction);
+	ensureType(j, isFunction);
+
+	return p;
+	}
+
+	/**
+	* It will produce a settlePromise function to user.
+	* Such as the resolve and reject in this `new Yaku (resolve, reject) ->`.
+	* @private
+	* @param  {Yaku} self
+	* @param  {Integer} state The value is one of `$pending`, `$resolved` or `$rejected`.
+	* @return {Function} `(value) -> undefined` A resolve or reject function.
+	*/
+	function genSettler (self, state) {
+	var isCalled = false;
+	return function (value) {
+		if (isCalled) return;
+		isCalled = true;
+
+		if (isLongStackTrace)
+			self[$settlerTrace] = genTraceInfo(true);
+
+		if (state === $resolved)
+			settleWithX(self, value);
+		else
+			settlePromise(self, state, value);
+	};
+	}
+
+	/**
+	* Link the promise1 to the promise2.
+	* @private
+	* @param {Yaku} p1
+	* @param {Yaku} p2
+	* @param {Function} onFulfilled
+	* @param {Function} onRejected
+	*/
+	function addHandler (p1, p2, onFulfilled, onRejected) {
+	// 2.2.1
+	if (isFunction(onFulfilled))
+		p2._onFulfilled = onFulfilled;
+	if (isFunction(onRejected)) {
+		if (p1[$unhandled]) emitEvent($rejectionHandled, p1);
+
+		p2._onRejected = onRejected;
+	}
+
+	if (isLongStackTrace) p2._p = p1;
+	p1[p1._c++] = p2;
+
+	// 2.2.6
+	if (p1._s !== $pending)
+		scheduleHandler(p1, p2);
+
+	// 2.2.7
+	return p2;
+	}
+
+	// iterate tree
+	function hashOnRejected (node) {
+	// A node shouldn't be checked twice.
+	if (node._umark)
+		return true;
+	else
+		node._umark = true;
+
+	var i = 0
+		, len = node._c
+		, child;
+
+	while (i < len) {
+		child = node[i++];
+		if (child._onRejected || hashOnRejected(child)) return true;
+	}
+	}
+
+	function genStackInfo (reason, p) {
+	var stackInfo = [];
+
+	function push (trace) {
+		return stackInfo.push(trace.replace(/^\s+|\s+$/g, ''));
+	}
+
+	if (isLongStackTrace) {
+		if (p[$settlerTrace])
+			push(p[$settlerTrace]);
+
+		// Hope you guys could understand how the back trace works.
+		// We only have to iterate through the tree from the bottom to root.
+		(function iter (node) {
+			if (node && $promiseTrace in node) {
+				iter(node._next);
+				push(node[$promiseTrace] + '');
+				iter(node._p);
+			}
+		})(p);
+	}
+
+	return (reason && reason.stack ? reason.stack : reason) +
+		('\n' + stackInfo.join('\n')).replace($cleanStackReg, '');
+	}
+
+	function callHanler (handler, value) {
+	// 2.2.5
+	return handler(value);
+	}
+
+	/**
+	* Resolve or reject a promise.
+	* @private
+	* @param  {Yaku} p
+	* @param  {Integer} state
+	* @param  {Any} value
+	*/
+	function settlePromise (p, state, value) {
+	var i = 0
+		, len = p._c;
+
+	// 2.1.2
+	// 2.1.3
+	if (p._s === $pending) {
+		// 2.1.1.1
+		p._s = state;
+		p._v = value;
+
+		if (state === $rejected) {
+			if (isLongStackTrace && isError(value)) {
+				value.longStack = genStackInfo(value, p);
+			}
+
+			scheduleUnhandledRejection(p);
+		}
+
+		// 2.2.4
+		while (i < len) {
+			scheduleHandler(p, p[i++]);
+		}
+	}
+
+	return p;
+	}
+
+	/**
+	* Resolve or reject promise with value x. The x can also be a thenable.
+	* @private
+	* @param {Yaku} p
+	* @param {Any | Thenable} x A normal value or a thenable.
+	*/
+	function settleWithX (p, x) {
+	// 2.3.1
+	if (x === p && x) {
+		settlePromise(p, $rejected, genTypeError($promiseCircularChain));
+		return p;
+	}
+
+	// 2.3.2
+	// 2.3.3
+	if (x !== $null && (isFunction(x) || isObject(x))) {
+		// 2.3.2.1
+		var xthen = genTryCatcher(getThen)(x);
+
+		if (xthen === $tryErr) {
+			// 2.3.3.2
+			settlePromise(p, $rejected, xthen.e);
+			return p;
+		}
+
+		if (isFunction(xthen)) {
+			if (isLongStackTrace && isYaku(x))
+				p._next = x;
+
+			// Fix https://bugs.chromium.org/p/v8/issues/detail?id=4162
+			if (isYaku(x))
+				settleXthen(p, x, xthen);
+			else
+				Yaku.nextTick(function () {
+					settleXthen(p, x, xthen);
+				});
+		} else
+			// 2.3.3.4
+			settlePromise(p, $resolved, x);
+	} else
+		// 2.3.4
+		settlePromise(p, $resolved, x);
+
+	return p;
+	}
+
+	/**
+	* Try to get a promise's then method.
+	* @private
+	* @param  {Thenable} x
+	* @return {Function}
+	*/
+	function getThen (x) { return x.then; }
+
+	/**
+	* Resolve then with its promise.
+	* @private
+	* @param  {Yaku} p
+	* @param  {Thenable} x
+	* @param  {Function} xthen
+	*/
+	function settleXthen (p, x, xthen) {
+	// 2.3.3.3
+	var err = genTryCatcher(xthen, x)(function (y) {
+		// 2.3.3.3.3
+		// 2.3.3.3.1
+		x && (x = $null, settleWithX(p, y));
+	}, function (r) {
+		// 2.3.3.3.3
+		// 2.3.3.3.2
+		x && (x = $null, settlePromise(p, $rejected, r));
+	});
+
+	// 2.3.3.3.4.1
+	if (err === $tryErr && x) {
+		// 2.3.3.3.4.2
+		settlePromise(p, $rejected, err.e);
+		x = $null;
+	}
+	}
+
+	root.Promise = Yaku;
+})();
diff --git a/www/js/lib/q.js b/www/js/lib/q.js
deleted file mode 100644
index 6e467958..00000000
--- a/www/js/lib/q.js
+++ /dev/null
@@ -1,2076 +0,0 @@
-// vim:ts=4:sts=4:sw=4:
-/*!
- *
- * Copyright 2009-2017 Kris Kowal under the terms of the MIT
- * license found at https://github.com/kriskowal/q/blob/v1/LICENSE
- *
- * With parts by Tyler Close
- * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
- * at http://www.opensource.org/licenses/mit-license.html
- * Forked at ref_send.js version: 2009-05-11
- *
- * With parts by Mark Miller
- * Copyright (C) 2011 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-(function (definition) {
-    "use strict";
-
-    // This file will function properly as a <script> tag, or a module
-    // using CommonJS and NodeJS or RequireJS module formats.  In
-    // Common/Node/RequireJS, the module exports the Q API and when
-    // executed as a simple <script>, it creates a Q global instead.
-
-    // Montage Require
-    if (typeof bootstrap === "function") {
-        bootstrap("promise", definition);
-
-    // CommonJS
-    } else if (typeof exports === "object" && typeof module === "object") {
-        module.exports = definition();
-
-    // RequireJS
-    } else if (typeof define === "function" && define.amd) {
-        define(definition);
-
-    // SES (Secure EcmaScript)
-    } else if (typeof ses !== "undefined") {
-        if (!ses.ok()) {
-            return;
-        } else {
-            ses.makeQ = definition;
-        }
-
-    // <script>
-    } else if (typeof window !== "undefined" || typeof self !== "undefined") {
-        // Prefer window over self for add-on scripts. Use self for
-        // non-windowed contexts.
-        var global = typeof window !== "undefined" ? window : self;
-
-        // Get the `window` object, save the previous Q global
-        // and initialize Q as a global.
-        var previousQ = global.Q;
-        global.Q = definition();
-
-        // Add a noConflict function so Q can be removed from the
-        // global namespace.
-        global.Q.noConflict = function () {
-            global.Q = previousQ;
-            return this;
-        };
-
-    } else {
-        throw new Error("This environment was not anticipated by Q. Please file a bug.");
-    }
-
-})(function () {
-"use strict";
-
-var hasStacks = false;
-try {
-    throw new Error();
-} catch (e) {
-    hasStacks = !!e.stack;
-}
-
-// All code after this point will be filtered from stack traces reported
-// by Q.
-var qStartingLine = captureLine();
-var qFileName;
-
-// shims
-
-// used for fallback in "allResolved"
-var noop = function () {};
-
-// Use the fastest possible means to execute a task in a future turn
-// of the event loop.
-var nextTick =(function () {
-    // linked list of tasks (single, with head node)
-    var head = {task: void 0, next: null};
-    var tail = head;
-    var flushing = false;
-    var requestTick = void 0;
-    var isNodeJS = false;
-    // queue for late tasks, used by unhandled rejection tracking
-    var laterQueue = [];
-
-    function flush() {
-        /* jshint loopfunc: true */
-        var task, domain;
-
-        while (head.next) {
-            head = head.next;
-            task = head.task;
-            head.task = void 0;
-            domain = head.domain;
-
-            if (domain) {
-                head.domain = void 0;
-                domain.enter();
-            }
-            runSingle(task, domain);
-
-        }
-        while (laterQueue.length) {
-            task = laterQueue.pop();
-            runSingle(task);
-        }
-        flushing = false;
-    }
-    // runs a single function in the async queue
-    function runSingle(task, domain) {
-        try {
-            task();
-
-        } catch (e) {
-            if (isNodeJS) {
-                // In node, uncaught exceptions are considered fatal errors.
-                // Re-throw them synchronously to interrupt flushing!
-
-                // Ensure continuation if the uncaught exception is suppressed
-                // listening "uncaughtException" events (as domains does).
-                // Continue in next event to avoid tick recursion.
-                if (domain) {
-                    domain.exit();
-                }
-                setTimeout(flush, 0);
-                if (domain) {
-                    domain.enter();
-                }
-
-                throw e;
-
-            } else {
-                // In browsers, uncaught exceptions are not fatal.
-                // Re-throw them asynchronously to avoid slow-downs.
-                setTimeout(function () {
-                    throw e;
-                }, 0);
-            }
-        }
-
-        if (domain) {
-            domain.exit();
-        }
-    }
-
-    nextTick = function (task) {
-        tail = tail.next = {
-            task: task,
-            domain: isNodeJS && process.domain,
-            next: null
-        };
-
-        if (!flushing) {
-            flushing = true;
-            requestTick();
-        }
-    };
-
-    if (typeof process === "object" &&
-        process.toString() === "[object process]" && process.nextTick) {
-        // Ensure Q is in a real Node environment, with a `process.nextTick`.
-        // To see through fake Node environments:
-        // * Mocha test runner - exposes a `process` global without a `nextTick`
-        // * Browserify - exposes a `process.nexTick` function that uses
-        //   `setTimeout`. In this case `setImmediate` is preferred because
-        //    it is faster. Browserify's `process.toString()` yields
-        //   "[object Object]", while in a real Node environment
-        //   `process.toString()` yields "[object process]".
-        isNodeJS = true;
-
-        requestTick = function () {
-            process.nextTick(flush);
-        };
-
-    } else if (typeof setImmediate === "function") {
-        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
-        if (typeof window !== "undefined") {
-            requestTick = setImmediate.bind(window, flush);
-        } else {
-            requestTick = function () {
-                setImmediate(flush);
-            };
-        }
-
-    } else if (typeof MessageChannel !== "undefined") {
-        // modern browsers
-        // http://www.nonblocking.io/2011/06/windownexttick.html
-        var channel = new MessageChannel();
-        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
-        // working message ports the first time a page loads.
-        channel.port1.onmessage = function () {
-            requestTick = requestPortTick;
-            channel.port1.onmessage = flush;
-            flush();
-        };
-        var requestPortTick = function () {
-            // Opera requires us to provide a message payload, regardless of
-            // whether we use it.
-            channel.port2.postMessage(0);
-        };
-        requestTick = function () {
-            setTimeout(flush, 0);
-            requestPortTick();
-        };
-
-    } else {
-        // old browsers
-        requestTick = function () {
-            setTimeout(flush, 0);
-        };
-    }
-    // runs a task after all other tasks have been run
-    // this is useful for unhandled rejection tracking that needs to happen
-    // after all `then`d tasks have been run.
-    nextTick.runAfter = function (task) {
-        laterQueue.push(task);
-        if (!flushing) {
-            flushing = true;
-            requestTick();
-        }
-    };
-    return nextTick;
-})();
-
-// Attempt to make generics safe in the face of downstream
-// modifications.
-// There is no situation where this is necessary.
-// If you need a security guarantee, these primordials need to be
-// deeply frozen anyway, and if you don’t need a security guarantee,
-// this is just plain paranoid.
-// However, this **might** have the nice side-effect of reducing the size of
-// the minified code by reducing x.call() to merely x()
-// See Mark Miller’s explanation of what this does.
-// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
-var call = Function.call;
-function uncurryThis(f) {
-    return function () {
-        return call.apply(f, arguments);
-    };
-}
-// This is equivalent, but slower:
-// uncurryThis = Function_bind.bind(Function_bind.call);
-// http://jsperf.com/uncurrythis
-
-var array_slice = uncurryThis(Array.prototype.slice);
-
-var array_reduce = uncurryThis(
-    Array.prototype.reduce || function (callback, basis) {
-        var index = 0,
-            length = this.length;
-        // concerning the initial value, if one is not provided
-        if (arguments.length === 1) {
-            // seek to the first value in the array, accounting
-            // for the possibility that is is a sparse array
-            do {
-                if (index in this) {
-                    basis = this[index++];
-                    break;
-                }
-                if (++index >= length) {
-                    throw new TypeError();
-                }
-            } while (1);
-        }
-        // reduce
-        for (; index < length; index++) {
-            // account for the possibility that the array is sparse
-            if (index in this) {
-                basis = callback(basis, this[index], index);
-            }
-        }
-        return basis;
-    }
-);
-
-var array_indexOf = uncurryThis(
-    Array.prototype.indexOf || function (value) {
-        // not a very good shim, but good enough for our one use of it
-        for (var i = 0; i < this.length; i++) {
-            if (this[i] === value) {
-                return i;
-            }
-        }
-        return -1;
-    }
-);
-
-var array_map = uncurryThis(
-    Array.prototype.map || function (callback, thisp) {
-        var self = this;
-        var collect = [];
-        array_reduce(self, function (undefined, value, index) {
-            collect.push(callback.call(thisp, value, index, self));
-        }, void 0);
-        return collect;
-    }
-);
-
-var object_create = Object.create || function (prototype) {
-    function Type() { }
-    Type.prototype = prototype;
-    return new Type();
-};
-
-var object_defineProperty = Object.defineProperty || function (obj, prop, descriptor) {
-    obj[prop] = descriptor.value;
-    return obj;
-};
-
-var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
-
-var object_keys = Object.keys || function (object) {
-    var keys = [];
-    for (var key in object) {
-        if (object_hasOwnProperty(object, key)) {
-            keys.push(key);
-        }
-    }
-    return keys;
-};
-
-var object_toString = uncurryThis(Object.prototype.toString);
-
-function isObject(value) {
-    return value === Object(value);
-}
-
-// generator related shims
-
-// FIXME: Remove this function once ES6 generators are in SpiderMonkey.
-function isStopIteration(exception) {
-    return (
-        object_toString(exception) === "[object StopIteration]" ||
-        exception instanceof QReturnValue
-    );
-}
-
-// FIXME: Remove this helper and Q.return once ES6 generators are in
-// SpiderMonkey.
-var QReturnValue;
-if (typeof ReturnValue !== "undefined") {
-    QReturnValue = ReturnValue;
-} else {
-    QReturnValue = function (value) {
-        this.value = value;
-    };
-}
-
-// long stack traces
-
-var STACK_JUMP_SEPARATOR = "From previous event:";
-
-function makeStackTraceLong(error, promise) {
-    // If possible, transform the error stack trace by removing Node and Q
-    // cruft, then concatenating with the stack trace of `promise`. See #57.
-    if (hasStacks &&
-        promise.stack &&
-        typeof error === "object" &&
-        error !== null &&
-        error.stack
-    ) {
-        var stacks = [];
-        for (var p = promise; !!p; p = p.source) {
-            if (p.stack && (!error.__minimumStackCounter__ || error.__minimumStackCounter__ > p.stackCounter)) {
-                object_defineProperty(error, "__minimumStackCounter__", {value: p.stackCounter, configurable: true});
-                stacks.unshift(p.stack);
-            }
-        }
-        stacks.unshift(error.stack);
-
-        var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
-        var stack = filterStackString(concatedStacks);
-        object_defineProperty(error, "stack", {value: stack, configurable: true});
-    }
-}
-
-function filterStackString(stackString) {
-    var lines = stackString.split("\n");
-    var desiredLines = [];
-    for (var i = 0; i < lines.length; ++i) {
-        var line = lines[i];
-
-        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
-            desiredLines.push(line);
-        }
-    }
-    return desiredLines.join("\n");
-}
-
-function isNodeFrame(stackLine) {
-    return stackLine.indexOf("(module.js:") !== -1 ||
-           stackLine.indexOf("(node.js:") !== -1;
-}
-
-function getFileNameAndLineNumber(stackLine) {
-    // Named functions: "at functionName (filename:lineNumber:columnNumber)"
-    // In IE10 function name can have spaces ("Anonymous function") O_o
-    var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
-    if (attempt1) {
-        return [attempt1[1], Number(attempt1[2])];
-    }
-
-    // Anonymous functions: "at filename:lineNumber:columnNumber"
-    var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
-    if (attempt2) {
-        return [attempt2[1], Number(attempt2[2])];
-    }
-
-    // Firefox style: "function@filename:lineNumber or @filename:lineNumber"
-    var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
-    if (attempt3) {
-        return [attempt3[1], Number(attempt3[2])];
-    }
-}
-
-function isInternalFrame(stackLine) {
-    var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);
-
-    if (!fileNameAndLineNumber) {
-        return false;
-    }
-
-    var fileName = fileNameAndLineNumber[0];
-    var lineNumber = fileNameAndLineNumber[1];
-
-    return fileName === qFileName &&
-        lineNumber >= qStartingLine &&
-        lineNumber <= qEndingLine;
-}
-
-// discover own file name and line number range for filtering stack
-// traces
-function captureLine() {
-    if (!hasStacks) {
-        return;
-    }
-
-    try {
-        throw new Error();
-    } catch (e) {
-        var lines = e.stack.split("\n");
-        var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
-        var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
-        if (!fileNameAndLineNumber) {
-            return;
-        }
-
-        qFileName = fileNameAndLineNumber[0];
-        return fileNameAndLineNumber[1];
-    }
-}
-
-function deprecate(callback, name, alternative) {
-    return function () {
-        if (typeof console !== "undefined" &&
-            typeof console.warn === "function") {
-            console.warn(name + " is deprecated, use " + alternative +
-                         " instead.", new Error("").stack);
-        }
-        return callback.apply(callback, arguments);
-    };
-}
-
-// end of shims
-// beginning of real work
-
-/**
- * Constructs a promise for an immediate reference, passes promises through, or
- * coerces promises from different systems.
- * @param value immediate reference or promise
- */
-function Q(value) {
-    // If the object is already a Promise, return it directly.  This enables
-    // the resolve function to both be used to created references from objects,
-    // but to tolerably coerce non-promises to promises.
-    if (value instanceof Promise) {
-        return value;
-    }
-
-    // assimilate thenables
-    if (isPromiseAlike(value)) {
-        return coerce(value);
-    } else {
-        return fulfill(value);
-    }
-}
-Q.resolve = Q;
-
-/**
- * Performs a task in a future turn of the event loop.
- * @param {Function} task
- */
-Q.nextTick = nextTick;
-
-/**
- * Controls whether or not long stack traces will be on
- */
-Q.longStackSupport = false;
-
-/**
- * The counter is used to determine the stopping point for building
- * long stack traces. In makeStackTraceLong we walk backwards through
- * the linked list of promises, only stacks which were created before
- * the rejection are concatenated.
- */
-var longStackCounter = 1;
-
-// enable long stacks if Q_DEBUG is set
-if (typeof process === "object" && process && process.env && process.env.Q_DEBUG) {
-    Q.longStackSupport = true;
-}
-
-/**
- * Constructs a {promise, resolve, reject} object.
- *
- * `resolve` is a callback to invoke with a more resolved value for the
- * promise. To fulfill the promise, invoke `resolve` with any value that is
- * not a thenable. To reject the promise, invoke `resolve` with a rejected
- * thenable, or invoke `reject` with the reason directly. To resolve the
- * promise to another thenable, thus putting it in the same state, invoke
- * `resolve` with that other thenable.
- */
-Q.defer = defer;
-function defer() {
-    // if "messages" is an "Array", that indicates that the promise has not yet
-    // been resolved.  If it is "undefined", it has been resolved.  Each
-    // element of the messages array is itself an array of complete arguments to
-    // forward to the resolved promise.  We coerce the resolution value to a
-    // promise using the `resolve` function because it handles both fully
-    // non-thenable values and other thenables gracefully.
-    var messages = [], progressListeners = [], resolvedPromise;
-
-    var deferred = object_create(defer.prototype);
-    var promise = object_create(Promise.prototype);
-
-    promise.promiseDispatch = function (resolve, op, operands) {
-        var args = array_slice(arguments);
-        if (messages) {
-            messages.push(args);
-            if (op === "when" && operands[1]) { // progress operand
-                progressListeners.push(operands[1]);
-            }
-        } else {
-            Q.nextTick(function () {
-                resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
-            });
-        }
-    };
-
-    // XXX deprecated
-    promise.valueOf = function () {
-        if (messages) {
-            return promise;
-        }
-        var nearerValue = nearer(resolvedPromise);
-        if (isPromise(nearerValue)) {
-            resolvedPromise = nearerValue; // shorten chain
-        }
-        return nearerValue;
-    };
-
-    promise.inspect = function () {
-        if (!resolvedPromise) {
-            return { state: "pending" };
-        }
-        return resolvedPromise.inspect();
-    };
-
-    if (Q.longStackSupport && hasStacks) {
-        try {
-            throw new Error();
-        } catch (e) {
-            // NOTE: don't try to use `Error.captureStackTrace` or transfer the
-            // accessor around; that causes memory leaks as per GH-111. Just
-            // reify the stack trace as a string ASAP.
-            //
-            // At the same time, cut off the first line; it's always just
-            // "[object Promise]\n", as per the `toString`.
-            promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
-            promise.stackCounter = longStackCounter++;
-        }
-    }
-
-    // NOTE: we do the checks for `resolvedPromise` in each method, instead of
-    // consolidating them into `become`, since otherwise we'd create new
-    // promises with the lines `become(whatever(value))`. See e.g. GH-252.
-
-    function become(newPromise) {
-        resolvedPromise = newPromise;
-
-        if (Q.longStackSupport && hasStacks) {
-            // Only hold a reference to the new promise if long stacks
-            // are enabled to reduce memory usage
-            promise.source = newPromise;
-        }
-
-        array_reduce(messages, function (undefined, message) {
-            Q.nextTick(function () {
-                newPromise.promiseDispatch.apply(newPromise, message);
-            });
-        }, void 0);
-
-        messages = void 0;
-        progressListeners = void 0;
-    }
-
-    deferred.promise = promise;
-    deferred.resolve = function (value) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        become(Q(value));
-    };
-
-    deferred.fulfill = function (value) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        become(fulfill(value));
-    };
-    deferred.reject = function (reason) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        become(reject(reason));
-    };
-    deferred.notify = function (progress) {
-        if (resolvedPromise) {
-            return;
-        }
-
-        array_reduce(progressListeners, function (undefined, progressListener) {
-            Q.nextTick(function () {
-                progressListener(progress);
-            });
-        }, void 0);
-    };
-
-    return deferred;
-}
-
-/**
- * Creates a Node-style callback that will resolve or reject the deferred
- * promise.
- * @returns a nodeback
- */
-defer.prototype.makeNodeResolver = function () {
-    var self = this;
-    return function (error, value) {
-        if (error) {
-            self.reject(error);
-        } else if (arguments.length > 2) {
-            self.resolve(array_slice(arguments, 1));
-        } else {
-            self.resolve(value);
-        }
-    };
-};
-
-/**
- * @param resolver {Function} a function that returns nothing and accepts
- * the resolve, reject, and notify functions for a deferred.
- * @returns a promise that may be resolved with the given resolve and reject
- * functions, or rejected by a thrown exception in resolver
- */
-Q.Promise = promise; // ES6
-Q.promise = promise;
-function promise(resolver) {
-    if (typeof resolver !== "function") {
-        throw new TypeError("resolver must be a function.");
-    }
-    var deferred = defer();
-    try {
-        resolver(deferred.resolve, deferred.reject, deferred.notify);
-    } catch (reason) {
-        deferred.reject(reason);
-    }
-    return deferred.promise;
-}
-
-promise.race = race; // ES6
-promise.all = all; // ES6
-promise.reject = reject; // ES6
-promise.resolve = Q; // ES6
-
-// XXX experimental.  This method is a way to denote that a local value is
-// serializable and should be immediately dispatched to a remote upon request,
-// instead of passing a reference.
-Q.passByCopy = function (object) {
-    //freeze(object);
-    //passByCopies.set(object, true);
-    return object;
-};
-
-Promise.prototype.passByCopy = function () {
-    //freeze(object);
-    //passByCopies.set(object, true);
-    return this;
-};
-
-/**
- * If two promises eventually fulfill to the same value, promises that value,
- * but otherwise rejects.
- * @param x {Any*}
- * @param y {Any*}
- * @returns {Any*} a promise for x and y if they are the same, but a rejection
- * otherwise.
- *
- */
-Q.join = function (x, y) {
-    return Q(x).join(y);
-};
-
-Promise.prototype.join = function (that) {
-    return Q([this, that]).spread(function (x, y) {
-        if (x === y) {
-            // TODO: "===" should be Object.is or equiv
-            return x;
-        } else {
-            throw new Error("Q can't join: not the same: " + x + " " + y);
-        }
-    });
-};
-
-/**
- * Returns a promise for the first of an array of promises to become settled.
- * @param answers {Array[Any*]} promises to race
- * @returns {Any*} the first promise to be settled
- */
-Q.race = race;
-function race(answerPs) {
-    return promise(function (resolve, reject) {
-        // Switch to this once we can assume at least ES5
-        // answerPs.forEach(function (answerP) {
-        //     Q(answerP).then(resolve, reject);
-        // });
-        // Use this in the meantime
-        for (var i = 0, len = answerPs.length; i < len; i++) {
-            Q(answerPs[i]).then(resolve, reject);
-        }
-    });
-}
-
-Promise.prototype.race = function () {
-    return this.then(Q.race);
-};
-
-/**
- * Constructs a Promise with a promise descriptor object and optional fallback
- * function.  The descriptor contains methods like when(rejected), get(name),
- * set(name, value), post(name, args), and delete(name), which all
- * return either a value, a promise for a value, or a rejection.  The fallback
- * accepts the operation name, a resolver, and any further arguments that would
- * have been forwarded to the appropriate method above had a method been
- * provided with the proper name.  The API makes no guarantees about the nature
- * of the returned object, apart from that it is usable whereever promises are
- * bought and sold.
- */
-Q.makePromise = Promise;
-function Promise(descriptor, fallback, inspect) {
-    if (fallback === void 0) {
-        fallback = function (op) {
-            return reject(new Error(
-                "Promise does not support operation: " + op
-            ));
-        };
-    }
-    if (inspect === void 0) {
-        inspect = function () {
-            return {state: "unknown"};
-        };
-    }
-
-    var promise = object_create(Promise.prototype);
-
-    promise.promiseDispatch = function (resolve, op, args) {
-        var result;
-        try {
-            if (descriptor[op]) {
-                result = descriptor[op].apply(promise, args);
-            } else {
-                result = fallback.call(promise, op, args);
-            }
-        } catch (exception) {
-            result = reject(exception);
-        }
-        if (resolve) {
-            resolve(result);
-        }
-    };
-
-    promise.inspect = inspect;
-
-    // XXX deprecated `valueOf` and `exception` support
-    if (inspect) {
-        var inspected = inspect();
-        if (inspected.state === "rejected") {
-            promise.exception = inspected.reason;
-        }
-
-        promise.valueOf = function () {
-            var inspected = inspect();
-            if (inspected.state === "pending" ||
-                inspected.state === "rejected") {
-                return promise;
-            }
-            return inspected.value;
-        };
-    }
-
-    return promise;
-}
-
-Promise.prototype.toString = function () {
-    return "[object Promise]";
-};
-
-Promise.prototype.then = function (fulfilled, rejected, progressed) {
-    var self = this;
-    var deferred = defer();
-    var done = false;   // ensure the untrusted promise makes at most a
-                        // single call to one of the callbacks
-
-    function _fulfilled(value) {
-        try {
-            return typeof fulfilled === "function" ? fulfilled(value) : value;
-        } catch (exception) {
-            return reject(exception);
-        }
-    }
-
-    function _rejected(exception) {
-        if (typeof rejected === "function") {
-            makeStackTraceLong(exception, self);
-            try {
-                return rejected(exception);
-            } catch (newException) {
-                return reject(newException);
-            }
-        }
-        return reject(exception);
-    }
-
-    function _progressed(value) {
-        return typeof progressed === "function" ? progressed(value) : value;
-    }
-
-    Q.nextTick(function () {
-        self.promiseDispatch(function (value) {
-            if (done) {
-                return;
-            }
-            done = true;
-
-            deferred.resolve(_fulfilled(value));
-        }, "when", [function (exception) {
-            if (done) {
-                return;
-            }
-            done = true;
-
-            deferred.resolve(_rejected(exception));
-        }]);
-    });
-
-    // Progress propagator need to be attached in the current tick.
-    self.promiseDispatch(void 0, "when", [void 0, function (value) {
-        var newValue;
-        var threw = false;
-        try {
-            newValue = _progressed(value);
-        } catch (e) {
-            threw = true;
-            if (Q.onerror) {
-                Q.onerror(e);
-            } else {
-                throw e;
-            }
-        }
-
-        if (!threw) {
-            deferred.notify(newValue);
-        }
-    }]);
-
-    return deferred.promise;
-};
-
-Q.tap = function (promise, callback) {
-    return Q(promise).tap(callback);
-};
-
-/**
- * Works almost like "finally", but not called for rejections.
- * Original resolution value is passed through callback unaffected.
- * Callback may return a promise that will be awaited for.
- * @param {Function} callback
- * @returns {Q.Promise}
- * @example
- * doSomething()
- *   .then(...)
- *   .tap(console.log)
- *   .then(...);
- */
-Promise.prototype.tap = function (callback) {
-    callback = Q(callback);
-
-    return this.then(function (value) {
-        return callback.fcall(value).thenResolve(value);
-    });
-};
-
-/**
- * Registers an observer on a promise.
- *
- * Guarantees:
- *
- * 1. that fulfilled and rejected will be called only once.
- * 2. that either the fulfilled callback or the rejected callback will be
- *    called, but not both.
- * 3. that fulfilled and rejected will not be called in this turn.
- *
- * @param value      promise or immediate reference to observe
- * @param fulfilled  function to be called with the fulfilled value
- * @param rejected   function to be called with the rejection exception
- * @param progressed function to be called on any progress notifications
- * @return promise for the return value from the invoked callback
- */
-Q.when = when;
-function when(value, fulfilled, rejected, progressed) {
-    return Q(value).then(fulfilled, rejected, progressed);
-}
-
-Promise.prototype.thenResolve = function (value) {
-    return this.then(function () { return value; });
-};
-
-Q.thenResolve = function (promise, value) {
-    return Q(promise).thenResolve(value);
-};
-
-Promise.prototype.thenReject = function (reason) {
-    return this.then(function () { throw reason; });
-};
-
-Q.thenReject = function (promise, reason) {
-    return Q(promise).thenReject(reason);
-};
-
-/**
- * If an object is not a promise, it is as "near" as possible.
- * If a promise is rejected, it is as "near" as possible too.
- * If it’s a fulfilled promise, the fulfillment value is nearer.
- * If it’s a deferred promise and the deferred has been resolved, the
- * resolution is "nearer".
- * @param object
- * @returns most resolved (nearest) form of the object
- */
-
-// XXX should we re-do this?
-Q.nearer = nearer;
-function nearer(value) {
-    if (isPromise(value)) {
-        var inspected = value.inspect();
-        if (inspected.state === "fulfilled") {
-            return inspected.value;
-        }
-    }
-    return value;
-}
-
-/**
- * @returns whether the given object is a promise.
- * Otherwise it is a fulfilled value.
- */
-Q.isPromise = isPromise;
-function isPromise(object) {
-    return object instanceof Promise;
-}
-
-Q.isPromiseAlike = isPromiseAlike;
-function isPromiseAlike(object) {
-    return isObject(object) && typeof object.then === "function";
-}
-
-/**
- * @returns whether the given object is a pending promise, meaning not
- * fulfilled or rejected.
- */
-Q.isPending = isPending;
-function isPending(object) {
-    return isPromise(object) && object.inspect().state === "pending";
-}
-
-Promise.prototype.isPending = function () {
-    return this.inspect().state === "pending";
-};
-
-/**
- * @returns whether the given object is a value or fulfilled
- * promise.
- */
-Q.isFulfilled = isFulfilled;
-function isFulfilled(object) {
-    return !isPromise(object) || object.inspect().state === "fulfilled";
-}
-
-Promise.prototype.isFulfilled = function () {
-    return this.inspect().state === "fulfilled";
-};
-
-/**
- * @returns whether the given object is a rejected promise.
- */
-Q.isRejected = isRejected;
-function isRejected(object) {
-    return isPromise(object) && object.inspect().state === "rejected";
-}
-
-Promise.prototype.isRejected = function () {
-    return this.inspect().state === "rejected";
-};
-
-//// BEGIN UNHANDLED REJECTION TRACKING
-
-// This promise library consumes exceptions thrown in handlers so they can be
-// handled by a subsequent promise.  The exceptions get added to this array when
-// they are created, and removed when they are handled.  Note that in ES6 or
-// shimmed environments, this would naturally be a `Set`.
-var unhandledReasons = [];
-var unhandledRejections = [];
-var reportedUnhandledRejections = [];
-var trackUnhandledRejections = true;
-
-function resetUnhandledRejections() {
-    unhandledReasons.length = 0;
-    unhandledRejections.length = 0;
-
-    if (!trackUnhandledRejections) {
-        trackUnhandledRejections = true;
-    }
-}
-
-function trackRejection(promise, reason) {
-    if (!trackUnhandledRejections) {
-        return;
-    }
-    if (typeof process === "object" && typeof process.emit === "function") {
-        Q.nextTick.runAfter(function () {
-            if (array_indexOf(unhandledRejections, promise) !== -1) {
-                process.emit("unhandledRejection", reason, promise);
-                reportedUnhandledRejections.push(promise);
-            }
-        });
-    }
-
-    unhandledRejections.push(promise);
-    if (reason && typeof reason.stack !== "undefined") {
-        unhandledReasons.push(reason.stack);
-    } else {
-        unhandledReasons.push("(no stack) " + reason);
-    }
-}
-
-function untrackRejection(promise) {
-    if (!trackUnhandledRejections) {
-        return;
-    }
-
-    var at = array_indexOf(unhandledRejections, promise);
-    if (at !== -1) {
-        if (typeof process === "object" && typeof process.emit === "function") {
-            Q.nextTick.runAfter(function () {
-                var atReport = array_indexOf(reportedUnhandledRejections, promise);
-                if (atReport !== -1) {
-                    process.emit("rejectionHandled", unhandledReasons[at], promise);
-                    reportedUnhandledRejections.splice(atReport, 1);
-                }
-            });
-        }
-        unhandledRejections.splice(at, 1);
-        unhandledReasons.splice(at, 1);
-    }
-}
-
-Q.resetUnhandledRejections = resetUnhandledRejections;
-
-Q.getUnhandledReasons = function () {
-    // Make a copy so that consumers can't interfere with our internal state.
-    return unhandledReasons.slice();
-};
-
-Q.stopUnhandledRejectionTracking = function () {
-    resetUnhandledRejections();
-    trackUnhandledRejections = false;
-};
-
-resetUnhandledRejections();
-
-//// END UNHANDLED REJECTION TRACKING
-
-/**
- * Constructs a rejected promise.
- * @param reason value describing the failure
- */
-Q.reject = reject;
-function reject(reason) {
-    var rejection = Promise({
-        "when": function (rejected) {
-            // note that the error has been handled
-            if (rejected) {
-                untrackRejection(this);
-            }
-            return rejected ? rejected(reason) : this;
-        }
-    }, function fallback() {
-        return this;
-    }, function inspect() {
-        return { state: "rejected", reason: reason };
-    });
-
-    // Note that the reason has not been handled.
-    trackRejection(rejection, reason);
-
-    return rejection;
-}
-
-/**
- * Constructs a fulfilled promise for an immediate reference.
- * @param value immediate reference
- */
-Q.fulfill = fulfill;
-function fulfill(value) {
-    return Promise({
-        "when": function () {
-            return value;
-        },
-        "get": function (name) {
-            return value[name];
-        },
-        "set": function (name, rhs) {
-            value[name] = rhs;
-        },
-        "delete": function (name) {
-            delete value[name];
-        },
-        "post": function (name, args) {
-            // Mark Miller proposes that post with no name should apply a
-            // promised function.
-            if (name === null || name === void 0) {
-                return value.apply(void 0, args);
-            } else {
-                return value[name].apply(value, args);
-            }
-        },
-        "apply": function (thisp, args) {
-            return value.apply(thisp, args);
-        },
-        "keys": function () {
-            return object_keys(value);
-        }
-    }, void 0, function inspect() {
-        return { state: "fulfilled", value: value };
-    });
-}
-
-/**
- * Converts thenables to Q promises.
- * @param promise thenable promise
- * @returns a Q promise
- */
-function coerce(promise) {
-    var deferred = defer();
-    Q.nextTick(function () {
-        try {
-            promise.then(deferred.resolve, deferred.reject, deferred.notify);
-        } catch (exception) {
-            deferred.reject(exception);
-        }
-    });
-    return deferred.promise;
-}
-
-/**
- * Annotates an object such that it will never be
- * transferred away from this process over any promise
- * communication channel.
- * @param object
- * @returns promise a wrapping of that object that
- * additionally responds to the "isDef" message
- * without a rejection.
- */
-Q.master = master;
-function master(object) {
-    return Promise({
-        "isDef": function () {}
-    }, function fallback(op, args) {
-        return dispatch(object, op, args);
-    }, function () {
-        return Q(object).inspect();
-    });
-}
-
-/**
- * Spreads the values of a promised array of arguments into the
- * fulfillment callback.
- * @param fulfilled callback that receives variadic arguments from the
- * promised array
- * @param rejected callback that receives the exception if the promise
- * is rejected.
- * @returns a promise for the return value or thrown exception of
- * either callback.
- */
-Q.spread = spread;
-function spread(value, fulfilled, rejected) {
-    return Q(value).spread(fulfilled, rejected);
-}
-
-Promise.prototype.spread = function (fulfilled, rejected) {
-    return this.all().then(function (array) {
-        return fulfilled.apply(void 0, array);
-    }, rejected);
-};
-
-/**
- * The async function is a decorator for generator functions, turning
- * them into asynchronous generators.  Although generators are only part
- * of the newest ECMAScript 6 drafts, this code does not cause syntax
- * errors in older engines.  This code should continue to work and will
- * in fact improve over time as the language improves.
- *
- * ES6 generators are currently part of V8 version 3.19 with the
- * --harmony-generators runtime flag enabled.  SpiderMonkey has had them
- * for longer, but under an older Python-inspired form.  This function
- * works on both kinds of generators.
- *
- * Decorates a generator function such that:
- *  - it may yield promises
- *  - execution will continue when that promise is fulfilled
- *  - the value of the yield expression will be the fulfilled value
- *  - it returns a promise for the return value (when the generator
- *    stops iterating)
- *  - the decorated function returns a promise for the return value
- *    of the generator or the first rejected promise among those
- *    yielded.
- *  - if an error is thrown in the generator, it propagates through
- *    every following yield until it is caught, or until it escapes
- *    the generator function altogether, and is translated into a
- *    rejection for the promise returned by the decorated generator.
- */
-Q.async = async;
-function async(makeGenerator) {
-    return function () {
-        // when verb is "send", arg is a value
-        // when verb is "throw", arg is an exception
-        function continuer(verb, arg) {
-            var result;
-
-            // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
-            // engine that has a deployed base of browsers that support generators.
-            // However, SM's generators use the Python-inspired semantics of
-            // outdated ES6 drafts.  We would like to support ES6, but we'd also
-            // like to make it possible to use generators in deployed browsers, so
-            // we also support Python-style generators.  At some point we can remove
-            // this block.
-
-            if (typeof StopIteration === "undefined") {
-                // ES6 Generators
-                try {
-                    result = generator[verb](arg);
-                } catch (exception) {
-                    return reject(exception);
-                }
-                if (result.done) {
-                    return Q(result.value);
-                } else {
-                    return when(result.value, callback, errback);
-                }
-            } else {
-                // SpiderMonkey Generators
-                // FIXME: Remove this case when SM does ES6 generators.
-                try {
-                    result = generator[verb](arg);
-                } catch (exception) {
-                    if (isStopIteration(exception)) {
-                        return Q(exception.value);
-                    } else {
-                        return reject(exception);
-                    }
-                }
-                return when(result, callback, errback);
-            }
-        }
-        var generator = makeGenerator.apply(this, arguments);
-        var callback = continuer.bind(continuer, "next");
-        var errback = continuer.bind(continuer, "throw");
-        return callback();
-    };
-}
-
-/**
- * The spawn function is a small wrapper around async that immediately
- * calls the generator and also ends the promise chain, so that any
- * unhandled errors are thrown instead of forwarded to the error
- * handler. This is useful because it's extremely common to run
- * generators at the top-level to work with libraries.
- */
-Q.spawn = spawn;
-function spawn(makeGenerator) {
-    Q.done(Q.async(makeGenerator)());
-}
-
-// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.
-/**
- * Throws a ReturnValue exception to stop an asynchronous generator.
- *
- * This interface is a stop-gap measure to support generator return
- * values in older Firefox/SpiderMonkey.  In browsers that support ES6
- * generators like Chromium 29, just use "return" in your generator
- * functions.
- *
- * @param value the return value for the surrounding generator
- * @throws ReturnValue exception with the value.
- * @example
- * // ES6 style
- * Q.async(function* () {
- *      var foo = yield getFooPromise();
- *      var bar = yield getBarPromise();
- *      return foo + bar;
- * })
- * // Older SpiderMonkey style
- * Q.async(function () {
- *      var foo = yield getFooPromise();
- *      var bar = yield getBarPromise();
- *      Q.return(foo + bar);
- * })
- */
-Q["return"] = _return;
-function _return(value) {
-    throw new QReturnValue(value);
-}
-
-/**
- * The promised function decorator ensures that any promise arguments
- * are settled and passed as values (`this` is also settled and passed
- * as a value).  It will also ensure that the result of a function is
- * always a promise.
- *
- * @example
- * var add = Q.promised(function (a, b) {
- *     return a + b;
- * });
- * add(Q(a), Q(B));
- *
- * @param {function} callback The function to decorate
- * @returns {function} a function that has been decorated.
- */
-Q.promised = promised;
-function promised(callback) {
-    return function () {
-        return spread([this, all(arguments)], function (self, args) {
-            return callback.apply(self, args);
-        });
-    };
-}
-
-/**
- * sends a message to a value in a future turn
- * @param object* the recipient
- * @param op the name of the message operation, e.g., "when",
- * @param args further arguments to be forwarded to the operation
- * @returns result {Promise} a promise for the result of the operation
- */
-Q.dispatch = dispatch;
-function dispatch(object, op, args) {
-    return Q(object).dispatch(op, args);
-}
-
-Promise.prototype.dispatch = function (op, args) {
-    var self = this;
-    var deferred = defer();
-    Q.nextTick(function () {
-        self.promiseDispatch(deferred.resolve, op, args);
-    });
-    return deferred.promise;
-};
-
-/**
- * Gets the value of a property in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of property to get
- * @return promise for the property value
- */
-Q.get = function (object, key) {
-    return Q(object).dispatch("get", [key]);
-};
-
-Promise.prototype.get = function (key) {
-    return this.dispatch("get", [key]);
-};
-
-/**
- * Sets the value of a property in a future turn.
- * @param object    promise or immediate reference for object object
- * @param name      name of property to set
- * @param value     new value of property
- * @return promise for the return value
- */
-Q.set = function (object, key, value) {
-    return Q(object).dispatch("set", [key, value]);
-};
-
-Promise.prototype.set = function (key, value) {
-    return this.dispatch("set", [key, value]);
-};
-
-/**
- * Deletes a property in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of property to delete
- * @return promise for the return value
- */
-Q.del = // XXX legacy
-Q["delete"] = function (object, key) {
-    return Q(object).dispatch("delete", [key]);
-};
-
-Promise.prototype.del = // XXX legacy
-Promise.prototype["delete"] = function (key) {
-    return this.dispatch("delete", [key]);
-};
-
-/**
- * Invokes a method in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of method to invoke
- * @param value     a value to post, typically an array of
- *                  invocation arguments for promises that
- *                  are ultimately backed with `resolve` values,
- *                  as opposed to those backed with URLs
- *                  wherein the posted value can be any
- *                  JSON serializable object.
- * @return promise for the return value
- */
-// bound locally because it is used by other methods
-Q.mapply = // XXX As proposed by "Redsandro"
-Q.post = function (object, name, args) {
-    return Q(object).dispatch("post", [name, args]);
-};
-
-Promise.prototype.mapply = // XXX As proposed by "Redsandro"
-Promise.prototype.post = function (name, args) {
-    return this.dispatch("post", [name, args]);
-};
-
-/**
- * Invokes a method in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of method to invoke
- * @param ...args   array of invocation arguments
- * @return promise for the return value
- */
-Q.send = // XXX Mark Miller's proposed parlance
-Q.mcall = // XXX As proposed by "Redsandro"
-Q.invoke = function (object, name /*...args*/) {
-    return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
-};
-
-Promise.prototype.send = // XXX Mark Miller's proposed parlance
-Promise.prototype.mcall = // XXX As proposed by "Redsandro"
-Promise.prototype.invoke = function (name /*...args*/) {
-    return this.dispatch("post", [name, array_slice(arguments, 1)]);
-};
-
-/**
- * Applies the promised function in a future turn.
- * @param object    promise or immediate reference for target function
- * @param args      array of application arguments
- */
-Q.fapply = function (object, args) {
-    return Q(object).dispatch("apply", [void 0, args]);
-};
-
-Promise.prototype.fapply = function (args) {
-    return this.dispatch("apply", [void 0, args]);
-};
-
-/**
- * Calls the promised function in a future turn.
- * @param object    promise or immediate reference for target function
- * @param ...args   array of application arguments
- */
-Q["try"] =
-Q.fcall = function (object /* ...args*/) {
-    return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
-};
-
-Promise.prototype.fcall = function (/*...args*/) {
-    return this.dispatch("apply", [void 0, array_slice(arguments)]);
-};
-
-/**
- * Binds the promised function, transforming return values into a fulfilled
- * promise and thrown errors into a rejected one.
- * @param object    promise or immediate reference for target function
- * @param ...args   array of application arguments
- */
-Q.fbind = function (object /*...args*/) {
-    var promise = Q(object);
-    var args = array_slice(arguments, 1);
-    return function fbound() {
-        return promise.dispatch("apply", [
-            this,
-            args.concat(array_slice(arguments))
-        ]);
-    };
-};
-Promise.prototype.fbind = function (/*...args*/) {
-    var promise = this;
-    var args = array_slice(arguments);
-    return function fbound() {
-        return promise.dispatch("apply", [
-            this,
-            args.concat(array_slice(arguments))
-        ]);
-    };
-};
-
-/**
- * Requests the names of the owned properties of a promised
- * object in a future turn.
- * @param object    promise or immediate reference for target object
- * @return promise for the keys of the eventually settled object
- */
-Q.keys = function (object) {
-    return Q(object).dispatch("keys", []);
-};
-
-Promise.prototype.keys = function () {
-    return this.dispatch("keys", []);
-};
-
-/**
- * Turns an array of promises into a promise for an array.  If any of
- * the promises gets rejected, the whole array is rejected immediately.
- * @param {Array*} an array (or promise for an array) of values (or
- * promises for values)
- * @returns a promise for an array of the corresponding values
- */
-// By Mark Miller
-// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
-Q.all = all;
-function all(promises) {
-    return when(promises, function (promises) {
-        var pendingCount = 0;
-        var deferred = defer();
-        array_reduce(promises, function (undefined, promise, index) {
-            var snapshot;
-            if (
-                isPromise(promise) &&
-                (snapshot = promise.inspect()).state === "fulfilled"
-            ) {
-                promises[index] = snapshot.value;
-            } else {
-                ++pendingCount;
-                when(
-                    promise,
-                    function (value) {
-                        promises[index] = value;
-                        if (--pendingCount === 0) {
-                            deferred.resolve(promises);
-                        }
-                    },
-                    deferred.reject,
-                    function (progress) {
-                        deferred.notify({ index: index, value: progress });
-                    }
-                );
-            }
-        }, void 0);
-        if (pendingCount === 0) {
-            deferred.resolve(promises);
-        }
-        return deferred.promise;
-    });
-}
-
-Promise.prototype.all = function () {
-    return all(this);
-};
-
-/**
- * Returns the first resolved promise of an array. Prior rejected promises are
- * ignored.  Rejects only if all promises are rejected.
- * @param {Array*} an array containing values or promises for values
- * @returns a promise fulfilled with the value of the first resolved promise,
- * or a rejected promise if all promises are rejected.
- */
-Q.any = any;
-
-function any(promises) {
-    if (promises.length === 0) {
-        return Q.resolve();
-    }
-
-    var deferred = Q.defer();
-    var pendingCount = 0;
-    array_reduce(promises, function (prev, current, index) {
-        var promise = promises[index];
-
-        pendingCount++;
-
-        when(promise, onFulfilled, onRejected, onProgress);
-        function onFulfilled(result) {
-            deferred.resolve(result);
-        }
-        function onRejected(err) {
-            pendingCount--;
-            if (pendingCount === 0) {
-                var rejection = err || new Error("" + err);
-
-                rejection.message = ("Q can't get fulfillment value from any promise, all " +
-                    "promises were rejected. Last error message: " + rejection.message);
-
-                deferred.reject(rejection);
-            }
-        }
-        function onProgress(progress) {
-            deferred.notify({
-                index: index,
-                value: progress
-            });
-        }
-    }, undefined);
-
-    return deferred.promise;
-}
-
-Promise.prototype.any = function () {
-    return any(this);
-};
-
-/**
- * Waits for all promises to be settled, either fulfilled or
- * rejected.  This is distinct from `all` since that would stop
- * waiting at the first rejection.  The promise returned by
- * `allResolved` will never be rejected.
- * @param promises a promise for an array (or an array) of promises
- * (or values)
- * @return a promise for an array of promises
- */
-Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
-function allResolved(promises) {
-    return when(promises, function (promises) {
-        promises = array_map(promises, Q);
-        return when(all(array_map(promises, function (promise) {
-            return when(promise, noop, noop);
-        })), function () {
-            return promises;
-        });
-    });
-}
-
-Promise.prototype.allResolved = function () {
-    return allResolved(this);
-};
-
-/**
- * @see Promise#allSettled
- */
-Q.allSettled = allSettled;
-function allSettled(promises) {
-    return Q(promises).allSettled();
-}
-
-/**
- * Turns an array of promises into a promise for an array of their states (as
- * returned by `inspect`) when they have all settled.
- * @param {Array[Any*]} values an array (or promise for an array) of values (or
- * promises for values)
- * @returns {Array[State]} an array of states for the respective values.
- */
-Promise.prototype.allSettled = function () {
-    return this.then(function (promises) {
-        return all(array_map(promises, function (promise) {
-            promise = Q(promise);
-            function regardless() {
-                return promise.inspect();
-            }
-            return promise.then(regardless, regardless);
-        }));
-    });
-};
-
-/**
- * Captures the failure of a promise, giving an oportunity to recover
- * with a callback.  If the given promise is fulfilled, the returned
- * promise is fulfilled.
- * @param {Any*} promise for something
- * @param {Function} callback to fulfill the returned promise if the
- * given promise is rejected
- * @returns a promise for the return value of the callback
- */
-Q.fail = // XXX legacy
-Q["catch"] = function (object, rejected) {
-    return Q(object).then(void 0, rejected);
-};
-
-Promise.prototype.fail = // XXX legacy
-Promise.prototype["catch"] = function (rejected) {
-    return this.then(void 0, rejected);
-};
-
-/**
- * Attaches a listener that can respond to progress notifications from a
- * promise's originating deferred. This listener receives the exact arguments
- * passed to ``deferred.notify``.
- * @param {Any*} promise for something
- * @param {Function} callback to receive any progress notifications
- * @returns the given promise, unchanged
- */
-Q.progress = progress;
-function progress(object, progressed) {
-    return Q(object).then(void 0, void 0, progressed);
-}
-
-Promise.prototype.progress = function (progressed) {
-    return this.then(void 0, void 0, progressed);
-};
-
-/**
- * Provides an opportunity to observe the settling of a promise,
- * regardless of whether the promise is fulfilled or rejected.  Forwards
- * the resolution to the returned promise when the callback is done.
- * The callback can return a promise to defer completion.
- * @param {Any*} promise
- * @param {Function} callback to observe the resolution of the given
- * promise, takes no arguments.
- * @returns a promise for the resolution of the given promise when
- * ``fin`` is done.
- */
-Q.fin = // XXX legacy
-Q["finally"] = function (object, callback) {
-    return Q(object)["finally"](callback);
-};
-
-Promise.prototype.fin = // XXX legacy
-Promise.prototype["finally"] = function (callback) {
-    if (!callback || typeof callback.apply !== "function") {
-        throw new Error("Q can't apply finally callback");
-    }
-    callback = Q(callback);
-    return this.then(function (value) {
-        return callback.fcall().then(function () {
-            return value;
-        });
-    }, function (reason) {
-        // TODO attempt to recycle the rejection with "this".
-        return callback.fcall().then(function () {
-            throw reason;
-        });
-    });
-};
-
-/**
- * Terminates a chain of promises, forcing rejections to be
- * thrown as exceptions.
- * @param {Any*} promise at the end of a chain of promises
- * @returns nothing
- */
-Q.done = function (object, fulfilled, rejected, progress) {
-    return Q(object).done(fulfilled, rejected, progress);
-};
-
-Promise.prototype.done = function (fulfilled, rejected, progress) {
-    var onUnhandledError = function (error) {
-        // forward to a future turn so that ``when``
-        // does not catch it and turn it into a rejection.
-        Q.nextTick(function () {
-            makeStackTraceLong(error, promise);
-            if (Q.onerror) {
-                Q.onerror(error);
-            } else {
-                throw error;
-            }
-        });
-    };
-
-    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.
-    var promise = fulfilled || rejected || progress ?
-        this.then(fulfilled, rejected, progress) :
-        this;
-
-    if (typeof process === "object" && process && process.domain) {
-        onUnhandledError = process.domain.bind(onUnhandledError);
-    }
-
-    promise.then(void 0, onUnhandledError);
-};
-
-/**
- * Causes a promise to be rejected if it does not get fulfilled before
- * some milliseconds time out.
- * @param {Any*} promise
- * @param {Number} milliseconds timeout
- * @param {Any*} custom error message or Error object (optional)
- * @returns a promise for the resolution of the given promise if it is
- * fulfilled before the timeout, otherwise rejected.
- */
-Q.timeout = function (object, ms, error) {
-    return Q(object).timeout(ms, error);
-};
-
-Promise.prototype.timeout = function (ms, error) {
-    var deferred = defer();
-    var timeoutId = setTimeout(function () {
-        if (!error || "string" === typeof error) {
-            error = new Error(error || "Timed out after " + ms + " ms");
-            error.code = "ETIMEDOUT";
-        }
-        deferred.reject(error);
-    }, ms);
-
-    this.then(function (value) {
-        clearTimeout(timeoutId);
-        deferred.resolve(value);
-    }, function (exception) {
-        clearTimeout(timeoutId);
-        deferred.reject(exception);
-    }, deferred.notify);
-
-    return deferred.promise;
-};
-
-/**
- * Returns a promise for the given value (or promised value), some
- * milliseconds after it resolved. Passes rejections immediately.
- * @param {Any*} promise
- * @param {Number} milliseconds
- * @returns a promise for the resolution of the given promise after milliseconds
- * time has elapsed since the resolution of the given promise.
- * If the given promise rejects, that is passed immediately.
- */
-Q.delay = function (object, timeout) {
-    if (timeout === void 0) {
-        timeout = object;
-        object = void 0;
-    }
-    return Q(object).delay(timeout);
-};
-
-Promise.prototype.delay = function (timeout) {
-    return this.then(function (value) {
-        var deferred = defer();
-        setTimeout(function () {
-            deferred.resolve(value);
-        }, timeout);
-        return deferred.promise;
-    });
-};
-
-/**
- * Passes a continuation to a Node function, which is called with the given
- * arguments provided as an array, and returns a promise.
- *
- *      Q.nfapply(FS.readFile, [__filename])
- *      .then(function (content) {
- *      })
- *
- */
-Q.nfapply = function (callback, args) {
-    return Q(callback).nfapply(args);
-};
-
-Promise.prototype.nfapply = function (args) {
-    var deferred = defer();
-    var nodeArgs = array_slice(args);
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.fapply(nodeArgs).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Passes a continuation to a Node function, which is called with the given
- * arguments provided individually, and returns a promise.
- * @example
- * Q.nfcall(FS.readFile, __filename)
- * .then(function (content) {
- * })
- *
- */
-Q.nfcall = function (callback /*...args*/) {
-    var args = array_slice(arguments, 1);
-    return Q(callback).nfapply(args);
-};
-
-Promise.prototype.nfcall = function (/*...args*/) {
-    var nodeArgs = array_slice(arguments);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.fapply(nodeArgs).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Wraps a NodeJS continuation passing function and returns an equivalent
- * version that returns a promise.
- * @example
- * Q.nfbind(FS.readFile, __filename)("utf-8")
- * .then(console.log)
- * .done()
- */
-Q.nfbind =
-Q.denodeify = function (callback /*...args*/) {
-    if (callback === undefined) {
-        throw new Error("Q can't wrap an undefined function");
-    }
-    var baseArgs = array_slice(arguments, 1);
-    return function () {
-        var nodeArgs = baseArgs.concat(array_slice(arguments));
-        var deferred = defer();
-        nodeArgs.push(deferred.makeNodeResolver());
-        Q(callback).fapply(nodeArgs).fail(deferred.reject);
-        return deferred.promise;
-    };
-};
-
-Promise.prototype.nfbind =
-Promise.prototype.denodeify = function (/*...args*/) {
-    var args = array_slice(arguments);
-    args.unshift(this);
-    return Q.denodeify.apply(void 0, args);
-};
-
-Q.nbind = function (callback, thisp /*...args*/) {
-    var baseArgs = array_slice(arguments, 2);
-    return function () {
-        var nodeArgs = baseArgs.concat(array_slice(arguments));
-        var deferred = defer();
-        nodeArgs.push(deferred.makeNodeResolver());
-        function bound() {
-            return callback.apply(thisp, arguments);
-        }
-        Q(bound).fapply(nodeArgs).fail(deferred.reject);
-        return deferred.promise;
-    };
-};
-
-Promise.prototype.nbind = function (/*thisp, ...args*/) {
-    var args = array_slice(arguments, 0);
-    args.unshift(this);
-    return Q.nbind.apply(void 0, args);
-};
-
-/**
- * Calls a method of a Node-style object that accepts a Node-style
- * callback with a given array of arguments, plus a provided callback.
- * @param object an object that has the named method
- * @param {String} name name of the method of object
- * @param {Array} args arguments to pass to the method; the callback
- * will be provided by Q and appended to these arguments.
- * @returns a promise for the value or error
- */
-Q.nmapply = // XXX As proposed by "Redsandro"
-Q.npost = function (object, name, args) {
-    return Q(object).npost(name, args);
-};
-
-Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
-Promise.prototype.npost = function (name, args) {
-    var nodeArgs = array_slice(args || []);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Calls a method of a Node-style object that accepts a Node-style
- * callback, forwarding the given variadic arguments, plus a provided
- * callback argument.
- * @param object an object that has the named method
- * @param {String} name name of the method of object
- * @param ...args arguments to pass to the method; the callback will
- * be provided by Q and appended to these arguments.
- * @returns a promise for the value or error
- */
-Q.nsend = // XXX Based on Mark Miller's proposed "send"
-Q.nmcall = // XXX Based on "Redsandro's" proposal
-Q.ninvoke = function (object, name /*...args*/) {
-    var nodeArgs = array_slice(arguments, 2);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
-
-Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
-Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
-Promise.prototype.ninvoke = function (name /*...args*/) {
-    var nodeArgs = array_slice(arguments, 1);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * If a function would like to support both Node continuation-passing-style and
- * promise-returning-style, it can end its internal promise chain with
- * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user
- * elects to use a nodeback, the result will be sent there.  If they do not
- * pass a nodeback, they will receive the result promise.
- * @param object a result (or a promise for a result)
- * @param {Function} nodeback a Node.js-style callback
- * @returns either the promise or nothing
- */
-Q.nodeify = nodeify;
-function nodeify(object, nodeback) {
-    return Q(object).nodeify(nodeback);
-}
-
-Promise.prototype.nodeify = function (nodeback) {
-    if (nodeback) {
-        this.then(function (value) {
-            Q.nextTick(function () {
-                nodeback(null, value);
-            });
-        }, function (error) {
-            Q.nextTick(function () {
-                nodeback(error);
-            });
-        });
-    } else {
-        return this;
-    }
-};
-
-Q.noConflict = function() {
-    throw new Error("Q.noConflict only works when Q is used as a global");
-};
-
-// All code before this point will be filtered from stack traces.
-var qEndingLine = captureLine();
-
-return Q;
-
-});
diff --git a/www/js/lib/util.js b/www/js/lib/util.js
index 0728f579..8c2db9fa 100644
--- a/www/js/lib/util.js
+++ b/www/js/lib/util.js
@@ -20,7 +20,7 @@
  * along with Kiwix (file LICENSE-GPLv3.txt).  If not, see <http://www.gnu.org/licenses/>
  */
 'use strict';
-define(['q'], function(Q) {
+define([], function() {
 
     /**
      * A Regular Expression to match the first letter of a word even if preceded by Unicode punctuation
@@ -211,7 +211,7 @@ define(['q'], function(Q) {
                 return new Uint8Array(buffer);
             });
         } else {
-            return Q.Promise(function (resolve, reject) {
+            return new Promise(function (resolve, reject) {
                 var reader = new FileReader();
                 reader.readAsArrayBuffer(file.slice(begin, end));
                 reader.addEventListener('load', function (e) {
diff --git a/www/js/lib/webpHeroPolyfills_0.0.0-dev.27.js b/www/js/lib/webpHeroPolyfills_0.0.0-dev.27.js
deleted file mode 100644
index 714c7f9d..00000000
--- a/www/js/lib/webpHeroPolyfills_0.0.0-dev.27.js
+++ /dev/null
@@ -1,2 +0,0 @@
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.ES6Promise=e()}(this,function(){"use strict";function t(t){var e=typeof t;return null!==t&&("object"===e||"function"===e)}function e(t){return"function"==typeof t}function n(t){W=t}function r(t){z=t}function o(){return function(){return process.nextTick(a)}}function i(){return"undefined"!=typeof U?function(){U(a)}:c()}function s(){var t=0,e=new H(a),n=document.createTextNode("");return e.observe(n,{characterData:!0}),function(){n.data=t=++t%2}}function u(){var t=new MessageChannel;return t.port1.onmessage=a,function(){return t.port2.postMessage(0)}}function c(){var t=setTimeout;return function(){return t(a,1)}}function a(){for(var t=0;t<N;t+=2){var e=Q[t],n=Q[t+1];e(n),Q[t]=void 0,Q[t+1]=void 0}N=0}function f(){try{var t=Function("return this")().require("vertx");return U=t.runOnLoop||t.runOnContext,i()}catch(e){return c()}}function l(t,e){var n=this,r=new this.constructor(p);void 0===r[V]&&x(r);var o=n._state;if(o){var i=arguments[o-1];z(function(){return T(o,r,i,n._result)})}else j(n,r,t,e);return r}function h(t){var e=this;if(t&&"object"==typeof t&&t.constructor===e)return t;var n=new e(p);return w(n,t),n}function p(){}function v(){return new TypeError("You cannot resolve a promise with itself")}function d(){return new TypeError("A promises callback cannot return that same promise.")}function _(t,e,n,r){try{t.call(e,n,r)}catch(o){return o}}function y(t,e,n){z(function(t){var r=!1,o=_(n,e,function(n){r||(r=!0,e!==n?w(t,n):A(t,n))},function(e){r||(r=!0,S(t,e))},"Settle: "+(t._label||" unknown promise"));!r&&o&&(r=!0,S(t,o))},t)}function m(t,e){e._state===Z?A(t,e._result):e._state===$?S(t,e._result):j(e,void 0,function(e){return w(t,e)},function(e){return S(t,e)})}function b(t,n,r){n.constructor===t.constructor&&r===l&&n.constructor.resolve===h?m(t,n):void 0===r?A(t,n):e(r)?y(t,n,r):A(t,n)}function w(e,n){if(e===n)S(e,v());else if(t(n)){var r=void 0;try{r=n.then}catch(o){return void S(e,o)}b(e,n,r)}else A(e,n)}function g(t){t._onerror&&t._onerror(t._result),E(t)}function A(t,e){t._state===X&&(t._result=e,t._state=Z,0!==t._subscribers.length&&z(E,t))}function S(t,e){t._state===X&&(t._state=$,t._result=e,z(g,t))}function j(t,e,n,r){var o=t._subscribers,i=o.length;t._onerror=null,o[i]=e,o[i+Z]=n,o[i+$]=r,0===i&&t._state&&z(E,t)}function E(t){var e=t._subscribers,n=t._state;if(0!==e.length){for(var r=void 0,o=void 0,i=t._result,s=0;s<e.length;s+=3)r=e[s],o=e[s+n],r?T(n,r,o,i):o(i);t._subscribers.length=0}}function T(t,n,r,o){var i=e(r),s=void 0,u=void 0,c=!0;if(i){try{s=r(o)}catch(a){c=!1,u=a}if(n===s)return void S(n,d())}else s=o;n._state!==X||(i&&c?w(n,s):c===!1?S(n,u):t===Z?A(n,s):t===$&&S(n,s))}function M(t,e){try{e(function(e){w(t,e)},function(e){S(t,e)})}catch(n){S(t,n)}}function P(){return tt++}function x(t){t[V]=tt++,t._state=void 0,t._result=void 0,t._subscribers=[]}function C(){return new Error("Array Methods must be provided an Array")}function O(t){return new et(this,t).promise}function k(t){var e=this;return new e(L(t)?function(n,r){for(var o=t.length,i=0;i<o;i++)e.resolve(t[i]).then(n,r)}:function(t,e){return e(new TypeError("You must pass an array to race."))})}function F(t){var e=this,n=new e(p);return S(n,t),n}function Y(){throw new TypeError("You must pass a resolver function as the first argument to the promise constructor")}function q(){throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.")}function D(){var t=void 0;if("undefined"!=typeof global)t=global;else if("undefined"!=typeof self)t=self;else try{t=Function("return this")()}catch(e){throw new Error("polyfill failed because global object is unavailable in this environment")}var n=t.Promise;if(n){var r=null;try{r=Object.prototype.toString.call(n.resolve())}catch(e){}if("[object Promise]"===r&&!n.cast)return}t.Promise=nt}var K=void 0;K=Array.isArray?Array.isArray:function(t){return"[object Array]"===Object.prototype.toString.call(t)};var L=K,N=0,U=void 0,W=void 0,z=function(t,e){Q[N]=t,Q[N+1]=e,N+=2,2===N&&(W?W(a):R())},B="undefined"!=typeof window?window:void 0,G=B||{},H=G.MutationObserver||G.WebKitMutationObserver,I="undefined"==typeof self&&"undefined"!=typeof process&&"[object process]"==={}.toString.call(process),J="undefined"!=typeof Uint8ClampedArray&&"undefined"!=typeof importScripts&&"undefined"!=typeof MessageChannel,Q=new Array(1e3),R=void 0;R=I?o():H?s():J?u():void 0===B&&"function"==typeof require?f():c();var V=Math.random().toString(36).substring(2),X=void 0,Z=1,$=2,tt=0,et=function(){function t(t,e){this._instanceConstructor=t,this.promise=new t(p),this.promise[V]||x(this.promise),L(e)?(this.length=e.length,this._remaining=e.length,this._result=new Array(this.length),0===this.length?A(this.promise,this._result):(this.length=this.length||0,this._enumerate(e),0===this._remaining&&A(this.promise,this._result))):S(this.promise,C())}return t.prototype._enumerate=function(t){for(var e=0;this._state===X&&e<t.length;e++)this._eachEntry(t[e],e)},t.prototype._eachEntry=function(t,e){var n=this._instanceConstructor,r=n.resolve;if(r===h){var o=void 0,i=void 0,s=!1;try{o=t.then}catch(u){s=!0,i=u}if(o===l&&t._state!==X)this._settledAt(t._state,e,t._result);else if("function"!=typeof o)this._remaining--,this._result[e]=t;else if(n===nt){var c=new n(p);s?S(c,i):b(c,t,o),this._willSettleAt(c,e)}else this._willSettleAt(new n(function(e){return e(t)}),e)}else this._willSettleAt(r(t),e)},t.prototype._settledAt=function(t,e,n){var r=this.promise;r._state===X&&(this._remaining--,t===$?S(r,n):this._result[e]=n),0===this._remaining&&A(r,this._result)},t.prototype._willSettleAt=function(t,e){var n=this;j(t,void 0,function(t){return n._settledAt(Z,e,t)},function(t){return n._settledAt($,e,t)})},t}(),nt=function(){function t(e){this[V]=P(),this._result=this._state=void 0,this._subscribers=[],p!==e&&("function"!=typeof e&&Y(),this instanceof t?M(this,e):q())}return t.prototype["catch"]=function(t){return this.then(null,t)},t.prototype["finally"]=function(t){var n=this,r=n.constructor;return e(t)?n.then(function(e){return r.resolve(t()).then(function(){return e})},function(e){return r.resolve(t()).then(function(){throw e})}):n.then(t,t)},t}();return nt.prototype.then=l,nt.all=O,nt.race=k,nt.resolve=h,nt.reject=F,nt._setScheduler=n,nt._setAsap=r,nt._asap=z,nt.polyfill=D,nt.Promise=nt,nt.polyfill(),nt});
-!function(){var t,u,e,c;Array.from||(Array.from=(t=Object.prototype.toString,u=function(r){return"function"==typeof r||"[object Function]"===t.call(r)},e=Math.pow(2,53)-1,c=function(r){var t,n=(t=Number(r),isNaN(t)?0:0!==t&&isFinite(t)?(0<t?1:-1)*Math.floor(Math.abs(t)):t);return Math.min(Math.max(n,0),e)},function(r){var t=Object(r);if(null==r)throw new TypeError("Array.from requires an array-like object - not null or undefined");var n,e=1<arguments.length?arguments[1]:void 0;if(void 0!==e){if(!u(e))throw new TypeError("Array.from: when provided, the second argument must be a function");2<arguments.length&&(n=arguments[2])}for(var o,a=c(t.length),i=u(this)?Object(new this(a)):new Array(a),f=0;f<a;)o=t[f],i[f]=e?void 0===n?e(o,f):e.call(n,o,f):o,f+=1;return i.length=a,i}))}();
diff --git a/www/js/lib/xzdec_wrapper.js b/www/js/lib/xzdec_wrapper.js
index 3139a362..1d06fbf1 100644
--- a/www/js/lib/xzdec_wrapper.js
+++ b/www/js/lib/xzdec_wrapper.js
@@ -20,7 +20,7 @@
  * along with Kiwix (file LICENSE-GPLv3.txt).  If not, see <http://www.gnu.org/licenses/>
  */
 'use strict';
-define(['q', 'xzdec'], function(Q) {
+define(['xzdec'], function() {
     // DEV: xzdec.js emits a global Module variable, which cannot be set in requireJS function line above, though it can be loaded in definition
     var xzdec = Module;
     xzdec._init();
@@ -86,14 +86,15 @@ define(['q', 'xzdec'], function(Q) {
      * @returns {Promise} A Promise for the read data
      */
     Decompressor.prototype.readSliceSingleThread = function (offset, length) {
-        if (!busy) {
+        // Tests whether the decompressor is ready (initiated) and not busy
+        if (xzdec && !busy) {
             return this.readSlice(offset, length);
         } else {
             // The decompressor is already in progress.
             // To avoid using too much memory, we wait until it has finished
             // before using it for another decompression
             var that = this;
-            return Q.Promise(function (resolve, reject) {
+            return new Promise(function (resolve, reject) {
                 setTimeout(function () {
                     that.readSliceSingleThread(offset, length).then(resolve, reject);
                 }, DELAY_WAITING_IDLE_DECOMPRESSOR);
@@ -148,8 +149,7 @@ define(['q', 'xzdec'], function(Q) {
      */
     Decompressor.prototype._fillInBufferIfNeeded = function() {
         if (!xzdec._input_empty(this._decHandle)) {
-            // DEV: When converting to Promise/A+, use Promise.resolve(0) here
-            return Q.when(0);
+            return Promise.resolve(0);
         }
         var that = this;
         return this._reader(this._inStreamPos, this._chunkSize).then(function(data) {
diff --git a/www/js/lib/zimfile.js b/www/js/lib/zimfile.js
index 419fbe97..c3fe0e3b 100644
--- a/www/js/lib/zimfile.js
+++ b/www/js/lib/zimfile.js
@@ -21,7 +21,7 @@
  */
 'use strict';
 
-define(['xzdec_wrapper', 'zstddec_wrapper', 'util', 'utf8', 'q', 'zimDirEntry', 'filecache'], function(xz, zstd, util, utf8, Q, zimDirEntry, FileCache) {
+define(['xzdec_wrapper', 'zstddec_wrapper', 'util', 'utf8', 'zimDirEntry', 'filecache'], function(xz, zstd, util, utf8, zimDirEntry, FileCache) {
 
     /**
      * A variable to keep track of the currently loaded ZIM archive, e.g., for labelling cache entries
@@ -118,12 +118,12 @@ define(['xzdec_wrapper', 'zstddec_wrapper', 'util', 'utf8', 'q', 'zimDirEntry',
             }
         }
         if (readRequests.length === 0) {
-            return Q(new Uint8Array(0).buffer);
+            return Promise.resolve(new Uint8Array(0).buffer);
         } else if (readRequests.length === 1) {
             return readRequests[0];
         } else {
             // Wait until all are resolved and concatenate.
-            return Q.all(readRequests).then(function (arrays) {
+            return Promise.all(readRequests).then(function (arrays) {
                 var concatenated = new Uint8Array(end - begin);
                 var offset = 0;
                 arrays.forEach(function (item) {
@@ -227,7 +227,7 @@ define(['xzdec_wrapper', 'zstddec_wrapper', 'util', 'utf8', 'q', 'zimDirEntry',
                             return that._readSlice(offsetStart, size);
                         }
                     } else {
-                        return Q(new Uint8Array(0).buffer);
+                        return Promise.resolve(new Uint8Array(0).buffer);
                     }
                 };
                 // If only metadata were requested and the cluster is compressed, return null (this is probably a ZIM format error)
diff --git a/www/js/lib/zstddec.js b/www/js/lib/zstddec.js
index c40740f3..454d6e16 100644
--- a/www/js/lib/zstddec.js
+++ b/www/js/lib/zstddec.js
@@ -35,7 +35,7 @@ function B(){return buffer.byteLength/65536|0}return{"e":Ha,"f":oa,"g":na,"h":ga
 B=[];"object"!==typeof WebAssembly&&J("no native wasm support detected");var G,H=new function(c){var e=Array(c.initial);e.set=function(d,m){e[d]=m};e.get=function(d){return e[d]};return e}({initial:1,maximum:1,element:"anyfunc"}),K=!1;function L(c){var e=a["_"+c];e||J("Assertion failed: Cannot call unknown function "+(c+", make sure it is exported"));return e}
 function ea(c,e,d,m){var l={string:function(b){var f=0;if(null!==b&&void 0!==b&&0!==b){var g=(b.length<<2)+1;f=M(g);var h=f,k=O;if(0<g){g=h+g-1;for(var t=0;t<b.length;++t){var n=b.charCodeAt(t);if(55296<=n&&57343>=n){var I=b.charCodeAt(++t);n=65536+((n&1023)<<10)|I&1023}if(127>=n){if(h>=g)break;k[h++]=n}else{if(2047>=n){if(h+1>=g)break;k[h++]=192|n>>6}else{if(65535>=n){if(h+2>=g)break;k[h++]=224|n>>12}else{if(h+3>=g)break;k[h++]=240|n>>18;k[h++]=128|n>>12&63}k[h++]=128|n>>6&63}k[h++]=128|n&63}}k[h]=
 0}}return f},array:function(b){var f=M(b.length);fa.set(b,f);return f}},p=L(c),r=[];c=0;if(m)for(var q=0;q<m.length;q++){var D=l[d[q]];D?(0===c&&(c=ha()),r[q]=D(m[q])):r[q]=m[q]}d=p.apply(null,r);d=function(b){if("string"===e)if(b){for(var f=O,g=b+NaN,h=b;f[h]&&!(h>=g);)++h;if(16<h-b&&f.subarray&&ia)b=ia.decode(f.subarray(b,h));else{for(g="";b<h;){var k=f[b++];if(k&128){var t=f[b++]&63;if(192==(k&224))g+=String.fromCharCode((k&31)<<6|t);else{var n=f[b++]&63;k=224==(k&240)?(k&15)<<12|t<<6|n:(k&7)<<
-18|t<<12|n<<6|f[b++]&63;65536>k?g+=String.fromCharCode(k):(k-=65536,g+=String.fromCharCode(55296|k>>10,56320|k&1023))}}else g+=String.fromCharCode(k)}b=g}}else b="";else b="boolean"===e?!!b:b;return b}(d);0!==c&&ja(c);return d}var ia="undefined"!==typeof TextDecoder?new TextDecoder("utf8"):void 0,P,fa,O,C=a.INITIAL_MEMORY||140247040;a.wasmMemory?G=a.wasmMemory:G=new aa;G&&(P=G.buffer);C=P.byteLength;var Q=P;P=Q;a.HEAP8=fa=new Int8Array(Q);a.HEAP16=new Int16Array(Q);a.HEAP32=new Int32Array(Q);
+18|t<<12|n<<6|f[b++]&63;65536>k?g+=String.fromCharCode(k):(k-=65536,g+=String.fromCharCode(55296|k>>10,56320|k&1023))}}else g+=String.fromCharCode(k)}b=g}}else b="";else b="boolean"===e?!!b:b;return b}(d);0!==c&&ja(c);return d}var ia="undefined"!==typeof TextDecoder?new TextDecoder("utf8"):void 0,P,fa,O,C=a.INITIAL_MEMORY||150994944;a.wasmMemory?G=a.wasmMemory:G=new aa;G&&(P=G.buffer);C=P.byteLength;var Q=P;P=Q;a.HEAP8=fa=new Int8Array(Q);a.HEAP16=new Int16Array(Q);a.HEAP32=new Int32Array(Q);
 a.HEAPU8=O=new Uint8Array(Q);a.HEAPU16=new Uint16Array(Q);a.HEAPU32=new Uint32Array(Q);a.HEAPF32=new Float32Array(Q);a.HEAPF64=new Float64Array(Q);var ka=[],la=[],ma=[],na=[];function oa(){var c=a.preRun.shift();ka.unshift(c)}Math.imul&&-5===Math.imul(4294967295,5)||(Math.imul=function(c,e){var d=c&65535,m=e&65535;return d*m+((c>>>16)*m+d*(e>>>16)<<16)|0});if(!Math.fround){var pa=new Float32Array(1);Math.fround=function(c){pa[0]=c;return pa[0]}}
 Math.clz32||(Math.clz32=function(c){var e=32,d=c>>16;d&&(e-=16,c=d);if(d=c>>8)e-=8,c=d;if(d=c>>4)e-=4,c=d;if(d=c>>2)e-=2,c=d;return c>>1?e-2:e-c});Math.trunc||(Math.trunc=function(c){return 0>c?Math.ceil(c):Math.floor(c)});var R=0,T=null,U=null;a.preloadedImages={};a.preloadedAudios={};function J(c){if(a.onAbort)a.onAbort(c);A(c);K=!0;c=new da("abort("+c+"). Build with -s ASSERTIONS=1 for more info.");v(c);throw c;}
 function V(c){return String.prototype.startsWith?c.startsWith("data:application/octet-stream;base64,"):0===c.indexOf("data:application/octet-stream;base64,")}var W="zstddec.wasm";if(!V(W)){var qa=W;W=a.locateFile?a.locateFile(qa,y):y+qa}
diff --git a/www/js/lib/zstddec_wrapper.js b/www/js/lib/zstddec_wrapper.js
index 5e7a5e55..f82e7f64 100644
--- a/www/js/lib/zstddec_wrapper.js
+++ b/www/js/lib/zstddec_wrapper.js
@@ -20,7 +20,7 @@
  * along with Kiwix (file LICENSE-GPLv3.txt).  If not, see <http://www.gnu.org/licenses/>
  */
 'use strict';
-define(['q', 'zstddec'], function (Q) {
+define(['zstddec'], function () {
     // DEV: zstddec.js has been compiled with `-s EXPORT_NAME="ZD" -s MODULARIZE=1` to avoid a clash with xzdec which uses "Module" as its exported object
     // Note that we include zstddec above in requireJS definition, but we cannot change the name in the function list
     // There is no longer any need to load it in index.html
@@ -130,7 +130,7 @@ define(['q', 'zstddec'], function (Q) {
         this._outDataBufPos = 0;
         var ret = zd._ZSTD_initDStream(zd._decHandle);
         if (zd._ZSTD_isError(ret)) {
-            return Q.reject('Failed to initialize ZSTD decompression');
+            return Promise.reject('Failed to initialize ZSTD decompression');
         }
 
         return this._readLoop(offset, length).then(function (data) {
@@ -153,14 +153,15 @@ define(['q', 'zstddec'], function (Q) {
      * @returns {Promise} A Promise for the readSlice() function
      */
     Decompressor.prototype.readSliceSingleThread = function (offset, length) {
-        if (!busy) {
+        // Tests whether the decompressor is ready (initiated) and not busy
+        if (zd && !busy) {
             return this.readSlice(offset, length);
         } else {
             // The decompressor is already in progress.
             // To avoid using too much memory, we wait until it has finished
             // before using it for another decompression
             var that = this;
-            return Q.Promise(function (resolve, reject) {
+            return new Promise(function (resolve, reject) {
                 setTimeout(function () {
                     that.readSliceSingleThread(offset, length).then(resolve, reject);
                 }, DELAY_WAITING_IDLE_DECOMPRESSOR);
@@ -181,7 +182,7 @@ define(['q', 'zstddec'], function (Q) {
             var ret = zd._ZSTD_decompressStream(zd._decHandle, zd._outBuffer.ptr, zd._inBuffer.ptr);
             if (zd._ZSTD_isError(ret)) {
                 var errorMessage = "Failed to decompress data stream!\n" + zd.getErrorString(ret);
-                return Q.reject(errorMessage);
+                return Promise.reject(errorMessage);
             }
             // Get updated outbuffer values
             var obxPtr32Bit = zd._outBuffer.ptr >> 2;