www.aleph1.co.uk Git - yaffs-website/blob - node_modules/bluebird/js/release/debuggability.js

   1 "use strict";
   2 module.exports = function(Promise, Context) {
   3 var getDomain = Promise._getDomain;
   4 var async = Promise._async;
   5 var Warning = require("./errors").Warning;
   6 var util = require("./util");
   7 var canAttachTrace = util.canAttachTrace;
   8 var unhandledRejectionHandled;
   9 var possiblyUnhandledRejection;
  10 var bluebirdFramePattern =
  11     /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
  12 var stackFramePattern = null;
  13 var formatStack = null;
  14 var indentStackFrames = false;
  15 var printWarning;
  16 var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
  17                         (false ||
  18                          util.env("BLUEBIRD_DEBUG") ||
  19                          util.env("NODE_ENV") === "development"));
  20
  21 var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
  22     (debugging || util.env("BLUEBIRD_WARNINGS")));
  23
  24 var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
  25     (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
  26
  27 var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
  28     (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
  29
  30 Promise.prototype.suppressUnhandledRejections = function() {
  31     var target = this._target();
  32     target._bitField = ((target._bitField & (~1048576)) |
  33                       524288);
  34 };
  35
  36 Promise.prototype._ensurePossibleRejectionHandled = function () {
  37     if ((this._bitField & 524288) !== 0) return;
  38     this._setRejectionIsUnhandled();
  39     async.invokeLater(this._notifyUnhandledRejection, this, undefined);
  40 };
  41
  42 Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
  43     fireRejectionEvent("rejectionHandled",
  44                                   unhandledRejectionHandled, undefined, this);
  45 };
  46
  47 Promise.prototype._setReturnedNonUndefined = function() {
  48     this._bitField = this._bitField | 268435456;
  49 };
  50
  51 Promise.prototype._returnedNonUndefined = function() {
  52     return (this._bitField & 268435456) !== 0;
  53 };
  54
  55 Promise.prototype._notifyUnhandledRejection = function () {
  56     if (this._isRejectionUnhandled()) {
  57         var reason = this._settledValue();
  58         this._setUnhandledRejectionIsNotified();
  59         fireRejectionEvent("unhandledRejection",
  60                                       possiblyUnhandledRejection, reason, this);
  61     }
  62 };
  63
  64 Promise.prototype._setUnhandledRejectionIsNotified = function () {
  65     this._bitField = this._bitField | 262144;
  66 };
  67
  68 Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
  69     this._bitField = this._bitField & (~262144);
  70 };
  71
  72 Promise.prototype._isUnhandledRejectionNotified = function () {
  73     return (this._bitField & 262144) > 0;
  74 };
  75
  76 Promise.prototype._setRejectionIsUnhandled = function () {
  77     this._bitField = this._bitField | 1048576;
  78 };
  79
  80 Promise.prototype._unsetRejectionIsUnhandled = function () {
  81     this._bitField = this._bitField & (~1048576);
  82     if (this._isUnhandledRejectionNotified()) {
  83         this._unsetUnhandledRejectionIsNotified();
  84         this._notifyUnhandledRejectionIsHandled();
  85     }
  86 };
  87
  88 Promise.prototype._isRejectionUnhandled = function () {
  89     return (this._bitField & 1048576) > 0;
  90 };
  91
  92 Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
  93     return warn(message, shouldUseOwnTrace, promise || this);
  94 };
  95
  96 Promise.onPossiblyUnhandledRejection = function (fn) {
  97     var domain = getDomain();
  98     possiblyUnhandledRejection =
  99         typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
 100                                  : undefined;
 101 };
 102
 103 Promise.onUnhandledRejectionHandled = function (fn) {
 104     var domain = getDomain();
 105     unhandledRejectionHandled =
 106         typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
 107                                  : undefined;
 108 };
 109
 110 var disableLongStackTraces = function() {};
 111 Promise.longStackTraces = function () {
 112     if (async.haveItemsQueued() && !config.longStackTraces) {
 113         throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
 114     }
 115     if (!config.longStackTraces && longStackTracesIsSupported()) {
 116         var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
 117         var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
 118         config.longStackTraces = true;
 119         disableLongStackTraces = function() {
 120             if (async.haveItemsQueued() && !config.longStackTraces) {
 121                 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a    See http://goo.gl/MqrFmX\u000a");
 122             }
 123             Promise.prototype._captureStackTrace = Promise_captureStackTrace;
 124             Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
 125             Context.deactivateLongStackTraces();
 126             async.enableTrampoline();
 127             config.longStackTraces = false;
 128         };
 129         Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
 130         Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
 131         Context.activateLongStackTraces();
 132         async.disableTrampolineIfNecessary();
 133     }
 134 };
 135
 136 Promise.hasLongStackTraces = function () {
 137     return config.longStackTraces && longStackTracesIsSupported();
 138 };
 139
 140 Promise.config = function(opts) {
 141     opts = Object(opts);
 142     if ("longStackTraces" in opts) {
 143         if (opts.longStackTraces) {
 144             Promise.longStackTraces();
 145         } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
 146             disableLongStackTraces();
 147         }
 148     }
 149     if ("warnings" in opts) {
 150         var warningsOption = opts.warnings;
 151         config.warnings = !!warningsOption;
 152         wForgottenReturn = config.warnings;
 153
 154         if (util.isObject(warningsOption)) {
 155             if ("wForgottenReturn" in warningsOption) {
 156                 wForgottenReturn = !!warningsOption.wForgottenReturn;
 157             }
 158         }
 159     }
 160     if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
 161         if (async.haveItemsQueued()) {
 162             throw new Error(
 163                 "cannot enable cancellation after promises are in use");
 164         }
 165         Promise.prototype._clearCancellationData =
 166             cancellationClearCancellationData;
 167         Promise.prototype._propagateFrom = cancellationPropagateFrom;
 168         Promise.prototype._onCancel = cancellationOnCancel;
 169         Promise.prototype._setOnCancel = cancellationSetOnCancel;
 170         Promise.prototype._attachCancellationCallback =
 171             cancellationAttachCancellationCallback;
 172         Promise.prototype._execute = cancellationExecute;
 173         propagateFromFunction = cancellationPropagateFrom;
 174         config.cancellation = true;
 175     }
 176 };
 177
 178 Promise.prototype._execute = function(executor, resolve, reject) {
 179     try {
 180         executor(resolve, reject);
 181     } catch (e) {
 182         return e;
 183     }
 184 };
 185 Promise.prototype._onCancel = function () {};
 186 Promise.prototype._setOnCancel = function (handler) { ; };
 187 Promise.prototype._attachCancellationCallback = function(onCancel) {
 188     ;
 189 };
 190 Promise.prototype._captureStackTrace = function () {};
 191 Promise.prototype._attachExtraTrace = function () {};
 192 Promise.prototype._clearCancellationData = function() {};
 193 Promise.prototype._propagateFrom = function (parent, flags) {
 194     ;
 195     ;
 196 };
 197
 198 function cancellationExecute(executor, resolve, reject) {
 199     var promise = this;
 200     try {
 201         executor(resolve, reject, function(onCancel) {
 202             if (typeof onCancel !== "function") {
 203                 throw new TypeError("onCancel must be a function, got: " +
 204                                     util.toString(onCancel));
 205             }
 206             promise._attachCancellationCallback(onCancel);
 207         });
 208     } catch (e) {
 209         return e;
 210     }
 211 }
 212
 213 function cancellationAttachCancellationCallback(onCancel) {
 214     if (!this.isCancellable()) return this;
 215
 216     var previousOnCancel = this._onCancel();
 217     if (previousOnCancel !== undefined) {
 218         if (util.isArray(previousOnCancel)) {
 219             previousOnCancel.push(onCancel);
 220         } else {
 221             this._setOnCancel([previousOnCancel, onCancel]);
 222         }
 223     } else {
 224         this._setOnCancel(onCancel);
 225     }
 226 }
 227
 228 function cancellationOnCancel() {
 229     return this._onCancelField;
 230 }
 231
 232 function cancellationSetOnCancel(onCancel) {
 233     this._onCancelField = onCancel;
 234 }
 235
 236 function cancellationClearCancellationData() {
 237     this._cancellationParent = undefined;
 238     this._onCancelField = undefined;
 239 }
 240
 241 function cancellationPropagateFrom(parent, flags) {
 242     if ((flags & 1) !== 0) {
 243         this._cancellationParent = parent;
 244         var branchesRemainingToCancel = parent._branchesRemainingToCancel;
 245         if (branchesRemainingToCancel === undefined) {
 246             branchesRemainingToCancel = 0;
 247         }
 248         parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
 249     }
 250     if ((flags & 2) !== 0 && parent._isBound()) {
 251         this._setBoundTo(parent._boundTo);
 252     }
 253 }
 254
 255 function bindingPropagateFrom(parent, flags) {
 256     if ((flags & 2) !== 0 && parent._isBound()) {
 257         this._setBoundTo(parent._boundTo);
 258     }
 259 }
 260 var propagateFromFunction = bindingPropagateFrom;
 261
 262 function boundValueFunction() {
 263     var ret = this._boundTo;
 264     if (ret !== undefined) {
 265         if (ret instanceof Promise) {
 266             if (ret.isFulfilled()) {
 267                 return ret.value();
 268             } else {
 269                 return undefined;
 270             }
 271         }
 272     }
 273     return ret;
 274 }
 275
 276 function longStackTracesCaptureStackTrace() {
 277     this._trace = new CapturedTrace(this._peekContext());
 278 }
 279
 280 function longStackTracesAttachExtraTrace(error, ignoreSelf) {
 281     if (canAttachTrace(error)) {
 282         var trace = this._trace;
 283         if (trace !== undefined) {
 284             if (ignoreSelf) trace = trace._parent;
 285         }
 286         if (trace !== undefined) {
 287             trace.attachExtraTrace(error);
 288         } else if (!error.__stackCleaned__) {
 289             var parsed = parseStackAndMessage(error);
 290             util.notEnumerableProp(error, "stack",
 291                 parsed.message + "\n" + parsed.stack.join("\n"));
 292             util.notEnumerableProp(error, "__stackCleaned__", true);
 293         }
 294     }
 295 }
 296
 297 function checkForgottenReturns(returnValue, promiseCreated, name, promise,
 298                                parent) {
 299     if (returnValue === undefined && promiseCreated !== null &&
 300         wForgottenReturn) {
 301         if (parent !== undefined && parent._returnedNonUndefined()) return;
 302
 303         if (name) name = name + " ";
 304         var msg = "a promise was created in a " + name +
 305             "handler but was not returned from it";
 306         promise._warn(msg, true, promiseCreated);
 307     }
 308 }
 309
 310 function deprecated(name, replacement) {
 311     var message = name +
 312         " is deprecated and will be removed in a future version.";
 313     if (replacement) message += " Use " + replacement + " instead.";
 314     return warn(message);
 315 }
 316
 317 function warn(message, shouldUseOwnTrace, promise) {
 318     if (!config.warnings) return;
 319     var warning = new Warning(message);
 320     var ctx;
 321     if (shouldUseOwnTrace) {
 322         promise._attachExtraTrace(warning);
 323     } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
 324         ctx.attachExtraTrace(warning);
 325     } else {
 326         var parsed = parseStackAndMessage(warning);
 327         warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
 328     }
 329     formatAndLogError(warning, "", true);
 330 }
 331
 332 function reconstructStack(message, stacks) {
 333     for (var i = 0; i < stacks.length - 1; ++i) {
 334         stacks[i].push("From previous event:");
 335         stacks[i] = stacks[i].join("\n");
 336     }
 337     if (i < stacks.length) {
 338         stacks[i] = stacks[i].join("\n");
 339     }
 340     return message + "\n" + stacks.join("\n");
 341 }
 342
 343 function removeDuplicateOrEmptyJumps(stacks) {
 344     for (var i = 0; i < stacks.length; ++i) {
 345         if (stacks[i].length === 0 ||
 346             ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
 347             stacks.splice(i, 1);
 348             i--;
 349         }
 350     }
 351 }
 352
 353 function removeCommonRoots(stacks) {
 354     var current = stacks[0];
 355     for (var i = 1; i < stacks.length; ++i) {
 356         var prev = stacks[i];
 357         var currentLastIndex = current.length - 1;
 358         var currentLastLine = current[currentLastIndex];
 359         var commonRootMeetPoint = -1;
 360
 361         for (var j = prev.length - 1; j >= 0; --j) {
 362             if (prev[j] === currentLastLine) {
 363                 commonRootMeetPoint = j;
 364                 break;
 365             }
 366         }
 367
 368         for (var j = commonRootMeetPoint; j >= 0; --j) {
 369             var line = prev[j];
 370             if (current[currentLastIndex] === line) {
 371                 current.pop();
 372                 currentLastIndex--;
 373             } else {
 374                 break;
 375             }
 376         }
 377         current = prev;
 378     }
 379 }
 380
 381 function cleanStack(stack) {
 382     var ret = [];
 383     for (var i = 0; i < stack.length; ++i) {
 384         var line = stack[i];
 385         var isTraceLine = "    (No stack trace)" === line ||
 386             stackFramePattern.test(line);
 387         var isInternalFrame = isTraceLine && shouldIgnore(line);
 388         if (isTraceLine && !isInternalFrame) {
 389             if (indentStackFrames && line.charAt(0) !== " ") {
 390                 line = "    " + line;
 391             }
 392             ret.push(line);
 393         }
 394     }
 395     return ret;
 396 }
 397
 398 function stackFramesAsArray(error) {
 399     var stack = error.stack.replace(/\s+$/g, "").split("\n");
 400     for (var i = 0; i < stack.length; ++i) {
 401         var line = stack[i];
 402         if ("    (No stack trace)" === line || stackFramePattern.test(line)) {
 403             break;
 404         }
 405     }
 406     if (i > 0) {
 407         stack = stack.slice(i);
 408     }
 409     return stack;
 410 }
 411
 412 function parseStackAndMessage(error) {
 413     var stack = error.stack;
 414     var message = error.toString();
 415     stack = typeof stack === "string" && stack.length > 0
 416                 ? stackFramesAsArray(error) : ["    (No stack trace)"];
 417     return {
 418         message: message,
 419         stack: cleanStack(stack)
 420     };
 421 }
 422
 423 function formatAndLogError(error, title, isSoft) {
 424     if (typeof console !== "undefined") {
 425         var message;
 426         if (util.isObject(error)) {
 427             var stack = error.stack;
 428             message = title + formatStack(stack, error);
 429         } else {
 430             message = title + String(error);
 431         }
 432         if (typeof printWarning === "function") {
 433             printWarning(message, isSoft);
 434         } else if (typeof console.log === "function" ||
 435             typeof console.log === "object") {
 436             console.log(message);
 437         }
 438     }
 439 }
 440
 441 function fireRejectionEvent(name, localHandler, reason, promise) {
 442     var localEventFired = false;
 443     try {
 444         if (typeof localHandler === "function") {
 445             localEventFired = true;
 446             if (name === "rejectionHandled") {
 447                 localHandler(promise);
 448             } else {
 449                 localHandler(reason, promise);
 450             }
 451         }
 452     } catch (e) {
 453         async.throwLater(e);
 454     }
 455
 456     var globalEventFired = false;
 457     try {
 458         globalEventFired = fireGlobalEvent(name, reason, promise);
 459     } catch (e) {
 460         globalEventFired = true;
 461         async.throwLater(e);
 462     }
 463
 464     var domEventFired = false;
 465     if (fireDomEvent) {
 466         try {
 467             domEventFired = fireDomEvent(name.toLowerCase(), {
 468                 reason: reason,
 469                 promise: promise
 470             });
 471         } catch (e) {
 472             domEventFired = true;
 473             async.throwLater(e);
 474         }
 475     }
 476
 477     if (!globalEventFired && !localEventFired && !domEventFired &&
 478         name === "unhandledRejection") {
 479         formatAndLogError(reason, "Unhandled rejection ");
 480     }
 481 }
 482
 483 function formatNonError(obj) {
 484     var str;
 485     if (typeof obj === "function") {
 486         str = "[function " +
 487             (obj.name || "anonymous") +
 488             "]";
 489     } else {
 490         str = obj && typeof obj.toString === "function"
 491             ? obj.toString() : util.toString(obj);
 492         var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
 493         if (ruselessToString.test(str)) {
 494             try {
 495                 var newStr = JSON.stringify(obj);
 496                 str = newStr;
 497             }
 498             catch(e) {
 499
 500             }
 501         }
 502         if (str.length === 0) {
 503             str = "(empty array)";
 504         }
 505     }
 506     return ("(<" + snip(str) + ">, no stack trace)");
 507 }
 508
 509 function snip(str) {
 510     var maxChars = 41;
 511     if (str.length < maxChars) {
 512         return str;
 513     }
 514     return str.substr(0, maxChars - 3) + "...";
 515 }
 516
 517 function longStackTracesIsSupported() {
 518     return typeof captureStackTrace === "function";
 519 }
 520
 521 var shouldIgnore = function() { return false; };
 522 var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
 523 function parseLineInfo(line) {
 524     var matches = line.match(parseLineInfoRegex);
 525     if (matches) {
 526         return {
 527             fileName: matches[1],
 528             line: parseInt(matches[2], 10)
 529         };
 530     }
 531 }
 532
 533 function setBounds(firstLineError, lastLineError) {
 534     if (!longStackTracesIsSupported()) return;
 535     var firstStackLines = firstLineError.stack.split("\n");
 536     var lastStackLines = lastLineError.stack.split("\n");
 537     var firstIndex = -1;
 538     var lastIndex = -1;
 539     var firstFileName;
 540     var lastFileName;
 541     for (var i = 0; i < firstStackLines.length; ++i) {
 542         var result = parseLineInfo(firstStackLines[i]);
 543         if (result) {
 544             firstFileName = result.fileName;
 545             firstIndex = result.line;
 546             break;
 547         }
 548     }
 549     for (var i = 0; i < lastStackLines.length; ++i) {
 550         var result = parseLineInfo(lastStackLines[i]);
 551         if (result) {
 552             lastFileName = result.fileName;
 553             lastIndex = result.line;
 554             break;
 555         }
 556     }
 557     if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
 558         firstFileName !== lastFileName || firstIndex >= lastIndex) {
 559         return;
 560     }
 561
 562     shouldIgnore = function(line) {
 563         if (bluebirdFramePattern.test(line)) return true;
 564         var info = parseLineInfo(line);
 565         if (info) {
 566             if (info.fileName === firstFileName &&
 567                 (firstIndex <= info.line && info.line <= lastIndex)) {
 568                 return true;
 569             }
 570         }
 571         return false;
 572     };
 573 }
 574
 575 function CapturedTrace(parent) {
 576     this._parent = parent;
 577     this._promisesCreated = 0;
 578     var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
 579     captureStackTrace(this, CapturedTrace);
 580     if (length > 32) this.uncycle();
 581 }
 582 util.inherits(CapturedTrace, Error);
 583 Context.CapturedTrace = CapturedTrace;
 584
 585 CapturedTrace.prototype.uncycle = function() {
 586     var length = this._length;
 587     if (length < 2) return;
 588     var nodes = [];
 589     var stackToIndex = {};
 590
 591     for (var i = 0, node = this; node !== undefined; ++i) {
 592         nodes.push(node);
 593         node = node._parent;
 594     }
 595     length = this._length = i;
 596     for (var i = length - 1; i >= 0; --i) {
 597         var stack = nodes[i].stack;
 598         if (stackToIndex[stack] === undefined) {
 599             stackToIndex[stack] = i;
 600         }
 601     }
 602     for (var i = 0; i < length; ++i) {
 603         var currentStack = nodes[i].stack;
 604         var index = stackToIndex[currentStack];
 605         if (index !== undefined && index !== i) {
 606             if (index > 0) {
 607                 nodes[index - 1]._parent = undefined;
 608                 nodes[index - 1]._length = 1;
 609             }
 610             nodes[i]._parent = undefined;
 611             nodes[i]._length = 1;
 612             var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
 613
 614             if (index < length - 1) {
 615                 cycleEdgeNode._parent = nodes[index + 1];
 616                 cycleEdgeNode._parent.uncycle();
 617                 cycleEdgeNode._length =
 618                     cycleEdgeNode._parent._length + 1;
 619             } else {
 620                 cycleEdgeNode._parent = undefined;
 621                 cycleEdgeNode._length = 1;
 622             }
 623             var currentChildLength = cycleEdgeNode._length + 1;
 624             for (var j = i - 2; j >= 0; --j) {
 625                 nodes[j]._length = currentChildLength;
 626                 currentChildLength++;
 627             }
 628             return;
 629         }
 630     }
 631 };
 632
 633 CapturedTrace.prototype.attachExtraTrace = function(error) {
 634     if (error.__stackCleaned__) return;
 635     this.uncycle();
 636     var parsed = parseStackAndMessage(error);
 637     var message = parsed.message;
 638     var stacks = [parsed.stack];
 639
 640     var trace = this;
 641     while (trace !== undefined) {
 642         stacks.push(cleanStack(trace.stack.split("\n")));
 643         trace = trace._parent;
 644     }
 645     removeCommonRoots(stacks);
 646     removeDuplicateOrEmptyJumps(stacks);
 647     util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
 648     util.notEnumerableProp(error, "__stackCleaned__", true);
 649 };
 650
 651 var captureStackTrace = (function stackDetection() {
 652     var v8stackFramePattern = /^\s*at\s*/;
 653     var v8stackFormatter = function(stack, error) {
 654         if (typeof stack === "string") return stack;
 655
 656         if (error.name !== undefined &&
 657             error.message !== undefined) {
 658             return error.toString();
 659         }
 660         return formatNonError(error);
 661     };
 662
 663     if (typeof Error.stackTraceLimit === "number" &&
 664         typeof Error.captureStackTrace === "function") {
 665         Error.stackTraceLimit += 6;
 666         stackFramePattern = v8stackFramePattern;
 667         formatStack = v8stackFormatter;
 668         var captureStackTrace = Error.captureStackTrace;
 669
 670         shouldIgnore = function(line) {
 671             return bluebirdFramePattern.test(line);
 672         };
 673         return function(receiver, ignoreUntil) {
 674             Error.stackTraceLimit += 6;
 675             captureStackTrace(receiver, ignoreUntil);
 676             Error.stackTraceLimit -= 6;
 677         };
 678     }
 679     var err = new Error();
 680
 681     if (typeof err.stack === "string" &&
 682         err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
 683         stackFramePattern = /@/;
 684         formatStack = v8stackFormatter;
 685         indentStackFrames = true;
 686         return function captureStackTrace(o) {
 687             o.stack = new Error().stack;
 688         };
 689     }
 690
 691     var hasStackAfterThrow;
 692     try { throw new Error(); }
 693     catch(e) {
 694         hasStackAfterThrow = ("stack" in e);
 695     }
 696     if (!("stack" in err) && hasStackAfterThrow &&
 697         typeof Error.stackTraceLimit === "number") {
 698         stackFramePattern = v8stackFramePattern;
 699         formatStack = v8stackFormatter;
 700         return function captureStackTrace(o) {
 701             Error.stackTraceLimit += 6;
 702             try { throw new Error(); }
 703             catch(e) { o.stack = e.stack; }
 704             Error.stackTraceLimit -= 6;
 705         };
 706     }
 707
 708     formatStack = function(stack, error) {
 709         if (typeof stack === "string") return stack;
 710
 711         if ((typeof error === "object" ||
 712             typeof error === "function") &&
 713             error.name !== undefined &&
 714             error.message !== undefined) {
 715             return error.toString();
 716         }
 717         return formatNonError(error);
 718     };
 719
 720     return null;
 721
 722 })([]);
 723
 724 var fireDomEvent;
 725 var fireGlobalEvent = (function() {
 726     if (util.isNode) {
 727         return function(name, reason, promise) {
 728             if (name === "rejectionHandled") {
 729                 return process.emit(name, promise);
 730             } else {
 731                 return process.emit(name, reason, promise);
 732             }
 733         };
 734     } else {
 735         var globalObject = typeof self !== "undefined" ? self :
 736                      typeof window !== "undefined" ? window :
 737                      typeof global !== "undefined" ? global :
 738                      this !== undefined ? this : null;
 739
 740         if (!globalObject) {
 741             return function() {
 742                 return false;
 743             };
 744         }
 745
 746         try {
 747             var event = document.createEvent("CustomEvent");
 748             event.initCustomEvent("testingtheevent", false, true, {});
 749             globalObject.dispatchEvent(event);
 750             fireDomEvent = function(type, detail) {
 751                 var event = document.createEvent("CustomEvent");
 752                 event.initCustomEvent(type, false, true, detail);
 753                 return !globalObject.dispatchEvent(event);
 754             };
 755         } catch (e) {}
 756
 757         var toWindowMethodNameMap = {};
 758         toWindowMethodNameMap["unhandledRejection"] = ("on" +
 759             "unhandledRejection").toLowerCase();
 760         toWindowMethodNameMap["rejectionHandled"] = ("on" +
 761             "rejectionHandled").toLowerCase();
 762
 763         return function(name, reason, promise) {
 764             var methodName = toWindowMethodNameMap[name];
 765             var method = globalObject[methodName];
 766             if (!method) return false;
 767             if (name === "rejectionHandled") {
 768                 method.call(globalObject, promise);
 769             } else {
 770                 method.call(globalObject, reason, promise);
 771             }
 772             return true;
 773         };
 774     }
 775 })();
 776
 777 if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
 778     printWarning = function (message) {
 779         console.warn(message);
 780     };
 781     if (util.isNode && process.stderr.isTTY) {
 782         printWarning = function(message, isSoft) {
 783             var color = isSoft ? "\u001b[33m" : "\u001b[31m";
 784             console.warn(color + message + "\u001b[0m\n");
 785         };
 786     } else if (!util.isNode && typeof (new Error().stack) === "string") {
 787         printWarning = function(message, isSoft) {
 788             console.warn("%c" + message,
 789                         isSoft ? "color: darkorange" : "color: red");
 790         };
 791     }
 792 }
 793
 794 var config = {
 795     warnings: warnings,
 796     longStackTraces: false,
 797     cancellation: false
 798 };
 799
 800 if (longStackTraces) Promise.longStackTraces();
 801
 802 return {
 803     longStackTraces: function() {
 804         return config.longStackTraces;
 805     },
 806     warnings: function() {
 807         return config.warnings;
 808     },
 809     cancellation: function() {
 810         return config.cancellation;
 811     },
 812     propagateFromFunction: function() {
 813         return propagateFromFunction;
 814     },
 815     boundValueFunction: function() {
 816         return boundValueFunction;
 817     },
 818     checkForgottenReturns: checkForgottenReturns,
 819     setBounds: setBounds,
 820     warn: warn,
 821     deprecated: deprecated,
 822     CapturedTrace: CapturedTrace
 823 };
 824 };