docs: function Promise(callback, handler) {
  			// The `handler` variable points to the function that will
  			// 1) handle a .then(resolved, rejected) call
  			// 2) handle a resolve or reject call (if the first argument === `is`)
  			// Before 2), `handler` holds a queue of callbacks.
  			// After 2), `handler` is a finalized .then handler.
  			handler = function pendingHandler(resolved, rejected, value, queue, then, i) {
  				queue = pendingHandler.q;
  
  				// Case 1) handle a .then(resolved, rejected) call
  				if (resolved != is) {
  					return Promise(function (resolve, reject) {
  						queue.push({ p: this, r: resolve, j: reject, 1: resolved, 0: rejected });
  					});
  				}
  
  				// Case 2) handle a resolve or reject call
  				// (`resolved` === `is` acts as a sentinel)
  				// The actual function signature is
  				// .re[ject|solve](<is>, success, value)
  
  				// Check if the value is a promise and try to obtain its `then` method
  				if (value && (is(func, value) | is(obj, value))) {
  					try { then = value.then; }
  					catch (reason) { rejected = 0; value = reason; }
  				}
  				// If the value is a promise, take over its state
  				if (is(func, then)) {
  					function valueHandler(resolved) {
  						return function (value) { then && (then = 0, pendingHandler(is, resolved, value)); };
  					}
  					try { then.call(value, valueHandler(1), rejected = valueHandler(0)); }
  					catch (reason) { rejected(reason); }
  				}
  				// The value is not a promise; handle resolve/reject
  				else {
  					// Replace this handler with a finalized resolved/rejected handler
  					handler = function (Resolved, Rejected) {
  						// If the Resolved or Rejected parameter is not a function,
  						// return the original promise (now stored in the `callback` variable)
  						if (!is(func, (Resolved = rejected ? Resolved : Rejected)))
  							return callback;
  						// Otherwise, return a finalized promise, transforming the value with the function
  						return Promise(function (resolve, reject) { finalize(this, resolve, reject, value, Resolved); });
  					};
  					// Resolve/reject pending callbacks
  					i = 0;
  					while (i < queue.length) {
  						then = queue[i++];
  						// If no callback, just resolve/reject the promise
  						if (!is(func, resolved = then[rejected]))
  							(rejected ? then.r : then.j)(value);
  						// Otherwise, resolve/reject the promise with the result of the callback
  						else
  							finalize(then.p, then.r, then.j, value, resolved);
  					}
  				}
  			};
  			// The queue of pending callbacks; garbage-collected when handler is resolved/rejected
  			handler.q = [];
  
  			// Create and return the promise (reusing the callback variable)
  			callback.call(callback = { then:    function (resolved, rejected) { return handler(resolved, rejected); },
  					"catch": function (rejected)           { return handler(0,        rejected); } },
  				function (value)  { handler(is, 1,  value); },
  				function (reason) { handler(is, 0, reason); });
  			return callback;
  		}