Clean up code

3 files changed, 3 insertions, 1168 deletions

diff --git a/browser/base/content/promises/data/es6-promise.code.js b/browser/base/content/promises/data/es6-promise.code.js
deleted file mode 100644
index b0c6aeda9..000000000
--- a/browser/base/content/promises/data/es6-promise.code.js
+++ /dev/null
@@ -1,974 +0,0 @@
-/*!
- * @overview es6-promise - a tiny implementation of Promises/A+.
- * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
- * @license   Licensed under MIT license
- *            See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
- * @version   3.0.2
- */
-
-(function() {
-    function lib$es6pm$promise$utils$$objectOrFunction(x) {
-      return typeof x === 'function' || (typeof x === 'object' && x !== null);
-    }
-
-    function lib$es6pm$promise$utils$$isFunction(x) {
-      return typeof x === 'function';
-    }
-
-    function lib$es6pm$promise$utils$$isMaybeThenable(x) {
-      return typeof x === 'object' && x !== null;
-    }
-
-    var lib$es6pm$promise$utils$$_isArray;
-    if (!Array.isArray) {
-      lib$es6pm$promise$utils$$_isArray = function (x) {
-        return Object.prototype.toString.call(x) === '[object Array]';
-      };
-    } else {
-      lib$es6pm$promise$utils$$_isArray = Array.isArray;
-    }
-
-    var lib$es6pm$promise$utils$$isArray = lib$es6pm$promise$utils$$_isArray;
-    var lib$es6pm$promise$asap$$len = 0;
-    var lib$es6pm$promise$asap$$toString = {}.toString;
-    var lib$es6pm$promise$asap$$vertxNext;
-    var lib$es6pm$promise$asap$$customSchedulerFn;
-
-    var lib$es6pm$promise$asap$$asap = function asap(callback, arg) {
-      lib$es6pm$promise$asap$$queue[lib$es6pm$promise$asap$$len] = callback;
-      lib$es6pm$promise$asap$$queue[lib$es6pm$promise$asap$$len + 1] = arg;
-      lib$es6pm$promise$asap$$len += 2;
-      if (lib$es6pm$promise$asap$$len === 2) {
-        // If len is 2, that means that we need to schedule an async flush.
-        // If additional callbacks are queued before the queue is flushed, they
-        // will be processed by this flush that we are scheduling.
-        if (lib$es6pm$promise$asap$$customSchedulerFn) {
-          lib$es6pm$promise$asap$$customSchedulerFn(lib$es6pm$promise$asap$$flush);
-        } else {
-          lib$es6pm$promise$asap$$scheduleFlush();
-        }
-      }
-    }
-
-    function lib$es6pm$promise$asap$$setScheduler(scheduleFn) {
-      lib$es6pm$promise$asap$$customSchedulerFn = scheduleFn;
-    }
-
-    function lib$es6pm$promise$asap$$setAsap(asapFn) {
-      lib$es6pm$promise$asap$$asap = asapFn;
-    }
-
-    var lib$es6pm$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;
-    var lib$es6pm$promise$asap$$browserGlobal = lib$es6pm$promise$asap$$browserWindow || {};
-    var lib$es6pm$promise$asap$$BrowserMutationObserver = lib$es6pm$promise$asap$$browserGlobal.MutationObserver || lib$es6pm$promise$asap$$browserGlobal.WebKitMutationObserver;
-    var lib$es6pm$promise$asap$$isNode = typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
-
-    // test for web worker but not in IE10
-    var lib$es6pm$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
-      typeof importScripts !== 'undefined' &&
-      typeof MessageChannel !== 'undefined';
-
-    // node
-    function lib$es6pm$promise$asap$$useNextTick() {
-      // node version 0.10.x displays a deprecation warning when nextTick is used recursively
-      // see https://github.com/cujojs/when/issues/410 for details
-      return function() {
-        process.nextTick(lib$es6pm$promise$asap$$flush);
-      };
-    }
-
-    // vertx
-    function lib$es6pm$promise$asap$$useVertxTimer() {
-      return function() {
-        lib$es6pm$promise$asap$$vertxNext(lib$es6pm$promise$asap$$flush);
-      };
-    }
-
-    function lib$es6pm$promise$asap$$useMutationObserver() {
-      var iterations = 0;
-      var observer = new lib$es6pm$promise$asap$$BrowserMutationObserver(lib$es6pm$promise$asap$$flush);
-      var node = document.createTextNode('');
-      observer.observe(node, { characterData: true });
-
-      return function() {
-        node.data = (iterations = ++iterations % 2);
-      };
-    }
-
-    // web worker
-    function lib$es6pm$promise$asap$$useMessageChannel() {
-      var channel = new MessageChannel();
-      channel.port1.onmessage = lib$es6pm$promise$asap$$flush;
-      return function () {
-        channel.port2.postMessage(0);
-      };
-    }
-
-    function lib$es6pm$promise$asap$$useSetTimeout() {
-      return function() {
-        setTimeout(lib$es6pm$promise$asap$$flush, 1);
-      };
-    }
-
-    var lib$es6pm$promise$asap$$queue = new Array(1000);
-    function lib$es6pm$promise$asap$$flush() {
-      for (var i = 0; i < lib$es6pm$promise$asap$$len; i+=2) {
-        var callback = lib$es6pm$promise$asap$$queue[i];
-        var arg = lib$es6pm$promise$asap$$queue[i+1];
-
-        callback(arg);
-
-        lib$es6pm$promise$asap$$queue[i] = undefined;
-        lib$es6pm$promise$asap$$queue[i+1] = undefined;
-      }
-
-      lib$es6pm$promise$asap$$len = 0;
-    }
-
-    function lib$es6pm$promise$asap$$attemptVertx() {
-      try {
-        var r = require;
-        var vertx = r('vertx');
-        lib$es6pm$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;
-        return lib$es6pm$promise$asap$$useVertxTimer();
-      } catch(e) {
-        return lib$es6pm$promise$asap$$useSetTimeout();
-      }
-    }
-
-    var lib$es6pm$promise$asap$$scheduleFlush;
-    // Decide what async method to use to triggering processing of queued callbacks:
-    if (lib$es6pm$promise$asap$$isNode) {
-      lib$es6pm$promise$asap$$scheduleFlush = lib$es6pm$promise$asap$$useNextTick();
-    } else if (lib$es6pm$promise$asap$$BrowserMutationObserver) {
-      lib$es6pm$promise$asap$$scheduleFlush = lib$es6pm$promise$asap$$useMutationObserver();
-    } else if (lib$es6pm$promise$asap$$isWorker) {
-      lib$es6pm$promise$asap$$scheduleFlush = lib$es6pm$promise$asap$$useMessageChannel();
-    } else if (lib$es6pm$promise$asap$$browserWindow === undefined && typeof require === 'function') {
-      lib$es6pm$promise$asap$$scheduleFlush = lib$es6pm$promise$asap$$attemptVertx();
-    } else {
-      lib$es6pm$promise$asap$$scheduleFlush = lib$es6pm$promise$asap$$useSetTimeout();
-    }
-
-    function lib$es6pm$promise$$internal$$noop() {}
-
-    var lib$es6pm$promise$$internal$$PENDING   = void 0;
-    var lib$es6pm$promise$$internal$$FULFILLED = 1;
-    var lib$es6pm$promise$$internal$$REJECTED  = 2;
-
-    var lib$es6pm$promise$$internal$$GET_THEN_ERROR = new lib$es6pm$promise$$internal$$ErrorObject();
-
-    function lib$es6pm$promise$$internal$$selfFulfillment() {
-      return new TypeError("You cannot resolve a promise with itself");
-    }
-
-    function lib$es6pm$promise$$internal$$cannotReturnOwn() {
-      return new TypeError('A promises callback cannot return that same promise.');
-    }
-
-    function lib$es6pm$promise$$internal$$getThen(promise) {
-      try {
-        return promise.then;
-      } catch(error) {
-        lib$es6pm$promise$$internal$$GET_THEN_ERROR.error = error;
-        return lib$es6pm$promise$$internal$$GET_THEN_ERROR;
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {
-      try {
-        then.call(value, fulfillmentHandler, rejectionHandler);
-      } catch(e) {
-        return e;
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$handleForeignThenable(promise, thenable, then) {
-       lib$es6pm$promise$asap$$asap(function(promise) {
-        var sealed = false;
-        var error = lib$es6pm$promise$$internal$$tryThen(then, thenable, function(value) {
-          if (sealed) { return; }
-          sealed = true;
-          if (thenable !== value) {
-            lib$es6pm$promise$$internal$$resolve(promise, value);
-          } else {
-            lib$es6pm$promise$$internal$$fulfill(promise, value);
-          }
-        }, function(reason) {
-          if (sealed) { return; }
-          sealed = true;
-
-          lib$es6pm$promise$$internal$$reject(promise, reason);
-        }, 'Settle: ' + (promise._label || ' unknown promise'));
-
-        if (!sealed && error) {
-          sealed = true;
-          lib$es6pm$promise$$internal$$reject(promise, error);
-        }
-      }, promise);
-    }
-
-    function lib$es6pm$promise$$internal$$handleOwnThenable(promise, thenable) {
-      if (thenable._state === lib$es6pm$promise$$internal$$FULFILLED) {
-        lib$es6pm$promise$$internal$$fulfill(promise, thenable._result);
-      } else if (thenable._state === lib$es6pm$promise$$internal$$REJECTED) {
-        lib$es6pm$promise$$internal$$reject(promise, thenable._result);
-      } else {
-        lib$es6pm$promise$$internal$$subscribe(thenable, undefined, function(value) {
-          lib$es6pm$promise$$internal$$resolve(promise, value);
-        }, function(reason) {
-          lib$es6pm$promise$$internal$$reject(promise, reason);
-        });
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$handleMaybeThenable(promise, maybeThenable) {
-      if (maybeThenable.constructor === promise.constructor) {
-        lib$es6pm$promise$$internal$$handleOwnThenable(promise, maybeThenable);
-      } else {
-        var then = lib$es6pm$promise$$internal$$getThen(maybeThenable);
-
-        if (then === lib$es6pm$promise$$internal$$GET_THEN_ERROR) {
-          lib$es6pm$promise$$internal$$reject(promise, lib$es6pm$promise$$internal$$GET_THEN_ERROR.error);
-        } else if (then === undefined) {
-          lib$es6pm$promise$$internal$$fulfill(promise, maybeThenable);
-        } else if (lib$es6pm$promise$utils$$isFunction(then)) {
-          lib$es6pm$promise$$internal$$handleForeignThenable(promise, maybeThenable, then);
-        } else {
-          lib$es6pm$promise$$internal$$fulfill(promise, maybeThenable);
-        }
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$resolve(promise, value) {
-      if (promise === value) {
-        lib$es6pm$promise$$internal$$reject(promise, lib$es6pm$promise$$internal$$selfFulfillment());
-      } else if (lib$es6pm$promise$utils$$objectOrFunction(value)) {
-        lib$es6pm$promise$$internal$$handleMaybeThenable(promise, value);
-      } else {
-        lib$es6pm$promise$$internal$$fulfill(promise, value);
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$publishRejection(promise) {
-      if (promise._onerror) {
-        promise._onerror(promise._result);
-      }
-
-      lib$es6pm$promise$$internal$$publish(promise);
-    }
-
-    function lib$es6pm$promise$$internal$$fulfill(promise, value) {
-      if (promise._state !== lib$es6pm$promise$$internal$$PENDING) { return; }
-
-      promise._result = value;
-      promise._state = lib$es6pm$promise$$internal$$FULFILLED;
-
-      if (promise._subscribers.length !== 0) {
-        lib$es6pm$promise$asap$$asap(lib$es6pm$promise$$internal$$publish, promise);
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$reject(promise, reason) {
-      if (promise._state !== lib$es6pm$promise$$internal$$PENDING) { return; }
-      promise._state = lib$es6pm$promise$$internal$$REJECTED;
-      promise._result = reason;
-
-      lib$es6pm$promise$asap$$asap(lib$es6pm$promise$$internal$$publishRejection, promise);
-    }
-
-    function lib$es6pm$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) {
-      var subscribers = parent._subscribers;
-      var length = subscribers.length;
-
-      parent._onerror = null;
-
-      subscribers[length] = child;
-      subscribers[length + lib$es6pm$promise$$internal$$FULFILLED] = onFulfillment;
-      subscribers[length + lib$es6pm$promise$$internal$$REJECTED]  = onRejection;
-
-      if (length === 0 && parent._state) {
-        lib$es6pm$promise$asap$$asap(lib$es6pm$promise$$internal$$publish, parent);
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$publish(promise) {
-      var subscribers = promise._subscribers;
-      var settled = promise._state;
-
-      if (subscribers.length === 0) { return; }
-
-      var child, callback, detail = promise._result;
-
-      for (var i = 0; i < subscribers.length; i += 3) {
-        child = subscribers[i];
-        callback = subscribers[i + settled];
-
-        if (child) {
-          lib$es6pm$promise$$internal$$invokeCallback(settled, child, callback, detail);
-        } else {
-          callback(detail);
-        }
-      }
-
-      promise._subscribers.length = 0;
-    }
-
-    function lib$es6pm$promise$$internal$$ErrorObject() {
-      this.error = null;
-    }
-
-    var lib$es6pm$promise$$internal$$TRY_CATCH_ERROR = new lib$es6pm$promise$$internal$$ErrorObject();
-
-    function lib$es6pm$promise$$internal$$tryCatch(callback, detail) {
-      try {
-        return callback(detail);
-      } catch(e) {
-        lib$es6pm$promise$$internal$$TRY_CATCH_ERROR.error = e;
-        return lib$es6pm$promise$$internal$$TRY_CATCH_ERROR;
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$invokeCallback(settled, promise, callback, detail) {
-      var hasCallback = lib$es6pm$promise$utils$$isFunction(callback),
-          value, error, succeeded, failed;
-
-      if (hasCallback) {
-        value = lib$es6pm$promise$$internal$$tryCatch(callback, detail);
-
-        if (value === lib$es6pm$promise$$internal$$TRY_CATCH_ERROR) {
-          failed = true;
-          error = value.error;
-          value = null;
-        } else {
-          succeeded = true;
-        }
-
-        if (promise === value) {
-          lib$es6pm$promise$$internal$$reject(promise, lib$es6pm$promise$$internal$$cannotReturnOwn());
-          return;
-        }
-
-      } else {
-        value = detail;
-        succeeded = true;
-      }
-
-      if (promise._state !== lib$es6pm$promise$$internal$$PENDING) {
-        // noop
-      } else if (hasCallback && succeeded) {
-        lib$es6pm$promise$$internal$$resolve(promise, value);
-      } else if (failed) {
-        lib$es6pm$promise$$internal$$reject(promise, error);
-      } else if (settled === lib$es6pm$promise$$internal$$FULFILLED) {
-        lib$es6pm$promise$$internal$$fulfill(promise, value);
-      } else if (settled === lib$es6pm$promise$$internal$$REJECTED) {
-        lib$es6pm$promise$$internal$$reject(promise, value);
-      }
-    }
-
-    function lib$es6pm$promise$$internal$$initializePromise(promise, resolver) {
-      try {
-        resolver(function resolvePromise(value){
-          lib$es6pm$promise$$internal$$resolve(promise, value);
-        }, function rejectPromise(reason) {
-          lib$es6pm$promise$$internal$$reject(promise, reason);
-        });
-      } catch(e) {
-        lib$es6pm$promise$$internal$$reject(promise, e);
-      }
-    }
-
-    function lib$es6pm$promise$enumerator$$Enumerator(Constructor, input) {
-      var enumerator = this;
-
-      enumerator._instanceConstructor = Constructor;
-      enumerator.promise = new Constructor(lib$es6pm$promise$$internal$$noop);
-
-      if (enumerator._validateInput(input)) {
-        enumerator._input     = input;
-        enumerator.length     = input.length;
-        enumerator._remaining = input.length;
-
-        enumerator._init();
-
-        if (enumerator.length === 0) {
-          lib$es6pm$promise$$internal$$fulfill(enumerator.promise, enumerator._result);
-        } else {
-          enumerator.length = enumerator.length || 0;
-          enumerator._enumerate();
-          if (enumerator._remaining === 0) {
-            lib$es6pm$promise$$internal$$fulfill(enumerator.promise, enumerator._result);
-          }
-        }
-      } else {
-        lib$es6pm$promise$$internal$$reject(enumerator.promise, enumerator._validationError());
-      }
-    }
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._validateInput = function(input) {
-      return lib$es6pm$promise$utils$$isArray(input);
-    };
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._validationError = function() {
-      return new Error('Array Methods must be provided an Array');
-    };
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._init = function() {
-      this._result = new Array(this.length);
-    };
-
-    var lib$es6pm$promise$enumerator$$default = lib$es6pm$promise$enumerator$$Enumerator;
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._enumerate = function() {
-      var enumerator = this;
-
-      var length  = enumerator.length;
-      var promise = enumerator.promise;
-      var input   = enumerator._input;
-
-      for (var i = 0; promise._state === lib$es6pm$promise$$internal$$PENDING && i < length; i++) {
-        enumerator._eachEntry(input[i], i);
-      }
-    };
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
-      var enumerator = this;
-      var c = enumerator._instanceConstructor;
-
-      if (lib$es6pm$promise$utils$$isMaybeThenable(entry)) {
-        if (entry.constructor === c && entry._state !== lib$es6pm$promise$$internal$$PENDING) {
-          entry._onerror = null;
-          enumerator._settledAt(entry._state, i, entry._result);
-        } else {
-          enumerator._willSettleAt(c.resolve(entry), i);
-        }
-      } else {
-        enumerator._remaining--;
-        enumerator._result[i] = entry;
-      }
-    };
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
-      var enumerator = this;
-      var promise = enumerator.promise;
-
-      if (promise._state === lib$es6pm$promise$$internal$$PENDING) {
-        enumerator._remaining--;
-
-        if (state === lib$es6pm$promise$$internal$$REJECTED) {
-          lib$es6pm$promise$$internal$$reject(promise, value);
-        } else {
-          enumerator._result[i] = value;
-        }
-      }
-
-      if (enumerator._remaining === 0) {
-        lib$es6pm$promise$$internal$$fulfill(promise, enumerator._result);
-      }
-    };
-
-    lib$es6pm$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
-      var enumerator = this;
-
-      lib$es6pm$promise$$internal$$subscribe(promise, undefined, function(value) {
-        enumerator._settledAt(lib$es6pm$promise$$internal$$FULFILLED, i, value);
-      }, function(reason) {
-        enumerator._settledAt(lib$es6pm$promise$$internal$$REJECTED, i, reason);
-      });
-    };
-    function lib$es6pm$promise$promise$all$$all(entries) {
-      return new lib$es6pm$promise$enumerator$$default(this, entries).promise;
-    }
-    var lib$es6pm$promise$promise$all$$default = lib$es6pm$promise$promise$all$$all;
-    function lib$es6pm$promise$promise$race$$race(entries) {
-      /*jshint validthis:true */
-      var Constructor = this;
-
-      var promise = new Constructor(lib$es6pm$promise$$internal$$noop);
-
-      if (!lib$es6pm$promise$utils$$isArray(entries)) {
-        lib$es6pm$promise$$internal$$reject(promise, new TypeError('You must pass an array to race.'));
-        return promise;
-      }
-
-      var length = entries.length;
-
-      function onFulfillment(value) {
-        lib$es6pm$promise$$internal$$resolve(promise, value);
-      }
-
-      function onRejection(reason) {
-        lib$es6pm$promise$$internal$$reject(promise, reason);
-      }
-
-      for (var i = 0; promise._state === lib$es6pm$promise$$internal$$PENDING && i < length; i++) {
-        lib$es6pm$promise$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
-      }
-
-      return promise;
-    }
-    var lib$es6pm$promise$promise$race$$default = lib$es6pm$promise$promise$race$$race;
-    function lib$es6pm$promise$promise$resolve$$resolve(object) {
-      /*jshint validthis:true */
-      var Constructor = this;
-
-      if (object && typeof object === 'object' && object.constructor === Constructor) {
-        return object;
-      }
-
-      var promise = new Constructor(lib$es6pm$promise$$internal$$noop);
-      lib$es6pm$promise$$internal$$resolve(promise, object);
-      return promise;
-    }
-    var lib$es6pm$promise$promise$resolve$$default = lib$es6pm$promise$promise$resolve$$resolve;
-    function lib$es6pm$promise$promise$reject$$reject(reason) {
-      /*jshint validthis:true */
-      var Constructor = this;
-      var promise = new Constructor(lib$es6pm$promise$$internal$$noop);
-      lib$es6pm$promise$$internal$$reject(promise, reason);
-      return promise;
-    }
-    var lib$es6pm$promise$promise$reject$$default = lib$es6pm$promise$promise$reject$$reject;
-
-    var lib$es6pm$promise$promise$$counter = 0;
-
-    function lib$es6pm$promise$promise$$needsResolver() {
-      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
-    }
-
-    function lib$es6pm$promise$promise$$needsNew() {
-      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
-    }
-
-    var lib$es6pm$promise$promise$$default = lib$es6pm$promise$promise$$Promise;
-    /**
-      Promise objects represent the eventual result of an asynchronous operation. The
-      primary way of interacting with a promise is through its `then` method, which
-      registers callbacks to receive either a promise's eventual value or the reason
-      why the promise cannot be fulfilled.
-
-      Terminology
-      -----------
-
-      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
-      - `thenable` is an object or function that defines a `then` method.
-      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
-      - `exception` is a value that is thrown using the throw statement.
-      - `reason` is a value that indicates why a promise was rejected.
-      - `settled` the final resting state of a promise, fulfilled or rejected.
-
-      A promise can be in one of three states: pending, fulfilled, or rejected.
-
-      Promises that are fulfilled have a fulfillment value and are in the fulfilled
-      state.  Promises that are rejected have a rejection reason and are in the
-      rejected state.  A fulfillment value is never a thenable.
-
-      Promises can also be said to *resolve* a value.  If this value is also a
-      promise, then the original promise's settled state will match the value's
-      settled state.  So a promise that *resolves* a promise that rejects will
-      itself reject, and a promise that *resolves* a promise that fulfills will
-      itself fulfill.
-
-
-      Basic Usage:
-      ------------
-
-      ```js
-      var promise = new Promise(function(resolve, reject) {
-        // on success
-        resolve(value);
-
-        // on failure
-        reject(reason);
-      });
-
-      promise.then(function(value) {
-        // on fulfillment
-      }, function(reason) {
-        // on rejection
-      });
-      ```
-
-      Advanced Usage:
-      ---------------
-
-      Promises shine when abstracting away asynchronous interactions such as
-      `XMLHttpRequest`s.
-
-      ```js
-      function getJSON(url) {
-        return new Promise(function(resolve, reject){
-          var xhr = new XMLHttpRequest();
-
-          xhr.open('GET', url);
-          xhr.onreadystatechange = handler;
-          xhr.responseType = 'json';
-          xhr.setRequestHeader('Accept', 'application/json');
-          xhr.send();
-
-          function handler() {
-            if (this.readyState === this.DONE) {
-              if (this.status === 200) {
-                resolve(this.response);
-              } else {
-                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
-              }
-            }
-          };
-        });
-      }
-
-      getJSON('/posts.json').then(function(json) {
-        // on fulfillment
-      }, function(reason) {
-        // on rejection
-      });
-      ```
-
-      Unlike callbacks, promises are great composable primitives.
-
-      ```js
-      Promise.all([
-        getJSON('/posts'),
-        getJSON('/comments')
-      ]).then(function(values){
-        values[0] // => postsJSON
-        values[1] // => commentsJSON
-
-        return values;
-      });
-      ```
-
-      @class Promise
-      @param {function} resolver
-      Useful for tooling.
-      @constructor
-    */
-    function lib$es6pm$promise$promise$$Promise(resolver) {
-      this._id = lib$es6pm$promise$promise$$counter++;
-      this._state = undefined;
-      this._result = undefined;
-      this._subscribers = [];
-
-      if (lib$es6pm$promise$$internal$$noop !== resolver) {
-        if (!lib$es6pm$promise$utils$$isFunction(resolver)) {
-          lib$es6pm$promise$promise$$needsResolver();
-        }
-
-        if (!(this instanceof lib$es6pm$promise$promise$$Promise)) {
-          lib$es6pm$promise$promise$$needsNew();
-        }
-
-        lib$es6pm$promise$$internal$$initializePromise(this, resolver);
-      }
-    }
-
-    lib$es6pm$promise$promise$$Promise.all = lib$es6pm$promise$promise$all$$default;
-    lib$es6pm$promise$promise$$Promise.race = lib$es6pm$promise$promise$race$$default;
-    lib$es6pm$promise$promise$$Promise.resolve = lib$es6pm$promise$promise$resolve$$default;
-    lib$es6pm$promise$promise$$Promise.reject = lib$es6pm$promise$promise$reject$$default;
-    lib$es6pm$promise$promise$$Promise._setScheduler = lib$es6pm$promise$asap$$setScheduler;
-    lib$es6pm$promise$promise$$Promise._setAsap = lib$es6pm$promise$asap$$setAsap;
-    lib$es6pm$promise$promise$$Promise._asap = lib$es6pm$promise$asap$$asap;
-
-    lib$es6pm$promise$promise$$Promise.prototype = {
-      constructor: lib$es6pm$promise$promise$$Promise,
-
-    /**
-      The primary way of interacting with a promise is through its `then` method,
-      which registers callbacks to receive either a promise's eventual value or the
-      reason why the promise cannot be fulfilled.
-
-      ```js
-      findUser().then(function(user){
-        // user is available
-      }, function(reason){
-        // user is unavailable, and you are given the reason why
-      });
-      ```
-
-      Chaining
-      --------
-
-      The return value of `then` is itself a promise.  This second, 'downstream'
-      promise is resolved with the return value of the first promise's fulfillment
-      or rejection handler, or rejected if the handler throws an exception.
-
-      ```js
-      findUser().then(function (user) {
-        return user.name;
-      }, function (reason) {
-        return 'default name';
-      }).then(function (userName) {
-        // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
-        // will be `'default name'`
-      });
-
-      findUser().then(function (user) {
-        throw new Error('Found user, but still unhappy');
-      }, function (reason) {
-        throw new Error('`findUser` rejected and we're unhappy');
-      }).then(function (value) {
-        // never reached
-      }, function (reason) {
-        // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
-        // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
-      });
-      ```
-      If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
-
-      ```js
-      findUser().then(function (user) {
-        throw new PedagogicalException('Upstream error');
-      }).then(function (value) {
-        // never reached
-      }).then(function (value) {
-        // never reached
-      }, function (reason) {
-        // The `PedgagocialException` is propagated all the way down to here
-      });
-      ```
-
-      Assimilation
-      ------------
-
-      Sometimes the value you want to propagate to a downstream promise can only be
-      retrieved asynchronously. This can be achieved by returning a promise in the
-      fulfillment or rejection handler. The downstream promise will then be pending
-      until the returned promise is settled. This is called *assimilation*.
-
-      ```js
-      findUser().then(function (user) {
-        return findCommentsByAuthor(user);
-      }).then(function (comments) {
-        // The user's comments are now available
-      });
-      ```
-
-      If the assimliated promise rejects, then the downstream promise will also reject.
-
-      ```js
-      findUser().then(function (user) {
-        return findCommentsByAuthor(user);
-      }).then(function (comments) {
-        // If `findCommentsByAuthor` fulfills, we'll have the value here
-      }, function (reason) {
-        // If `findCommentsByAuthor` rejects, we'll have the reason here
-      });
-      ```
-
-      Simple Example
-      --------------
-
-      Synchronous Example
-
-      ```javascript
-      var result;
-
-      try {
-        result = findResult();
-        // success
-      } catch(reason) {
-        // failure
-      }
-      ```
-
-      Errback Example
-
-      ```js
-      findResult(function(result, err){
-        if (err) {
-          // failure
-        } else {
-          // success
-        }
-      });
-      ```
-
-      Promise Example;
-
-      ```javascript
-      findResult().then(function(result){
-        // success
-      }, function(reason){
-        // failure
-      });
-      ```
-
-      Advanced Example
-      --------------
-
-      Synchronous Example
-
-      ```javascript
-      var author, books;
-
-      try {
-        author = findAuthor();
-        books  = findBooksByAuthor(author);
-        // success
-      } catch(reason) {
-        // failure
-      }
-      ```
-
-      Errback Example
-
-      ```js
-
-      function foundBooks(books) {
-
-      }
-
-      function failure(reason) {
-
-      }
-
-      findAuthor(function(author, err){
-        if (err) {
-          failure(err);
-          // failure
-        } else {
-          try {
-            findBoooksByAuthor(author, function(books, err) {
-              if (err) {
-                failure(err);
-              } else {
-                try {
-                  foundBooks(books);
-                } catch(reason) {
-                  failure(reason);
-                }
-              }
-            });
-          } catch(error) {
-            failure(err);
-          }
-          // success
-        }
-      });
-      ```
-
-      Promise Example;
-
-      ```javascript
-      findAuthor().
-        then(findBooksByAuthor).
-        then(function(books){
-          // found books
-      }).catch(function(reason){
-        // something went wrong
-      });
-      ```
-
-      @method then
-      @param {Function} onFulfilled
-      @param {Function} onRejected
-      Useful for tooling.
-      @return {Promise}
-    */
-      then: function(onFulfillment, onRejection) {
-        var parent = this;
-        var state = parent._state;
-
-        if (state === lib$es6pm$promise$$internal$$FULFILLED && !onFulfillment || state === lib$es6pm$promise$$internal$$REJECTED && !onRejection) {
-          return this;
-        }
-
-        var child = new this.constructor(lib$es6pm$promise$$internal$$noop);
-        var result = parent._result;
-
-        if (state) {
-          var callback = arguments[state - 1];
-          lib$es6pm$promise$asap$$asap(function(){
-            lib$es6pm$promise$$internal$$invokeCallback(state, child, callback, result);
-          });
-        } else {
-          lib$es6pm$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);
-        }
-
-        return child;
-      },
-
-    /**
-      `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
-      as the catch block of a try/catch statement.
-
-      ```js
-      function findAuthor(){
-        throw new Error('couldn't find that author');
-      }
-
-      // synchronous
-      try {
-        findAuthor();
-      } catch(reason) {
-        // something went wrong
-      }
-
-      // async with promises
-      findAuthor().catch(function(reason){
-        // something went wrong
-      });
-      ```
-
-      @method catch
-      @param {Function} onRejection
-      Useful for tooling.
-      @return {Promise}
-    */
-      'catch': function(onRejection) {
-        return this.then(null, onRejection);
-      }
-    };
-    function lib$es6pm$promise$polyfill$$polyfill() {
-      var local;
-
-      if (typeof global !== 'undefined') {
-          local = global;
-      } else if (typeof self !== 'undefined') {
-          local = self;
-      } else {
-          try {
-              local = Function('return this')();
-          } catch (e) {
-              throw new Error('polyfill failed because global object is unavailable in this environment');
-          }
-      }
-
-      /* Skip this for integration
-      var P = local.Promise;
-
-      if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {
-        return;
-      }
-      */
-
-      local.Promise = lib$es6pm$promise$promise$$default;
-    }
-    var lib$es6pm$promise$polyfill$$default = lib$es6pm$promise$polyfill$$polyfill;
-
-    var lib$es6pm$promise$umd$$ES6Promise = {
-      'Promise': lib$es6pm$promise$promise$$default,
-      'polyfill': lib$es6pm$promise$polyfill$$default
-    };
-
-    /* global define:true module:true window: true */
-    /* Skip this for integration, only use window.*
-    if (typeof define === 'function' && define['amd']) {
-      define(function() { return lib$es6pm$promise$umd$$ES6Promise; });
-    } else if (typeof module !== 'undefined' && module['exports']) {
-      module['exports'] = lib$es6pm$promise$umd$$ES6Promise;
-    } else if (typeof this !== 'undefined') {
-      this['ES6Promise'] = lib$es6pm$promise$umd$$ES6Promise;
-    } */
-
-    if (typeof this !== 'undefined') {
-      this['ES6Promise'] = lib$es6pm$promise$umd$$ES6Promise;
-    }
-    
-    lib$es6pm$promise$polyfill$$default();
-}).call(this);
-
-//window.addEventListener("load", function () alert("!!!"), false);
diff --git a/browser/base/content/promises/data/es6-shim.js b/browser/base/content/promises/data/es6-shim.js
index d9601612a..d1af03340 100644
--- a/browser/base/content/promises/data/es6-shim.js
+++ b/browser/base/content/promises/data/es6-shim.js
@@ -3,28 +3,15 @@
   * @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com)
   *   and contributors,  MIT License
   * es6-shim: v0.34.2
+  * Modified for Pale Moon by M.C. Straver
   * see https://github.com/paulmillr/es6-shim/blob/0.34.2/LICENSE
   * Details and documentation:
   * https://github.com/paulmillr/es6-shim/
   */
 
-// UMD (Universal Module Definition)
-// see https://github.com/umdjs/umd/blob/master/returnExports.js
 (function (root, factory) {
-  /*global define, module, exports */
-  /* 
-  if (typeof define === 'function' && define.amd) {
-    // AMD. Register as an anonymous module.
-    define(factory);
-  } else if (typeof exports === 'object') {
-    // Node. Does not work with strict CommonJS, but
-    // only CommonJS-like environments that support module.exports,
-    // like Node.
-    module.exports = factory();
-  } else { */
-    // Browser globals (root is window)
-    root.returnExports = factory();
-  // }
+  // Browser globals (root is window)
+  root.returnExports = factory();
 }(this, function () {
   'use strict';
 
diff --git a/browser/base/content/promises/polypromise-injector.jsm.bak b/browser/base/content/promises/polypromise-injector.jsm.bak
deleted file mode 100644
index 2c49841d7..000000000
--- a/browser/base/content/promises/polypromise-injector.jsm.bak
+++ /dev/null
@@ -1,178 +0,0 @@
-/* coded by Ketmar // Invisible Vector (psyc://ketmar.no-ip.org/~Ketmar)
- * Understanding is not required. Only obedience.
- *
- * This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
- * If a copy of the MPL was not distributed with this file, 
- * You can obtain one at http://mozilla.org/MPL/2.0/. */
-////////////////////////////////////////////////////////////////////////////////
-let EXPORTED_SYMBOLS = [];
-
-const {utils:Cu, classes:Cc, interfaces:Ci, results:Cr} = Components;
-
-Cu.import("resource://gre/modules/Services.jsm");
-Cu.import("resource://gre/modules/XPCOMUtils.jsm");
-
-
-const debugLog = true;
-
-
-////////////////////////////////////////////////////////////////////////////////
-function loadTextContentsFromUrl (url, encoding) {
-  if (typeof(encoding) !== "string") encoding = "UTF-8"; else encoding = encoding||"UTF-8";
-
-  function toUnicode (text) {
-    if (typeof(text) === "string") {
-      if (text.length == 0) return "";
-    } else if (text instanceof ArrayBuffer) {
-      if (text.byteLength == 0) return "";
-      text = new Uint8Array(text);
-      return new TextDecoder(encoding).decode(text);
-    } else if ((text instanceof Uint8Array) || (text instanceof Int8Array)) {
-      if (text.length == 0) return "";
-      return new TextDecoder(encoding).decode(text);
-    } else {
-      return "";
-    }
-    let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
-    converter.charset = encoding;
-    return converter.ConvertToUnicode(text);
-  }
-
-  // download from URL
-  let req = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance();
-  req.mozBackgroundRequest = true;
-  req.open("GET", url, false);
-  req.timeout = 30*1000;
-  let cirq = Ci.nsIRequest;
-  req.channel.loadFlags |= cirq.INHIBIT_CACHING|cirq.INHIBIT_PERSISTENT_CACHING|cirq.LOAD_BYPASS_CACHE|cirq.LOAD_ANONYMOUS;
-  req.responseType = "arraybuffer";
-  let error = false;
-  req.onerror = function () { error = true; }; // just in case
-  req.ontimeout = function () { error = true; }; // just in case
-  req.send(null);
-  if (!error) error = (req.status != 0 && Math.floor(req.status/100) != 2);
-  if (error) throw new Error("can't load URI contents: status="+req.status+"; error="+error);
-  return toUnicode(req.response, encoding);
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// load promise library
-let ppfsrc = loadTextContentsFromUrl("chrome://browser/content/promises/data/es6-promise.code.js");
-//let ppfsrc = loadTextContentsFromUrl("chrome://browser/content/promises/data/es6-shim.js");
-//Cu.reportError("ppfsrc.length="+ppfsrc.length);
-
-
-////////////////////////////////////////////////////////////////////////////////
-function createSandbox (domWin) {
-  // create "unwrapped" sandbox
-  let sandbox = Cu.Sandbox(domWin, {
-    sandboxName: "unwrapped-polypromise",
-    sameZoneAs: domWin, // help GC a little
-    sandboxPrototype: domWin,
-    wantXrays: false,
-  });
-
-  Object.defineProperty(sandbox, "GM_info", {
-    get: function () "42",
-  });
-
-  // nuke sandbox when this window unloaded (this helps GC)
-  domWin.addEventListener("unload", function () {
-    if (sandbox) {
-      Cu.nukeSandbox(sandbox);
-      sandbox = null;
-    }
-  }, true);
-
-  //Cu.reportError("SBOX="+sandbox);
-  return sandbox;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-function ContentObserver () {}
-
-
-ContentObserver.prototype = {
-  QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]),
-
-  observe: function (aSubject, aTopic, aData) {
-    if (aTopic === "document-element-inserted") {
-      // get `document` object
-      let doc = aSubject;
-      if (!doc) return;
-      // don't tamper with XUL documents
-      if (!(doc instanceof Ci.nsIDOMHTMLDocument)) return //not html document, so its likely an XUL document
-      // get `window` object
-      let win = doc.defaultView;
-      if (!win) return;
-      // don't tamper with chrome windows
-      if (win instanceof Ci.nsIDOMChromeWindow) return;
-      // just in case, this should never be `true`
-      if (!(win instanceof Ci.nsIDOMWindow)) {
-        if (debugLog) Cu.reportError("*** WTF: ["+(doc.documentURI ? doc.documentURI : "<unknown>")+"]");
-        return;
-      }
-      // no need to check for URI scheme here:
-      // we want this API to be universally available, so
-      // inject it in *any* normal DOM window, and be happy
-      if (debugLog) Cu.reportError("ppfsrc.length="+ppfsrc.length+"; ["+(doc.documentURI ? doc.documentURI : "<unknown>")+"]");
-      //
-      let w = (win.wrappedJSObject||win);
-      if (debugLog) w.conlogx = (function () {
-        let s = "";
-        for (let idx = 0; idx < arguments.length; ++idx) s += arguments[idx];
-        if (s) Cu.reportError("LOG: "+s);
-      }).bind(win);
-      // define Promise lazy loader (we don't need to inject it each time; load it on demand)
-      let prmObject = null;
-      let prmLoaded = false;
-      let unloadListenerAdded = false;
-      Object.defineProperty(w, "Promise", {
-        get: (function () {
-          if (debugLog) Cu.reportError("***["+doc.documentURI+"] getter");
-          if (prmLoaded) return prmObject;
-          prmLoaded = true;
-          if (debugLog) Cu.reportError("***["+doc.documentURI+"] calculating...");
-          let sandbox = createSandbox(win);
-          Cu.evalInSandbox(ppfsrc, sandbox, "ECMAv5");
-          if (debugLog) Cu.reportError("***["+doc.documentURI+"] calculated: "+typeof(prmObject));
-          return prmObject;
-        }).bind(win),
-        set: (function (val) {
-          if (debugLog) Cu.reportError("***["+doc.documentURI+"] setting to: "+typeof(val));
-          prmLoaded = true;
-          prmObject = val;
-          if (!unloadListenerAdded) {
-            unloadListenerAdded = true;
-            win.addEventListener("unload", function () {
-              prmObject = null;
-              prmLoaded = false;
-            }, true);
-          }
-          return val;
-        }).bind(win),
-        configurable: true,
-        enumerable: true,
-      });
-      if (debugLog) Cu.reportError("***["+doc.documentURI+"] API set");
-    }
-  }
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-let contentObserver = new ContentObserver();
-
-
-////////////////////////////////////////////////////////////////////////////////
-Services.obs.addObserver(contentObserver, "document-element-inserted", false);
-
-
-////////////////////////////////////////////////////////////////////////////////
-/*
-win.addEventListener("unload", function () {
-  Services.obs.removeObserver(contentObserver, "document-element-inserted");
-}, false);
-*/