Assumes that an ES5 platform where, if {@code WeakMap} is\n * already present, then it conforms to the anticipated ES6\n * specification. To run this file on an ES5 or almost ES5\n * implementation where the {@code WeakMap} specification does not\n * quite conform, run repairES5.js first.\n *\n *
Even though WeakMapModule is not global, the linter thinks it\n * is, which is why it is in the overrides list below.\n *\n *
NOTE: Before using this WeakMap emulation in a non-SES\n * environment, see the note below about hiddenRecord.\n *\n * @author Mark S. Miller\n * @requires crypto, ArrayBuffer, Uint8Array, navigator, console\n * @overrides WeakMap, ses, Proxy\n * @overrides WeakMapModule\n */\n\n/**\n * This {@code WeakMap} emulation is observably equivalent to the\n * ES-Harmony WeakMap, but with leakier garbage collection properties.\n *\n *
As with true WeakMaps, in this emulation, a key does not\n * retain maps indexed by that key and (crucially) a map does not\n * retain the keys it indexes. A map by itself also does not retain\n * the values associated with that map.\n *\n *
However, the values associated with a key in some map are\n * retained so long as that key is retained and those associations are\n * not overridden. For example, when used to support membranes, all\n * values exported from a given membrane will live for the lifetime\n * they would have had in the absence of an interposed membrane. Even\n * when the membrane is revoked, all objects that would have been\n * reachable in the absence of revocation will still be reachable, as\n * far as the GC can tell, even though they will no longer be relevant\n * to ongoing computation.\n *\n *
The API implemented here is approximately the API as implemented\n * in FF6.0a1 and agreed to by MarkM, Andreas Gal, and Dave Herman,\n * rather than the offially approved proposal page. TODO(erights):\n * upgrade the ecmascript WeakMap proposal page to explain this API\n * change and present to EcmaScript committee for their approval.\n *\n *
The first difference between the emulation here and that in\n * FF6.0a1 is the presence of non enumerable {@code get___, has___,\n * set___, and delete___} methods on WeakMap instances to represent\n * what would be the hidden internal properties of a primitive\n * implementation. Whereas the FF6.0a1 WeakMap.prototype methods\n * require their {@code this} to be a genuine WeakMap instance (i.e.,\n * an object of {@code [[Class]]} \"WeakMap}), since there is nothing\n * unforgeable about the pseudo-internal method names used here,\n * nothing prevents these emulated prototype methods from being\n * applied to non-WeakMaps with pseudo-internal methods of the same\n * names.\n *\n *
Another difference is that our emulated {@code\n * WeakMap.prototype} is not itself a WeakMap. A problem with the\n * current FF6.0a1 API is that WeakMap.prototype is itself a WeakMap\n * providing ambient mutability and an ambient communications\n * channel. Thus, if a WeakMap is already present and has this\n * problem, repairES5.js wraps it in a safe wrappper in order to\n * prevent access to this channel. (See\n * PATCH_MUTABLE_FROZEN_WEAKMAP_PROTO in repairES5.js).\n */\n\n/**\n * If this is a full secureable ES5 platform and the ES-Harmony {@code WeakMap} is\n * absent, install an approximate emulation.\n *\n *
If WeakMap is present but cannot store some objects, use our approximate\n * emulation as a wrapper.\n *\n *
If this is almost a secureable ES5 platform, then WeakMap.js\n * should be run after repairES5.js.\n *\n *
See {@code WeakMap} for documentation of the garbage collection\n * properties of this WeakMap emulation.\n */\n(function WeakMapModule() {\n \"use strict\";\n\n if (typeof ses !== 'undefined' && ses.ok && !ses.ok()) {\n // already too broken, so give up\n return;\n }\n\n /**\n * In some cases (current Firefox), we must make a choice betweeen a\n * WeakMap which is capable of using all varieties of host objects as\n * keys and one which is capable of safely using proxies as keys. See\n * comments below about HostWeakMap and DoubleWeakMap for details.\n *\n * This function (which is a global, not exposed to guests) marks a\n * WeakMap as permitted to do what is necessary to index all host\n * objects, at the cost of making it unsafe for proxies.\n *\n * Do not apply this function to anything which is not a genuine\n * fresh WeakMap.\n */\n function weakMapPermitHostObjects(map) {\n // identity of function used as a secret -- good enough and cheap\n if (map.permitHostObjects___) {\n map.permitHostObjects___(weakMapPermitHostObjects);\n }\n }\n if (typeof ses !== 'undefined') {\n ses.weakMapPermitHostObjects = weakMapPermitHostObjects;\n }\n\n // IE 11 has no Proxy but has a broken WeakMap such that we need to patch\n // it using DoubleWeakMap; this flag tells DoubleWeakMap so.\n var doubleWeakMapCheckSilentFailure = false;\n\n // Check if there is already a good-enough WeakMap implementation, and if so\n // exit without replacing it.\n if (typeof WeakMap === 'function') {\n var HostWeakMap = WeakMap;\n // There is a WeakMap -- is it good enough?\n if (typeof navigator !== 'undefined' &&\n /Firefox/.test(navigator.userAgent)) {\n // We're now *assuming not*, because as of this writing (2013-05-06)\n // Firefox's WeakMaps have a miscellany of objects they won't accept, and\n // we don't want to make an exhaustive list, and testing for just one\n // will be a problem if that one is fixed alone (as they did for Event).\n\n // If there is a platform that we *can* reliably test on, here's how to\n // do it:\n // var problematic = ... ;\n // var testHostMap = new HostWeakMap();\n // try {\n // testHostMap.set(problematic, 1); // Firefox 20 will throw here\n // if (testHostMap.get(problematic) === 1) {\n // return;\n // }\n // } catch (e) {}\n\n } else {\n // IE 11 bug: WeakMaps silently fail to store frozen objects.\n var testMap = new HostWeakMap();\n var testObject = Object.freeze({});\n testMap.set(testObject, 1);\n if (testMap.get(testObject) !== 1) {\n doubleWeakMapCheckSilentFailure = true;\n // Fall through to installing our WeakMap.\n } else {\n module.exports = WeakMap;\n return;\n }\n }\n }\n\n var hop = Object.prototype.hasOwnProperty;\n var gopn = Object.getOwnPropertyNames;\n var defProp = Object.defineProperty;\n var isExtensible = Object.isExtensible;\n\n /**\n * Security depends on HIDDEN_NAME being both unguessable and\n * undiscoverable by untrusted code.\n *\n *
Given the known weaknesses of Math.random() on existing\n * browsers, it does not generate unguessability we can be confident\n * of.\n *\n *
It is the monkey patching logic in this file that is intended\n * to ensure undiscoverability. The basic idea is that there are\n * three fundamental means of discovering properties of an object:\n * The for/in loop, Object.keys(), and Object.getOwnPropertyNames(),\n * as well as some proposed ES6 extensions that appear on our\n * whitelist. The first two only discover enumerable properties, and\n * we only use HIDDEN_NAME to name a non-enumerable property, so the\n * only remaining threat should be getOwnPropertyNames and some\n * proposed ES6 extensions that appear on our whitelist. We monkey\n * patch them to remove HIDDEN_NAME from the list of properties they\n * returns.\n *\n *
TODO(erights): On a platform with built-in Proxies, proxies\n * could be used to trap and thereby discover the HIDDEN_NAME, so we\n * need to monkey patch Proxy.create, Proxy.createFunction, etc, in\n * order to wrap the provided handler with the real handler which\n * filters out all traps using HIDDEN_NAME.\n *\n *
TODO(erights): Revisit Mike Stay's suggestion that we use an\n * encapsulated function at a not-necessarily-secret name, which\n * uses the Stiegler shared-state rights amplification pattern to\n * reveal the associated value only to the WeakMap in which this key\n * is associated with that value. Since only the key retains the\n * function, the function can also remember the key without causing\n * leakage of the key, so this doesn't violate our general gc\n * goals. In addition, because the name need not be a guarded\n * secret, we could efficiently handle cross-frame frozen keys.\n */\n var HIDDEN_NAME_PREFIX = 'weakmap:';\n var HIDDEN_NAME = HIDDEN_NAME_PREFIX + 'ident:' + Math.random() + '___';\n\n if (typeof crypto !== 'undefined' &&\n typeof crypto.getRandomValues === 'function' &&\n typeof ArrayBuffer === 'function' &&\n typeof Uint8Array === 'function') {\n var ab = new ArrayBuffer(25);\n var u8s = new Uint8Array(ab);\n crypto.getRandomValues(u8s);\n HIDDEN_NAME = HIDDEN_NAME_PREFIX + 'rand:' +\n Array.prototype.map.call(u8s, function(u8) {\n return (u8 % 36).toString(36);\n }).join('') + '___';\n }\n\n function isNotHiddenName(name) {\n return !(\n name.substr(0, HIDDEN_NAME_PREFIX.length) == HIDDEN_NAME_PREFIX &&\n name.substr(name.length - 3) === '___');\n }\n\n /**\n * Monkey patch getOwnPropertyNames to avoid revealing the\n * HIDDEN_NAME.\n *\n *
The ES5.1 spec requires each name to appear only once, but as\n * of this writing, this requirement is controversial for ES6, so we\n * made this code robust against this case. If the resulting extra\n * search turns out to be expensive, we can probably relax this once\n * ES6 is adequately supported on all major browsers, iff no browser\n * versions we support at that time have relaxed this constraint\n * without providing built-in ES6 WeakMaps.\n */\n defProp(Object, 'getOwnPropertyNames', {\n value: function fakeGetOwnPropertyNames(obj) {\n return gopn(obj).filter(isNotHiddenName);\n }\n });\n\n /**\n * getPropertyNames is not in ES5 but it is proposed for ES6 and\n * does appear in our whitelist, so we need to clean it too.\n */\n if ('getPropertyNames' in Object) {\n var originalGetPropertyNames = Object.getPropertyNames;\n defProp(Object, 'getPropertyNames', {\n value: function fakeGetPropertyNames(obj) {\n return originalGetPropertyNames(obj).filter(isNotHiddenName);\n }\n });\n }\n\n /**\n *
To treat objects as identity-keys with reasonable efficiency\n * on ES5 by itself (i.e., without any object-keyed collections), we\n * need to add a hidden property to such key objects when we\n * can. This raises several issues:\n *
The monkey patched versions throw a TypeError if their\n * argument is not an object, so it should only be done to functions\n * that should throw a TypeError anyway if their argument is not an\n * object.\n */\n (function(){\n var oldFreeze = Object.freeze;\n defProp(Object, 'freeze', {\n value: function identifyingFreeze(obj) {\n getHiddenRecord(obj);\n return oldFreeze(obj);\n }\n });\n var oldSeal = Object.seal;\n defProp(Object, 'seal', {\n value: function identifyingSeal(obj) {\n getHiddenRecord(obj);\n return oldSeal(obj);\n }\n });\n var oldPreventExtensions = Object.preventExtensions;\n defProp(Object, 'preventExtensions', {\n value: function identifyingPreventExtensions(obj) {\n getHiddenRecord(obj);\n return oldPreventExtensions(obj);\n }\n });\n })();\n\n function constFunc(func) {\n func.prototype = null;\n return Object.freeze(func);\n }\n\n var calledAsFunctionWarningDone = false;\n function calledAsFunctionWarning() {\n // Future ES6 WeakMap is currently (2013-09-10) expected to reject WeakMap()\n // but we used to permit it and do it ourselves, so warn only.\n if (!calledAsFunctionWarningDone && typeof console !== 'undefined') {\n calledAsFunctionWarningDone = true;\n console.warn('WeakMap should be invoked as new WeakMap(), not ' +\n 'WeakMap(). This will be an error in the future.');\n }\n }\n\n var nextId = 0;\n\n var OurWeakMap = function() {\n if (!(this instanceof OurWeakMap)) { // approximate test for new ...()\n calledAsFunctionWarning();\n }\n\n // We are currently (12/25/2012) never encountering any prematurely\n // non-extensible keys.\n var keys = []; // brute force for prematurely non-extensible keys.\n var values = []; // brute force for corresponding values.\n var id = nextId++;\n\n function get___(key, opt_default) {\n var index;\n var hiddenRecord = getHiddenRecord(key);\n if (hiddenRecord) {\n return id in hiddenRecord ? hiddenRecord[id] : opt_default;\n } else {\n index = keys.indexOf(key);\n return index >= 0 ? values[index] : opt_default;\n }\n }\n\n function has___(key) {\n var hiddenRecord = getHiddenRecord(key);\n if (hiddenRecord) {\n return id in hiddenRecord;\n } else {\n return keys.indexOf(key) >= 0;\n }\n }\n\n function set___(key, value) {\n var index;\n var hiddenRecord = getHiddenRecord(key);\n if (hiddenRecord) {\n hiddenRecord[id] = value;\n } else {\n index = keys.indexOf(key);\n if (index >= 0) {\n values[index] = value;\n } else {\n // Since some browsers preemptively terminate slow turns but\n // then continue computing with presumably corrupted heap\n // state, we here defensively get keys.length first and then\n // use it to update both the values and keys arrays, keeping\n // them in sync.\n index = keys.length;\n values[index] = value;\n // If we crash here, values will be one longer than keys.\n keys[index] = key;\n }\n }\n return this;\n }\n\n function delete___(key) {\n var hiddenRecord = getHiddenRecord(key);\n var index, lastIndex;\n if (hiddenRecord) {\n return id in hiddenRecord && delete hiddenRecord[id];\n } else {\n index = keys.indexOf(key);\n if (index < 0) {\n return false;\n }\n // Since some browsers preemptively terminate slow turns but\n // then continue computing with potentially corrupted heap\n // state, we here defensively get keys.length first and then use\n // it to update both the keys and the values array, keeping\n // them in sync. We update the two with an order of assignments,\n // such that any prefix of these assignments will preserve the\n // key/value correspondence, either before or after the delete.\n // Note that this needs to work correctly when index === lastIndex.\n lastIndex = keys.length - 1;\n keys[index] = void 0;\n // If we crash here, there's a void 0 in the keys array, but\n // no operation will cause a \"keys.indexOf(void 0)\", since\n // getHiddenRecord(void 0) will always throw an error first.\n values[index] = values[lastIndex];\n // If we crash here, values[index] cannot be found here,\n // because keys[index] is void 0.\n keys[index] = keys[lastIndex];\n // If index === lastIndex and we crash here, then keys[index]\n // is still void 0, since the aliasing killed the previous key.\n keys.length = lastIndex;\n // If we crash here, keys will be one shorter than values.\n values.length = lastIndex;\n return true;\n }\n }\n\n return Object.create(OurWeakMap.prototype, {\n get___: { value: constFunc(get___) },\n has___: { value: constFunc(has___) },\n set___: { value: constFunc(set___) },\n delete___: { value: constFunc(delete___) }\n });\n };\n\n OurWeakMap.prototype = Object.create(Object.prototype, {\n get: {\n /**\n * Return the value most recently associated with key, or\n * opt_default if none.\n */\n value: function get(key, opt_default) {\n return this.get___(key, opt_default);\n },\n writable: true,\n configurable: true\n },\n\n has: {\n /**\n * Is there a value associated with key in this WeakMap?\n */\n value: function has(key) {\n return this.has___(key);\n },\n writable: true,\n configurable: true\n },\n\n set: {\n /**\n * Associate value with key in this WeakMap, overwriting any\n * previous association if present.\n */\n value: function set(key, value) {\n return this.set___(key, value);\n },\n writable: true,\n configurable: true\n },\n\n 'delete': {\n /**\n * Remove any association for key in this WeakMap, returning\n * whether there was one.\n *\n *
Note that the boolean return here does not work like the\n * {@code delete} operator. The {@code delete} operator returns\n * whether the deletion succeeds at bringing about a state in\n * which the deleted property is absent. The {@code delete}\n * operator therefore returns true if the property was already\n * absent, whereas this {@code delete} method returns false if\n * the association was already absent.\n */\n value: function remove(key) {\n return this.delete___(key);\n },\n writable: true,\n configurable: true\n }\n });\n\n if (typeof HostWeakMap === 'function') {\n (function() {\n // If we got here, then the platform has a WeakMap but we are concerned\n // that it may refuse to store some key types. Therefore, make a map\n // implementation which makes use of both as possible.\n\n // In this mode we are always using double maps, so we are not proxy-safe.\n // This combination does not occur in any known browser, but we had best\n // be safe.\n if (doubleWeakMapCheckSilentFailure && typeof Proxy !== 'undefined') {\n Proxy = undefined;\n }\n\n function DoubleWeakMap() {\n if (!(this instanceof OurWeakMap)) { // approximate test for new ...()\n calledAsFunctionWarning();\n }\n\n // Preferable, truly weak map.\n var hmap = new HostWeakMap();\n\n // Our hidden-property-based pseudo-weak-map. Lazily initialized in the\n // 'set' implementation; thus we can avoid performing extra lookups if\n // we know all entries actually stored are entered in 'hmap'.\n var omap = undefined;\n\n // Hidden-property maps are not compatible with proxies because proxies\n // can observe the hidden name and either accidentally expose it or fail\n // to allow the hidden property to be set. Therefore, we do not allow\n // arbitrary WeakMaps to switch to using hidden properties, but only\n // those which need the ability, and unprivileged code is not allowed\n // to set the flag.\n //\n // (Except in doubleWeakMapCheckSilentFailure mode in which case we\n // disable proxies.)\n var enableSwitching = false;\n\n function dget(key, opt_default) {\n if (omap) {\n return hmap.has(key) ? hmap.get(key)\n : omap.get___(key, opt_default);\n } else {\n return hmap.get(key, opt_default);\n }\n }\n\n function dhas(key) {\n return hmap.has(key) || (omap ? omap.has___(key) : false);\n }\n\n var dset;\n if (doubleWeakMapCheckSilentFailure) {\n dset = function(key, value) {\n hmap.set(key, value);\n if (!hmap.has(key)) {\n if (!omap) { omap = new OurWeakMap(); }\n omap.set(key, value);\n }\n return this;\n };\n } else {\n dset = function(key, value) {\n if (enableSwitching) {\n try {\n hmap.set(key, value);\n } catch (e) {\n if (!omap) { omap = new OurWeakMap(); }\n omap.set___(key, value);\n }\n } else {\n hmap.set(key, value);\n }\n return this;\n };\n }\n\n function ddelete(key) {\n var result = !!hmap['delete'](key);\n if (omap) { return omap.delete___(key) || result; }\n return result;\n }\n\n return Object.create(OurWeakMap.prototype, {\n get___: { value: constFunc(dget) },\n has___: { value: constFunc(dhas) },\n set___: { value: constFunc(dset) },\n delete___: { value: constFunc(ddelete) },\n permitHostObjects___: { value: constFunc(function(token) {\n if (token === weakMapPermitHostObjects) {\n enableSwitching = true;\n } else {\n throw new Error('bogus call to permitHostObjects___');\n }\n })}\n });\n }\n DoubleWeakMap.prototype = OurWeakMap.prototype;\n module.exports = DoubleWeakMap;\n\n // define .constructor to hide OurWeakMap ctor\n Object.defineProperty(WeakMap.prototype, 'constructor', {\n value: WeakMap,\n enumerable: false, // as default .constructor is\n configurable: true,\n writable: true\n });\n })();\n } else {\n // There is no host WeakMap, so we must use the emulation.\n\n // Emulated WeakMaps are incompatible with native proxies (because proxies\n // can observe the hidden name), so we must disable Proxy usage (in\n // ArrayLike and Domado, currently).\n if (typeof Proxy !== 'undefined') {\n Proxy = undefined;\n }\n\n module.exports = OurWeakMap;\n }\n})();\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things. But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals. It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n throw new Error('clearTimeout has not been defined');\n}\n(function () {\n try {\n if (typeof setTimeout === 'function') {\n cachedSetTimeout = setTimeout;\n } else {\n cachedSetTimeout = defaultSetTimout;\n }\n } catch (e) {\n cachedSetTimeout = defaultSetTimout;\n }\n try {\n if (typeof clearTimeout === 'function') {\n cachedClearTimeout = clearTimeout;\n } else {\n cachedClearTimeout = defaultClearTimeout;\n }\n } catch (e) {\n cachedClearTimeout = defaultClearTimeout;\n }\n} ())\nfunction runTimeout(fun) {\n if (cachedSetTimeout === setTimeout) {\n //normal enviroments in sane situations\n return setTimeout(fun, 0);\n }\n // if setTimeout wasn't available but was latter defined\n if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n cachedSetTimeout = setTimeout;\n return setTimeout(fun, 0);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedSetTimeout(fun, 0);\n } catch(e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedSetTimeout.call(null, fun, 0);\n } catch(e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n return cachedSetTimeout.call(this, fun, 0);\n }\n }\n\n\n}\nfunction runClearTimeout(marker) {\n if (cachedClearTimeout === clearTimeout) {\n //normal enviroments in sane situations\n return clearTimeout(marker);\n }\n // if clearTimeout wasn't available but was latter defined\n if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n cachedClearTimeout = clearTimeout;\n return clearTimeout(marker);\n }\n try {\n // when when somebody has screwed with setTimeout but no I.E. maddness\n return cachedClearTimeout(marker);\n } catch (e){\n try {\n // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n return cachedClearTimeout.call(null, marker);\n } catch (e){\n // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n return cachedClearTimeout.call(this, marker);\n }\n }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n if (!draining || !currentQueue) {\n return;\n }\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = runTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n runTimeout(drainQueue);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/* vim:ts=4:sts=4:sw=4: */\n/*!\n *\n * Copyright 2009-2013 Kris Kowal under the terms of the MIT\n * license found at http://github.com/kriskowal/q/raw/master/LICENSE\n *\n * With parts by Tyler Close\n * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found\n * at http://www.opensource.org/licenses/mit-license.html\n * Forked at ref_send.js version: 2009-05-11\n *\n * With parts by Mark Miller\n * Copyright (C) 2011 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n/*global -WeakMap */\n\"use strict\";\n\nvar hasStacks = false;\ntry {\n throw new Error();\n} catch (e) {\n hasStacks = !!e.stack;\n}\n\n// All code after this point will be filtered from stack traces reported\n// by Q.\nvar qStartingLine = captureLine();\nvar qFileName;\n\nvar WeakMap = require(\"weak-map\");\nvar iterate = require(\"pop-iterate\");\nvar asap = require(\"asap\");\n\nfunction isObject(value) {\n return value === Object(value);\n}\n\n// long stack traces\n\nvar STACK_JUMP_SEPARATOR = \"From previous event:\";\n\nfunction makeStackTraceLong(error, promise) {\n // If possible, transform the error stack trace by removing Node and Q\n // cruft, then concatenating with the stack trace of `promise`. See #57.\n if (hasStacks &&\n promise.stack &&\n typeof error === \"object\" &&\n error !== null &&\n error.stack &&\n error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1\n ) {\n var stacks = [];\n for (var p = promise; !!p && handlers.get(p); p = handlers.get(p).became) {\n if (p.stack) {\n stacks.unshift(p.stack);\n }\n }\n stacks.unshift(error.stack);\n\n var concatedStacks = stacks.join(\"\\n\" + STACK_JUMP_SEPARATOR + \"\\n\");\n error.stack = filterStackString(concatedStacks);\n }\n}\n\nfunction filterStackString(stackString) {\n if (Q.isIntrospective) {\n return stackString;\n }\n var lines = stackString.split(\"\\n\");\n var desiredLines = [];\n for (var i = 0; i < lines.length; ++i) {\n var line = lines[i];\n\n if (!isInternalFrame(line) && !isNodeFrame(line) && line) {\n desiredLines.push(line);\n }\n }\n return desiredLines.join(\"\\n\");\n}\n\nfunction isNodeFrame(stackLine) {\n return stackLine.indexOf(\"(module.js:\") !== -1 ||\n stackLine.indexOf(\"(node.js:\") !== -1;\n}\n\nfunction getFileNameAndLineNumber(stackLine) {\n // Named functions: \"at functionName (filename:lineNumber:columnNumber)\"\n // In IE10 function name can have spaces (\"Anonymous function\") O_o\n var attempt1 = /at .+ \\((.+):(\\d+):(?:\\d+)\\)$/.exec(stackLine);\n if (attempt1) {\n return [attempt1[1], Number(attempt1[2])];\n }\n\n // Anonymous functions: \"at filename:lineNumber:columnNumber\"\n var attempt2 = /at ([^ ]+):(\\d+):(?:\\d+)$/.exec(stackLine);\n if (attempt2) {\n return [attempt2[1], Number(attempt2[2])];\n }\n\n // Firefox style: \"function@filename:lineNumber or @filename:lineNumber\"\n var attempt3 = /.*@(.+):(\\d+)$/.exec(stackLine);\n if (attempt3) {\n return [attempt3[1], Number(attempt3[2])];\n }\n}\n\nfunction isInternalFrame(stackLine) {\n var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);\n\n if (!fileNameAndLineNumber) {\n return false;\n }\n\n var fileName = fileNameAndLineNumber[0];\n var lineNumber = fileNameAndLineNumber[1];\n\n return fileName === qFileName &&\n lineNumber >= qStartingLine &&\n lineNumber <= qEndingLine;\n}\n\n// discover own file name and line number range for filtering stack\n// traces\nfunction captureLine() {\n if (!hasStacks) {\n return;\n }\n\n try {\n throw new Error();\n } catch (e) {\n var lines = e.stack.split(\"\\n\");\n var firstLine = lines[0].indexOf(\"@\") > 0 ? lines[1] : lines[2];\n var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);\n if (!fileNameAndLineNumber) {\n return;\n }\n\n qFileName = fileNameAndLineNumber[0];\n return fileNameAndLineNumber[1];\n }\n}\n\nfunction deprecate(callback, name, alternative) {\n return function Q_deprecate() {\n if (\n typeof console !== \"undefined\" &&\n typeof console.warn === \"function\"\n ) {\n if (alternative) {\n console.warn(\n name + \" is deprecated, use \" + alternative + \" instead.\",\n new Error(\"\").stack\n );\n } else {\n console.warn(\n name + \" is deprecated.\",\n new Error(\"\").stack\n );\n }\n }\n return callback.apply(this, arguments);\n };\n}\n\n// end of long stack traces\n\nvar handlers = new WeakMap();\n\nfunction Q_getHandler(promise) {\n var handler = handlers.get(promise);\n if (!handler || !handler.became) {\n return handler;\n }\n handler = follow(handler);\n handlers.set(promise, handler);\n return handler;\n}\n\nfunction follow(handler) {\n if (!handler.became) {\n return handler;\n } else {\n handler.became = follow(handler.became);\n return handler.became;\n }\n}\n\nvar theViciousCycleError = new Error(\"Can't resolve a promise with itself\");\nvar theViciousCycleRejection = Q_reject(theViciousCycleError);\nvar theViciousCycle = Q_getHandler(theViciousCycleRejection);\n\nvar thenables = new WeakMap();\n\n/**\n * Coerces a value to a promise. If the value is a promise, pass it through\n * unaltered. If the value has a `then` method, it is presumed to be a promise\n * but not one of our own, so it is treated as a “thenable” promise and this\n * returns a promise that stands for it. Otherwise, this returns a promise that\n * has already been fulfilled with the value.\n * @param value promise, object with a then method, or a fulfillment value\n * @returns {Promise} the same promise as given, or a promise for the given\n * value\n */\nmodule.exports = Q;\nfunction Q(value) {\n // If the object is already a Promise, return it directly. This enables\n // the resolve function to both be used to created references from objects,\n // but to tolerably coerce non-promises to promises.\n if (Q_isPromise(value)) {\n return value;\n } else if (isThenable(value)) {\n if (!thenables.has(value)) {\n thenables.set(value, new Promise(new Thenable(value)));\n }\n return thenables.get(value);\n } else {\n return new Promise(new Fulfilled(value));\n }\n}\n\n/**\n * Controls whether or not long stack traces will be on\n * @type {boolean}\n */\nQ.longStackSupport = false;\n\n/**\n * Returns a promise that has been rejected with a reason, which should be an\n * instance of `Error`.\n * @param {Error} error reason for the failure.\n * @returns {Promise} rejection\n */\nQ.reject = Q_reject;\nfunction Q_reject(error) {\n return new Promise(new Rejected(error));\n}\n\n/**\n * Constructs a {promise, resolve, reject} object.\n *\n * `resolve` is a callback to invoke with a more resolved value for the\n * promise. To fulfill the promise, invoke `resolve` with any value that is\n * not a thenable. To reject the promise, invoke `resolve` with a rejected\n * thenable, or invoke `reject` with the reason directly. To resolve the\n * promise to another thenable, thus putting it in the same state, invoke\n * `resolve` with that other thenable.\n *\n * @returns {{promise, resolve, reject}} a deferred\n */\nQ.defer = defer;\nfunction defer() {\n\n var handler = new Pending();\n var promise = new Promise(handler);\n var deferred = new Deferred(promise);\n\n if (Q.longStackSupport && hasStacks) {\n try {\n throw new Error();\n } catch (e) {\n // NOTE: don't try to use `Error.captureStackTrace` or transfer the\n // accessor around; that causes memory leaks as per GH-111. Just\n // reify the stack trace as a string ASAP.\n //\n // At the same time, cut off the first line; it's always just\n // \"[object Promise]\\n\", as per the `toString`.\n promise.stack = e.stack.substring(e.stack.indexOf(\"\\n\") + 1);\n }\n }\n\n return deferred;\n}\n\n// TODO\n/**\n */\nQ.when = function Q_when(value, fulfilled, rejected, ms) {\n return Q(value).then(fulfilled, rejected, ms);\n};\n\n/**\n * Turns an array of promises into a promise for an array. If any of the\n * promises gets rejected, the whole array is rejected immediately.\n * @param {Array.