cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From za...@apache.org
Subject [24/52] [abbrv] [partial] cordova-firefoxos git commit: CB-4548 Install new node-firefox-* dependencies in node_modules
Date Wed, 01 Apr 2015 14:22:51 GMT
http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/Gruntfile.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/Gruntfile.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/Gruntfile.js
new file mode 100644
index 0000000..77fc162
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/Gruntfile.js
@@ -0,0 +1,725 @@
+"use strict";
+Error.stackTraceLimit = 100;
+var astPasses = require("./ast_passes.js");
+var node11 = parseInt(process.versions.node.split(".")[1], 10) >= 11;
+var Q = require("q");
+Q.longStackSupport = true;
+
+module.exports = function( grunt ) {
+    var isCI = !!grunt.option("ci");
+
+
+    function getBrowsers() {
+        //Terse format to generate the verbose format required by sauce
+        var browsers = {
+            "internet explorer|WIN8": ["10"],
+            "internet explorer|WIN8.1": ["11"],
+            "firefox|Windows 7": ["3.5", "3.6", "4", "25"],
+            "firefox|WIN8.1": null,
+            "chrome|Windows 7": null,
+            "safari|Windows 7": ["5"],
+            "iphone|OS X 10.8": ["6.0"]
+        };
+
+        var ret = [];
+        for( var browserAndPlatform in browsers) {
+            var split = browserAndPlatform.split("|");
+            var browser = split[0];
+            var platform = split[1];
+            var versions = browsers[browserAndPlatform];
+            if( versions != null ) {
+                for( var i = 0, len = versions.length; i < len; ++i ) {
+                    ret.push({
+                        browserName: browser,
+                        platform: platform,
+                        version: versions[i]
+                    });
+                }
+            }
+            else {
+                ret.push({
+                    browserName: browser,
+                    platform: platform
+                });
+            }
+        }
+        return ret;
+    }
+
+
+    var optionalModuleDependencyMap = {
+        "timers.js": ['Promise', 'INTERNAL'],
+        "any.js": ['Promise', 'Promise$_CreatePromiseArray', 'PromiseArray'],
+        "race.js": ['Promise', 'INTERNAL'],
+        "call_get.js": ['Promise'],
+        "filter.js": ['Promise', 'Promise$_CreatePromiseArray', 'PromiseArray', 'apiRejection'],
+        "generators.js": ['Promise', 'apiRejection', 'INTERNAL'],
+        "map.js": ['Promise', 'Promise$_CreatePromiseArray', 'PromiseArray', 'apiRejection'],
+        "nodeify.js": ['Promise'],
+        "promisify.js": ['Promise', 'INTERNAL'],
+        "props.js": ['Promise', 'PromiseArray'],
+        "reduce.js": ['Promise', 'Promise$_CreatePromiseArray', 'PromiseArray', 'apiRejection', 'INTERNAL'],
+        "settle.js": ['Promise', 'Promise$_CreatePromiseArray', 'PromiseArray'],
+        "some.js": ['Promise', 'Promise$_CreatePromiseArray', 'PromiseArray', 'apiRejection'],
+        "progress.js": ['Promise', 'isPromiseArrayProxy'],
+        "cancel.js": ['Promise', 'INTERNAL'],
+        "synchronous_inspection.js": ['Promise']
+
+    };
+
+    var optionalModuleRequireMap = {
+        "timers.js": true,
+        "race.js": true,
+        "any.js": true,
+        "call_get.js": true,
+        "filter.js": true,
+        "generators.js": true,
+        "map.js": true,
+        "nodeify.js": true,
+        "promisify.js": true,
+        "props.js": true,
+        "reduce.js": true,
+        "settle.js": true,
+        "some.js": true,
+        "progress.js": true,
+        "cancel.js": true,
+        "synchronous_inspection.js": true
+
+    };
+
+    function getOptionalRequireCode( srcs ) {
+        return srcs.reduce(function(ret, cur, i){
+            if( optionalModuleRequireMap[cur] ) {
+                ret += "require('./"+cur+"')("+ optionalModuleDependencyMap[cur] +");\n";
+            }
+            return ret;
+        }, "") + "\nPromise.prototype = Promise.prototype;\nreturn Promise;\n";
+    }
+
+    function getBrowserBuildHeader( sources ) {
+        var header = "/**\n * bluebird build version " + gruntConfig.pkg.version + "\n";
+        var enabledFeatures = ["core"];
+        var disabledFeatures = [];
+        featureLoop: for( var key in optionalModuleRequireMap ) {
+            for( var i = 0, len = sources.length; i < len; ++i ) {
+                var source = sources[i];
+                if( source.fileName === key ) {
+                    enabledFeatures.push( key.replace( ".js", "") );
+                    continue featureLoop;
+                }
+            }
+            disabledFeatures.push( key.replace( ".js", "") );
+        }
+
+        header += ( " * Features enabled: " + enabledFeatures.join(", ") + "\n" );
+
+        if( disabledFeatures.length ) {
+            header += " * Features disabled: " + disabledFeatures.join(", ") + "\n";
+        }
+        header += "*/\n";
+        return header;
+    }
+
+    function applyOptionalRequires( src, optionalRequireCode ) {
+        return src.replace( /};([^}]*)$/, optionalRequireCode + "\n};$1");
+    }
+
+    var CONSTANTS_FILE = './src/constants.js';
+    var BUILD_DEBUG_DEST = "./js/debug/bluebird.js";
+
+    var license;
+    function getLicense() {
+        if( !license ) {
+            var fs = require("fs");
+            var text = fs.readFileSync("LICENSE", "utf8");
+            text = text.split("\n").map(function(line, index){
+                return " * " + line;
+            }).join("\n")
+            license = "/**\n" + text + "\n */\n";
+        }
+        return license
+    }
+
+    var preserved;
+    function getLicensePreserve() {
+        if( !preserved ) {
+            var fs = require("fs");
+            var text = fs.readFileSync("LICENSE", "utf8");
+            text = text.split("\n").map(function(line, index){
+                if( index === 0 ) {
+                    return " * @preserve " + line;
+                }
+                return " * " + line;
+            }).join("\n")
+            preserved = "/**\n" + text + "\n */\n";
+        }
+        return preserved;
+    }
+
+    function writeFile( dest, content ) {
+        grunt.file.write( dest, content );
+        grunt.log.writeln('File "' + dest + '" created.');
+    }
+
+    function writeFileAsync( dest, content ) {
+        var fs = require("fs");
+        return Q.nfcall(fs.writeFile, dest, content).then(function(){
+            grunt.log.writeln('File "' + dest + '" created.');
+        });
+    }
+
+    var gruntConfig = {};
+
+    var getGlobals = function() {
+        var fs = require("fs");
+        var file = "./src/constants.js";
+        var contents = fs.readFileSync(file, "utf8");
+        var rconstantname = /CONSTANT\(\s*([^,]+)/g;
+        var m;
+        var globals = {
+            Error: true,
+            args: true,
+            INLINE_SLICE: false,
+            TypeError: true,
+            RangeError: true,
+            __DEBUG__: false,
+            __BROWSER__: false,
+            process: true,
+            "console": false,
+            "require": false,
+            "module": false,
+            "define": false
+        };
+        while( ( m = rconstantname.exec( contents ) ) ) {
+            globals[m[1]] = false;
+        }
+        return globals;
+    }
+
+    gruntConfig.pkg = grunt.file.readJSON("package.json");
+
+    gruntConfig.jshint = {
+        all: {
+            options: {
+                globals: getGlobals(),
+
+                "bitwise": false,
+                "camelcase": true,
+                "curly": true,
+                "eqeqeq": true,
+                "es3": true,
+                "forin": true,
+                "immed": true,
+                "latedef": false,
+                "newcap": true,
+                "noarg": true,
+                "noempty": true,
+                "nonew": true,
+                "plusplus": false,
+                "quotmark": "double",
+                "undef": true,
+                "unused": true,
+                "strict": false,
+                "trailing": true,
+                "maxparams": 6,
+                "maxlen": 80,
+
+                "asi": false,
+                "boss": true,
+                "eqnull": true,
+                "evil": true,
+                "expr": false,
+                "funcscope": false,
+                "globalstrict": false,
+                "lastsemic": false,
+                "laxcomma": false,
+                "laxbreak": false,
+                "loopfunc": true,
+                "multistr": true,
+                "proto": false,
+                "scripturl": true,
+                "smarttabs": false,
+                "shadow": true,
+                "sub": true,
+                "supernew": false,
+                "validthis": true,
+
+                "browser": true,
+                "jquery": true,
+                "devel": true,
+
+
+                '-W014': true,
+                '-W116': true,
+                '-W106': true,
+                '-W064': true,
+                '-W097': true
+            },
+
+            files: {
+                src: [
+                    "./src/finally.js",
+                    "./src/direct_resolve.js",
+                    "./src/synchronous_inspection.js",
+                    "./src/thenables.js",
+                    "./src/progress.js",
+                    "./src/cancel.js",
+                    "./src/any.js",
+                    "./src/race.js",
+                    "./src/call_get.js",
+                    "./src/filter.js",
+                    "./src/generators.js",
+                    "./src/map.js",
+                    "./src/nodeify.js",
+                    "./src/promisify.js",
+                    "./src/props.js",
+                    "./src/reduce.js",
+                    "./src/settle.js",
+                    "./src/some.js",
+                    "./src/util.js",
+                    "./src/schedule.js",
+                    "./src/queue.js",
+                    "./src/errors.js",
+                    "./src/captured_trace.js",
+                    "./src/async.js",
+                    "./src/catch_filter.js",
+                    "./src/promise.js",
+                    "./src/promise_array.js",
+                    "./src/settled_promise_array.js",
+                    "./src/some_promise_array.js",
+                    "./src/properties_promise_array.js",
+                    "./src/promise_inspection.js",
+                    "./src/promise_resolver.js",
+                    "./src/promise_spawn.js"
+                ]
+            }
+        }
+    };
+
+    if( !isCI ) {
+        gruntConfig.jshint.all.options.reporter = require("jshint-stylish");
+    }
+
+    gruntConfig.connect = {
+        server: {
+            options: {
+                base: "./browser",
+                port: 9999
+            }
+        }
+    };
+
+    gruntConfig.watch = {};
+
+    gruntConfig["saucelabs-mocha"] = {
+        all: {
+            options: {
+                urls: ["http://127.0.0.1:9999/index.html"],
+                tunnelTimeout: 5,
+                build: process.env.TRAVIS_JOB_ID,
+                concurrency: 3,
+                browsers: getBrowsers(),
+                testname: "mocha tests",
+                tags: ["master"]
+            }
+        }
+    };
+
+    gruntConfig.bump = {
+      options: {
+        files: ['package.json'],
+        updateConfigs: [],
+        commit: true,
+        commitMessage: 'Release v%VERSION%',
+        commitFiles: ['-a'],
+        createTag: true,
+        tagName: 'v%VERSION%',
+        tagMessage: 'Version %VERSION%',
+        false: true,
+        pushTo: 'master',
+        gitDescribeOptions: '--tags --always --abbrev=1 --dirty=-d' // options to use with '$ git describe'
+      }
+    };
+
+    grunt.initConfig(gruntConfig);
+    grunt.loadNpmTasks("grunt-contrib-connect");
+    grunt.loadNpmTasks("grunt-saucelabs");
+    grunt.loadNpmTasks('grunt-contrib-jshint');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+    grunt.loadNpmTasks('grunt-contrib-concat');
+
+    function runIndependentTest( file, cb , env) {
+        var fs = require("fs");
+        var path = require("path");
+        var sys = require('sys');
+        var spawn = require('child_process').spawn;
+        var p = path.join(process.cwd(), "test");
+
+        var stdio = [
+            'ignore',
+            grunt.option("verbose")
+                ? process.stdout
+                : 'ignore',
+            process.stderr
+        ];
+        var flags = node11 ? ["--harmony-generators"] : [];
+        flags.push("--allow-natives-syntax");
+        if( file.indexOf( "mocha/") > -1 || file === "aplus.js" ) {
+            var node = spawn(typeof node11 === "string" ? node11 : 'node',
+                flags.concat(["../mocharun.js", file]),
+                {cwd: p, stdio: stdio, env: env});
+        }
+        else {
+            var node = spawn('node', flags.concat(["./"+file]),
+                             {cwd: p, stdio: stdio, env:env});
+        }
+        node.on('exit', exit );
+
+        function exit( code ) {
+            if( code !== 0 ) {
+                cb(new Error("process didn't exit normally. Code: " + code));
+            }
+            else {
+                cb(null);
+            }
+        }
+
+
+    }
+
+    function buildMain( sources, optionalRequireCode ) {
+        var fs = require("fs");
+        var Q = require("q");
+        var root = cleanDirectory("./js/main/");
+
+        return Q.all(sources.map(function( source ) {
+            var src = astPasses.removeAsserts( source.sourceCode, source.fileName );
+            src = astPasses.inlineExpansion( src, source.fileName );
+            src = astPasses.expandConstants( src, source.fileName );
+            src = src.replace( /__DEBUG__/g, "false" );
+            src = src.replace( /__BROWSER__/g, "false" );
+            if( source.fileName === "promise.js" ) {
+                src = applyOptionalRequires( src, optionalRequireCode );
+            }
+            var path = root + source.fileName;
+            return writeFileAsync(path, src);
+        }));
+    }
+
+    function buildDebug( sources, optionalRequireCode ) {
+        var fs = require("fs");
+        var Q = require("q");
+        var root = cleanDirectory("./js/debug/");
+
+        return Q.nfcall(require('mkdirp'), root).then(function(){
+            return Q.all(sources.map(function( source ) {
+                var src = astPasses.expandAsserts( source.sourceCode, source.fileName );
+                src = astPasses.inlineExpansion( src, source.fileName );
+                src = astPasses.expandConstants( src, source.fileName );
+                src = src.replace( /__DEBUG__/g, "true" );
+                src = src.replace( /__BROWSER__/g, "false" );
+                if( source.fileName === "promise.js" ) {
+                    src = applyOptionalRequires( src, optionalRequireCode );
+                }
+                var path = root + source.fileName;
+                return writeFileAsync(path, src);
+            }));
+        });
+    }
+
+    function buildZalgo( sources, optionalRequireCode ) {
+        var fs = require("fs");
+        var Q = require("q");
+        var root = cleanDirectory("./js/zalgo/");
+
+        return Q.all(sources.map(function( source ) {
+            var src = astPasses.removeAsserts( source.sourceCode, source.fileName );
+            src = astPasses.inlineExpansion( src, source.fileName );
+            src = astPasses.expandConstants( src, source.fileName );
+            src = astPasses.asyncConvert( src, "async", "invoke", source.fileName);
+            src = src.replace( /__DEBUG__/g, "false" );
+            src = src.replace( /__BROWSER__/g, "false" );
+            if( source.fileName === "promise.js" ) {
+                src = applyOptionalRequires( src, optionalRequireCode );
+            }
+            var path = root + source.fileName;
+            return writeFileAsync(path, src);
+        }));
+    }
+
+    function buildBrowser( sources ) {
+        var fs = require("fs");
+        var browserify = require("browserify");
+        var b = browserify("./js/main/bluebird.js");
+        var dest = "./js/browser/bluebird.js";
+
+        var header = getBrowserBuildHeader( sources );
+
+        return Q.nbind(b.bundle, b)({
+                detectGlobals: false,
+                standalone: "Promise"
+        }).then(function(src) {
+            return writeFileAsync( dest,
+                getLicensePreserve() + src )
+        }).then(function() {
+            return Q.nfcall(fs.readFile, dest, "utf8" );
+        }).then(function( src ) {
+            src = header + src;
+            return Q.nfcall(fs.writeFile, dest, src );
+        });
+    }
+
+    function cleanDirectory(dir) {
+        if (isCI) return dir;
+        var fs = require("fs");
+        require("rimraf").sync(dir);
+        fs.mkdirSync(dir);
+        return dir;
+    }
+
+    function getOptionalPathsFromOption( opt ) {
+        opt = (opt + "").toLowerCase().split(/\s+/g);
+        return optionalPaths.filter(function(v){
+            v = v.replace("./src/", "").replace( ".js", "" ).toLowerCase();
+            return opt.indexOf(v) > -1;
+        });
+    }
+
+    var optionalPaths = [
+        "./src/timers.js",
+        "./src/synchronous_inspection.js",
+        "./src/any.js",
+        "./src/race.js",
+        "./src/call_get.js",
+        "./src/filter.js",
+        "./src/generators.js",
+        "./src/map.js",
+        "./src/nodeify.js",
+        "./src/promisify.js",
+        "./src/props.js",
+        "./src/reduce.js",
+        "./src/settle.js",
+        "./src/some.js",
+        "./src/progress.js",
+        "./src/cancel.js"
+    ];
+
+    var mandatoryPaths = [
+        "./src/finally.js",
+        "./src/es5.js",
+        "./src/bluebird.js",
+        "./src/thenables.js",
+        "./src/assert.js",
+        "./src/global.js",
+        "./src/util.js",
+        "./src/schedule.js",
+        "./src/queue.js",
+        "./src/errors.js",
+        "./src/errors_api_rejection.js",
+        "./src/captured_trace.js",
+        "./src/async.js",
+        "./src/catch_filter.js",
+        "./src/promise.js",
+        "./src/promise_array.js",
+        "./src/settled_promise_array.js",
+        "./src/some_promise_array.js",
+        "./src/properties_promise_array.js",
+        "./src/promise_inspection.js",
+        "./src/promise_resolver.js",
+        "./src/promise_spawn.js",
+        "./src/direct_resolve.js"
+    ];
+
+
+
+    function build( paths, isCI ) {
+        var fs = require("fs");
+        astPasses.readConstants(fs.readFileSync(CONSTANTS_FILE, "utf8"), CONSTANTS_FILE);
+        if( !paths ) {
+            paths = optionalPaths.concat(mandatoryPaths);
+        }
+        var optionalRequireCode = getOptionalRequireCode(paths.map(function(v) {
+            return v.replace("./src/", "");
+        }));
+
+        var Q = require("q");
+
+        var promises = [];
+        var sources = paths.map(function(v){
+            var promise = Q.nfcall(fs.readFile, v, "utf8");
+            promises.push(promise);
+            var ret = {};
+
+            ret.fileName = v.replace("./src/", "");
+            ret.sourceCode = promise.then(function(v){
+                ret.sourceCode = v;
+            });
+            return ret;
+        });
+
+        //Perform common AST passes on all builds
+        return Q.all(promises.slice()).then(function(){
+            sources.forEach( function( source ) {
+                var src = source.sourceCode
+                src = astPasses.removeComments(src, source.fileName);
+                src = getLicense() + src;
+                source.sourceCode = src;
+            });
+
+            if( isCI ) {
+                return buildDebug( sources, optionalRequireCode );
+            }
+            else {
+                return Q.all([
+                    buildMain( sources, optionalRequireCode ).then( function() {
+                        return buildBrowser( sources );
+                    }),
+                    buildDebug( sources, optionalRequireCode ),
+                    buildZalgo( sources, optionalRequireCode )
+                ]);
+            }
+        });
+    }
+
+    String.prototype.contains = function String$contains( str ) {
+        return this.indexOf( str ) >= 0;
+    };
+
+    function isSlowTest( file ) {
+        return file.contains("2.3.3") ||
+            file.contains("bind") ||
+            file.contains("unhandled_rejections");
+    }
+
+    function testRun( testOption ) {
+        var fs = require("fs");
+        var path = require("path");
+        var done = this.async();
+
+        var totalTests = 0;
+        var testsDone = 0;
+        function testDone() {
+            testsDone++;
+            if( testsDone >= totalTests ) {
+                done();
+            }
+        }
+        var files;
+        if( testOption === "aplus" ) {
+            files = fs.readdirSync("test/mocha").filter(function(f){
+                return /^\d+\.\d+\.\d+/.test(f);
+            }).map(function( f ){
+                return "mocha/" + f;
+            });
+        }
+        else {
+            files = testOption === "all"
+                ? fs.readdirSync('test')
+                    .concat(fs.readdirSync('test/mocha')
+                        .map(function(fileName){
+                            return "mocha/" + fileName
+                        })
+                    )
+                : [testOption + ".js" ];
+
+
+            if( testOption !== "all" &&
+                !fs.existsSync( "./test/" + files[0] ) ) {
+                files[0] = "mocha/" + files[0];
+            }
+        }
+        files = files.filter(function(fileName){
+            if( !node11 && fileName.indexOf("generator") > -1 ) {
+                return false;
+            }
+            return /\.js$/.test(fileName);
+        }).map(function(f){
+            return f.replace( /(\d)(\d)(\d)/, "$1.$2.$3" );
+        });
+
+
+        var slowTests = files.filter(isSlowTest);
+        files = files.filter(function(file){
+            return !isSlowTest(file);
+        });
+
+        function runFile(file) {
+            totalTests++;
+            grunt.log.writeln("Running test " + file );
+            var env = undefined;
+            if (file.indexOf("bluebird-debug-env-flag") >= 0) {
+                env = Object.create(process.env);
+                env["BLUEBIRD_DEBUG"] = true;
+            }
+            runIndependentTest(file, function(err) {
+                if( err ) throw new Error(err + " " + file + " failed");
+                grunt.log.writeln("Test " + file + " succeeded");
+                testDone();
+                if( files.length > 0 ) {
+                    runFile( files.shift() );
+                }
+            }, env);
+        }
+
+        slowTests.forEach(runFile);
+
+        var maxParallelProcesses = 10;
+        var len = Math.min( files.length, maxParallelProcesses );
+        for( var i = 0; i < len; ++i ) {
+            runFile( files.shift() );
+        }
+    }
+
+    grunt.registerTask( "build", function() {
+
+        var done = this.async();
+        var features = grunt.option("features");
+        var paths = null;
+        if( features ) {
+            paths = getOptionalPathsFromOption( features ).concat( mandatoryPaths );
+        }
+
+        build( paths, isCI ).then(function() {
+            done();
+        }).catch(function(e) {
+            if( e.fileName && e.stack ) {
+                console.log(e.scriptSrc);
+                var stack = e.stack.split("\n");
+                stack[0] = stack[0] + " " + e.fileName;
+                console.error(stack.join("\n"));
+                if (!grunt.option("verbose")) {
+                    console.error("use --verbose to see the source code");
+                }
+
+            }
+            else {
+                console.error(e.stack);
+            }
+            done(false);
+        });
+    });
+
+    grunt.registerTask( "testrun", function(){
+        var testOption = grunt.option("run");
+        var node11path = grunt.option("node11");
+
+        if (typeof node11path === "string" && node11path) {
+            node11 = node11path;
+        }
+
+        if( !testOption ) testOption = "all";
+        else {
+            testOption = ("" + testOption);
+            testOption = testOption
+                .replace( /\.js$/, "" )
+                .replace( /[^a-zA-Z0-9_-]/g, "" );
+        }
+        testRun.call( this, testOption );
+    });
+
+    grunt.registerTask( "test", ["jshint", "build", "testrun"] );
+    grunt.registerTask( "test-browser", ["connect", "saucelabs-mocha"]);
+    grunt.registerTask( "default", ["jshint", "build"] );
+    grunt.registerTask( "dev", ["connect", "watch"] );
+
+};

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/LICENSE
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/LICENSE b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/LICENSE
new file mode 100644
index 0000000..9ed7b98
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 Petka Antonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:</p>
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/README.md
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/README.md b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/README.md
new file mode 100644
index 0000000..7d4d1ae
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/README.md
@@ -0,0 +1,696 @@
+[![Build Status](https://travis-ci.org/petkaantonov/bluebird.png?branch=master)](https://travis-ci.org/petkaantonov/bluebird)
+
+<a href="http://promisesaplus.com/">
+    <img src="http://promisesaplus.com/assets/logo-small.png" alt="Promises/A+ logo"
+         title="Promises/A+ 1.0 compliant" align="right" />
+</a>
+
+#Introduction
+
+Bluebird is a fully featured [promise](#what-are-promises-and-why-should-i-use-them) library with focus on innovative features and performance
+
+#Topics
+
+- [Features](#features)
+- [Quick start](#quick-start)
+- [API Reference and examples](https://github.com/petkaantonov/bluebird/blob/master/API.md)
+- [What are promises and why should I use them?](#what-are-promises-and-why-should-i-use-them)
+- [Questions and issues](#questions-and-issues)
+- [Error handling](#error-handling)
+- [Development](#development)
+    - [Testing](#testing)
+    - [Benchmarking](#benchmarks)
+    - [Custom builds](#custom-builds)
+    - [For library authors](#for-library-authors)
+- [What is the sync build?](#what-is-the-sync-build)
+- [License](#license)
+- [Snippets for common problems](https://github.com/petkaantonov/bluebird/wiki/Snippets)
+- [Promise anti-patterns](https://github.com/petkaantonov/bluebird/wiki/Promise-anti-patterns)
+- [Changelog](https://github.com/petkaantonov/bluebird/blob/master/changelog.md)
+- [Optimization guide](#optimization-guide)
+
+#Features:
+
+- [Promises A+ 2.0.2](http://promisesaplus.com)
+- [Cancellation](https://github.com/promises-aplus)
+- [Progression](https://github.com/promises-aplus/progress-spec)
+- [Synchronous inspection](https://github.com/promises-aplus/synchronous-inspection-spec)
+- [`.bind`](https://github.com/petkaantonov/bluebird/blob/master/API.md#binddynamic-thisarg---promise)
+- [Complete parallel for C# 5.0 async and await](https://github.com/petkaantonov/bluebird/blob/master/API.md#promisecoroutinegeneratorfunction-generatorfunction---function)
+- [Collection methods](https://github.com/petkaantonov/bluebird/blob/master/API.md#collections) such as All, any, some, settle, map, filter, reduce, spread, join, race...
+- [Practical debugging solutions](#error-handling) such as unhandled rejection reporting, typed catches, catching only what you expect and very long, relevant stack traces without losing perf
+- [Sick performance](https://github.com/petkaantonov/bluebird/tree/master/benchmark/stats)
+
+Passes [AP2](https://github.com/petkaantonov/bluebird/tree/master/test/mocha), [AP3](https://github.com/petkaantonov/bluebird/tree/master/test/mocha), [Cancellation](https://github.com/petkaantonov/bluebird/blob/master/test/mocha/cancel.js), [Progress](https://github.com/petkaantonov/bluebird/blob/master/test/mocha/q_progress.js) tests and more. See [testing](#testing).
+
+<hr>
+
+#Quick start
+
+##Node.js
+
+    npm install bluebird
+
+Then:
+
+```js
+var Promise = require("bluebird");
+```
+
+##Browsers
+
+Download the [bluebird.js](https://github.com/petkaantonov/bluebird/tree/master/js/browser) file. And then use a script tag:
+
+```html
+<script type="text/javascript" src="/scripts/bluebird.js"></script>
+```
+
+The global variable `Promise` becomes available after the above script tag.
+
+####Browser support
+
+Browsers that [implement ECMA-262, edition 3](http://en.wikipedia.org/wiki/Ecmascript#Implementations) and later are supported.
+
+[![Selenium Test Status](https://saucelabs.com/browser-matrix/petka_antonov.svg)](https://saucelabs.com/u/petka_antonov)
+
+*IE7 and IE8 had to be removed from tests due to SauceLabs bug but are supported and pass all tests*
+
+**Note** that in ECMA-262, edition 3 (IE7, IE8 etc) it is not possible to use methods that have keyword names like `.catch` and `.finally`. The [API documentation](https://github.com/petkaantonov/bluebird/blob/master/API.md) always lists a compatible alternative name that you can use if you need to support these browsers. For example `.catch` is replaced with `.caught` and `.finally` with `.lastly`.
+
+Also, [long stack trace](https://github.com/petkaantonov/bluebird/blob/master/API.md#promiselongstacktraces---void) support is only available in Chrome and Firefox.
+
+<sub>Previously bluebird required es5-shim.js and es5-sham.js to support Edition 3 - these are **no longer required** as of **0.10.4**.</sub>
+
+After quick start, see [API Reference and examples](https://github.com/petkaantonov/bluebird/blob/master/API.md)
+
+<hr>
+
+#What are promises and why should I use them?
+
+You should use promises to turn this:
+
+```js
+readFile("file.json", function(err, val) {
+    if( err ) {
+        console.error("unable to read file");
+    }
+    else {
+        try {
+            val = JSON.parse(val);
+            console.log(val.success);
+        }
+        catch( e ) {
+            console.error("invalid json in file");
+        }
+    }
+});
+```
+
+Into this:
+
+```js
+readFile("file.json").then(JSON.parse).then(function(val) {
+    console.log(val.success);
+})
+.catch(SyntaxError, function(e) {
+    console.error("invalid json in file");
+})
+.catch(function(e){
+    console.error("unable to read file")
+});
+```
+
+Actually you might notice the latter has a lot in common with code that would do the same using synchronous I/O:
+
+```js
+try {
+    var val = JSON.parse(readFile("file.json"));
+    console.log(val.success);
+}
+//Syntax actually not supported in JS but drives the point
+catch(SyntaxError e) {
+    console.error("invalid json in file");
+}
+catch(Error e) {
+    console.error("unable to read file")
+}
+```
+
+And that is the point - being able to have something that is a lot like `return` and `throw` in synchronous code.
+
+You can also use promises to improve code that was written with callback helpers:
+
+
+```js
+//Copyright Plato http://stackoverflow.com/a/19385911/995876
+//CC BY-SA 2.5
+mapSeries(URLs, function (URL, done) {
+    var options = {};
+    needle.get(URL, options, function (error, response, body) {
+        if (error) {
+            return done(error)
+        }
+        try {
+            var ret = JSON.parse(body);
+            return done(null, ret);
+        }
+        catch (e) {
+            done(e);
+        }
+    });
+}, function (err, results) {
+    if (err) {
+        console.log(err)
+    } else {
+        console.log('All Needle requests successful');
+        // results is a 1 to 1 mapping in order of URLs > needle.body
+        processAndSaveAllInDB(results, function (err) {
+            if (err) {
+                return done(err)
+            }
+            console.log('All Needle requests saved');
+            done(null);
+        });
+    }
+});
+```
+
+Is more pleasing to the eye when done with promises:
+
+```js
+Promise.promisifyAll(needle);
+var options = {};
+
+var current = Promise.resolve();
+Promise.map(URLs, function(URL) {
+    current = current.then(function () {
+        return needle.getAsync(URL, options);
+    });
+    return current;
+}).map(function(responseAndBody){
+    return JSON.parse(responseAndBody[1]);
+}).then(function (results) {
+    return processAndSaveAllInDB(results);
+}).then(function(){
+    console.log('All Needle requests saved');
+}).catch(function (e) {
+    console.log(e);
+});
+```
+
+Also promises don't just give you correspondences for synchronous features but can also be used as limited event emitters or callback aggregators.
+
+More reading:
+
+ - [Promise nuggets](http://spion.github.io/promise-nuggets/)
+ - [Why I am switching to promises](http://spion.github.io/posts/why-i-am-switching-to-promises.html)
+ - [What is the the point of promises](http://domenic.me/2012/10/14/youre-missing-the-point-of-promises/#toc_1)
+ - [Snippets for common problems](https://github.com/petkaantonov/bluebird/wiki/Snippets)
+ - [Promise anti-patterns](https://github.com/petkaantonov/bluebird/wiki/Promise-anti-patterns)
+
+#Questions and issues
+
+If you find a bug in bluebird or have a feature request, file an issue in the [github issue tracker](https://github.com/petkaantonov/bluebird/issues). Anything else, such as questions for help in using the library, should be posted in [StackOverflow](http://stackoverflow.com/questions/tagged/bluebird) under tags `promise` and `bluebird`.
+
+#Error handling
+
+This is a problem every promise library needs to handle in some way. Unhandled rejections/exceptions don't really have a good agreed-on asynchronous correspondence. The problem is that it is impossible to predict the future and know if a rejected promise will eventually be handled.
+
+There are two common pragmatic attempts at solving the problem that promise libraries do.
+
+The more popular one is to have the user explicitly communicate that they are done and any unhandled rejections should be thrown, like so:
+
+```js
+download().then(...).then(...).done();
+```
+
+For handling this problem, in my opinion, this is completely unacceptable and pointless. The user must remember to explicitly call `.done` and that cannot be justified when the problem is forgetting to create an error handler in the first place.
+
+The second approach, which is what bluebird by default takes, is to call a registered handler if a rejection is unhandled by the start of a second turn. The default handler is to write the stack trace to stderr or `console.error` in browsers. This is close to what happens with synchronous code - your code doens't work as expected and you open console and see a stack trace. Nice.
+
+Of course this is not perfect, if your code for some reason needs to swoop in and attach error handler to some promise after the promise has been hanging around a while then you will see annoying messages. In that case you can use the `.done()` method to signal that any hanging exceptions should be thrown.
+
+If you want to override the default handler for these possibly unhandled rejections, you can pass yours like so:
+
+```js
+Promise.onPossiblyUnhandledRejection(function(error){
+    throw error;
+});
+```
+
+If you want to also enable long stack traces, call:
+
+```js
+Promise.longStackTraces();
+```
+
+right after the library is loaded.
+
+In node.js use the environment flag `BLUEBIRD_DEBUG`:
+
+```
+BLUEBIRD_DEBUG=1 node server.js
+```
+
+to enable long stack traces in all instances of bluebird.
+
+Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, even after using every trick to optimize them.
+
+Long stack traces are enabled by default in the debug build.
+
+####Expected and unexpected errors
+
+A practical problem with Promises/A+ is that it models Javascript `try-catch` too closely for its own good. Therefore by default promises inherit `try-catch` warts such as the inability to specify the error types that the catch block is eligible for. It is an anti-pattern in every other language to use catch-all handlers because they swallow exceptions that you might not know about.
+
+Now, Javascript does have a perfectly fine and working way of creating error type hierarchies. It is still quite awkward to use them with the built-in `try-catch` however:
+
+```js
+try {
+    //code
+}
+catch(e) {
+    if( e instanceof WhatIWantError) {
+        //handle
+    }
+    else {
+        throw e;
+    }
+}
+```
+
+Without such checking, unexpected errors would be silently swallowed. However, with promises, bluebird brings the future (hopefully) here now and extends the `.catch` to [accept potential error type eligibility](https://github.com/petkaantonov/bluebird/blob/master/API.md#catchfunction-errorclass-function-handler---promise).
+
+For instance here it is expected that some evil or incompetent entity will try to crash our server from `SyntaxError` by providing syntactically invalid JSON:
+
+```js
+getJSONFromSomewhere().then(function(jsonString) {
+    return JSON.parse(jsonString);
+}).then(function(object) {
+    console.log("it was valid json: ", object);
+}).catch(SyntaxError, function(e){
+    console.log("don't be evil");
+});
+```
+
+Here any kind of unexpected error will automatically reported on stderr along with a stack trace because we only register a handler for the expected `SyntaxError`.
+
+Ok, so, that's pretty neat. But actually not many libraries define error types and it is in fact a complete ghetto out there with ad hoc strings being attached as some arbitrary property name like `.name`, `.type`, `.code`, not having any property at all or even throwing strings as errors and so on. So how can we still listen for expected errors?
+
+Bluebird defines a special error type `RejectionError` (you can get a reference from `Promise.RejectionError`). This type of error is given as rejection reason by promisified methods when
+their underlying library gives an untyped, but expected error. Primitives such as strings, and error objects that are directly created like `new Error("database didn't respond")` are considered untyped.
+
+Example of such library is the node core library `fs`. So if we promisify it, we can catch just the errors we want pretty easily and have programmer errors be redirected to unhandled rejection handler so that we notice them:
+
+```js
+//Read more about promisification in the API Reference:
+//https://github.com/petkaantonov/bluebird/blob/master/API.md
+var fs = Promise.promisifyAll(require("fs"));
+
+fs.readFileAsync("myfile.json").then(JSON.parse).then(function (json) {
+    console.log("Successful json")
+}).catch(SyntaxError, function (e) {
+    console.error("file contains invalid json");
+}).catch(Promise.RejectionError, function (e) {
+    console.error("unable to read file, because: ", e.message);
+});
+```
+
+The last `catch` handler is only invoked when the `fs` module explicitly used the `err` argument convention of async callbacks to inform of an expected error. The `RejectionError` instance will contain the original error in its `.cause` property but it does have a direct copy of the `.message` and `.stack` too. In this code any unexpected error - be it in our code or the `fs` module - would not be caught by these handlers and therefore not swallowed.
+
+Since a `catch` handler typed to `Promise.RejectionError` is expected to be used very often, it has a neat shorthand:
+
+```js
+.error(function (e) {
+    console.error("unable to read file, because: ", e.message);
+});
+```
+
+See [API documentation for `.error()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#error-rejectedhandler----promise)
+
+Finally, Bluebird also supports predicate-based filters. If you pass a
+predicate function instead of an error type, the predicate will receive
+the error as an argument. The return result will be used determine whether
+the error handler should be called.
+
+Predicates should allow for very fine grained control over caught errors:
+pattern matching, error typesets with set operations and many other techniques
+can be implemented on top of them.
+
+Example of using a predicate-based filter:
+
+```js
+var Promise = require("bluebird");
+var request = Promise.promisify(require("request"));
+
+function clientError(e) {
+    return e.code >= 400 && e.code < 500;
+}
+
+request("http://www.google.com").then(function(contents){
+    console.log(contents);
+}).catch(clientError, function(e){
+   //A client error like 400 Bad Request happened
+});
+```
+
+**Danger:** The JavaScript language allows throwing primitive values like strings. Throwing primitives can lead to worse or no stack traces. Primitives [are not exceptions](http://www.devthought.com/2011/12/22/a-string-is-not-an-error/). You should consider always throwing Error objects when handling exceptions.
+
+<hr>
+
+####How do long stack traces differ from e.g. Q?
+
+Bluebird attempts to have more elaborate traces. Consider:
+
+```js
+Error.stackTraceLimit = 25;
+Q.longStackSupport = true;
+Q().then(function outer() {
+    return Q().then(function inner() {
+        return Q().then(function evenMoreInner() {
+            a.b.c.d();
+        }).catch(function catcher(e){
+            console.error(e.stack);
+        });
+    })
+});
+```
+
+You will see
+
+    ReferenceError: a is not defined
+        at evenMoreInner (<anonymous>:7:13)
+    From previous event:
+        at inner (<anonymous>:6:20)
+
+Compare to:
+
+```js
+Error.stackTraceLimit = 25;
+Promise.longStackTraces();
+Promise.resolve().then(function outer() {
+    return Promise.resolve().then(function inner() {
+        return Promise.resolve().then(function evenMoreInner() {
+            a.b.c.d()
+        }).catch(function catcher(e){
+            console.error(e.stack);
+        });
+    });
+});
+```
+
+    ReferenceError: a is not defined
+        at evenMoreInner (<anonymous>:7:13)
+    From previous event:
+        at inner (<anonymous>:6:36)
+    From previous event:
+        at outer (<anonymous>:5:32)
+    From previous event:
+        at <anonymous>:4:21
+        at Object.InjectedScript._evaluateOn (<anonymous>:572:39)
+        at Object.InjectedScript._evaluateAndWrap (<anonymous>:531:52)
+        at Object.InjectedScript.evaluate (<anonymous>:450:21)
+
+
+A better and more practical example of the differences can be seen in gorgikosev's [debuggability competition](https://github.com/spion/async-compare#debuggability).
+
+<hr>
+
+####Can I use long stack traces in production?
+
+Probably yes. Bluebird uses multiple innovative techniques to optimize long stack traces. Even with long stack traces, it is still way faster than similarly featured implementations that don't have long stack traces enabled and about same speed as minimal implementations. A slowdown of 4-5x is expected, not 50x.
+
+What techniques are used?
+
+#####V8 API second argument
+
+This technique utilizes the [slightly under-documented](https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi#Stack_trace_collection_for_custom_exceptions) second argument of V8 `Error.captureStackTrace`. It turns out that the second argument can actually be used to make V8 skip all library internal stack frames [for free](https://github.com/v8/v8/blob/b5fabb9225e1eb1c20fd527b037e3f877296e52a/src/isolate.cc#L665). It only requires propagation of callers manually in library internals but this is not visible to you as user at all.
+
+Without this technique, every promise (well not every, see second technique) created would have to waste time creating and collecting library internal frames which will just be thrown away anyway. It also allows one to use smaller stack trace limits because skipped frames are not counted towards the limit whereas with collecting everything upfront and filtering afterwards would likely have to use higher limits to get more user stack frames in.
+
+#####Sharing stack traces
+
+Consider:
+
+```js
+function getSomethingAsync(fileName) {
+    return readFileAsync(fileName).then(function(){
+        //...
+    }).then(function() {
+        //...
+    }).then(function() {
+        //...
+    });
+}
+```
+
+Everytime you call this function it creates 4 promises and in a straight-forward long stack traces implementation it would collect 4 almost identical stack traces. Bluebird has a light weight internal data-structure (kcnown as context stack in the source code) to help tracking when traces can be re-used and this example would only collect one trace.
+
+#####Lazy formatting
+
+After a stack trace has been collected on an object, one must be careful not to reference the `.stack` property until necessary. Referencing the property causes
+an expensive format call and the stack property is turned into a string which uses much more memory.
+
+What about [Q #111](https://github.com/kriskowal/q/issues/111)?
+
+Long stack traces is not inherently the problem. For example with latest Q with stack traces disabled:
+
+```js
+var Q = require("q");
+
+
+function test(i){
+    if (i <= 0){
+       return Q.when('done')
+   } else {
+       return Q.when(i-1).then(test)
+   }
+}
+test(1000000000).then(function(output){console.log(output) });
+```
+
+After 2 minutes of running this, it will give:
+
+```js
+FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - process out of memory
+```
+
+So the problem with this is how much absolute memory is used per promise - not whether long traces are enabled or not.
+
+For some purpose, let's say 100000 parallel pending promises in memory at the same time is the maximum. You would then roughly use 100MB for them instead of 10MB with stack traces disabled.For comparison, just creating 100000 functions alone will use 14MB if they're closures. All numbers can be halved for 32-bit node.
+
+<hr>
+
+#Development
+
+For development tasks such as running benchmarks or testing, you need to clone the repository and install dev-dependencies.
+
+Install [node](http://nodejs.org/), [npm](https://npmjs.org/), and [grunt](http://gruntjs.com/).
+
+    git clone git@github.com:petkaantonov/bluebird.git
+    cd bluebird
+    npm install
+
+##Testing
+
+To run all tests, run `grunt test`. Note that 10 processes are created to run the tests in parallel. The stdout of tests is ignored by default and everything will stop at the first failure.
+
+Individual files can be run with `grunt test --run=filename` where `filename` is a test file name in `/test` folder or `/test/mocha` folder. The `.js` prefix is not needed. The dots for AP compliance tests are not needed, so to run `/test/mocha/2.3.3.js` for instance:
+
+    grunt test --run=233
+
+When trying to get a test to pass, run only that individual test file with `--verbose` to see the output from that test:
+
+    grunt test --run=233 --verbose
+
+The reason for the unusual way of testing is because the majority of tests are from different libraries using different testing frameworks and because it takes forever to test sequentially.
+
+
+###Testing in browsers
+
+To test in browsers:
+
+    cd browser
+    setup
+
+Then open the `index.html` in your browser. Requires bash (on windows the mingw32 that comes with git works fine too).
+
+You may also [visit the github hosted page](http://petkaantonov.github.io/bluebird/browser/).
+
+Keep the test tab active because some tests are timing-sensitive and will fail if the browser is throttling timeouts. Chrome will do this for example when the tab is not active.
+
+##Benchmarks
+
+To run a benchmark, run the given command for a benchmark while on the project root. Requires bash (on windows the mingw32 that comes with git works fine too).
+
+Node 0.11.2+ is required to run the generator examples.
+
+###1\. DoxBee sequential
+
+Currently the most relevant benchmark is @gorkikosev's benchmark in the article [Analysis of generators and other async patterns in node](http://spion.github.io/posts/analysis-generators-and-other-async-patterns-node.html). The benchmark emulates a situation where n amount of users are making a request in parallel to execute some mixed async/sync action. The benchmark has been modified to include a warm-up phase to minimize any JITing during timed sections.
+
+Command: `bench doxbee`
+
+###2\. Made-up parallel
+
+This made-up scenario runs 15 shimmed queries in parallel.
+
+Command: `bench parallel`
+
+##Custom builds
+
+Custom builds for browsers are supported through a command-line utility.
+
+
+
+
+<table>
+    <caption>The following features can be disabled</caption>
+    <thead>
+        <tr>
+            <th>Feature(s)</th>
+            <th>Command line identifier</th>
+        </tr>
+    </thead>
+    <tbody>
+
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#any---promise"><code>.any</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promiseanyarraydynamicpromise-values---promise"><code>Promise.any</code></a></td><td><code>any</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#race---promise"><code>.race</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promiseracearraypromise-promises---promise"><code>Promise.race</code></a></td><td><code>race</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#callstring-propertyname--dynamic-arg---promise"><code>.call</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#getstring-propertyname---promise"><code>.get</code></a></td><td><code>call_get</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#filterfunction-filterer---promise"><code>.filter</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisefilterarraydynamicpromise-values-function-filterer---promise"><code>Promise.filter</code></a></td><td><code>filter</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#mapfunction-mapper---promise"><code>.map</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisemaparraydynamicpromise-values-function-mapper---promise"><code>Promise.map</code></a></td><td><code>map</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#reducefunction-reducer--dynamic-initialvalue---promise"><code>.reduce</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisereducearraydynamicpromise-values-function-reducer--dynamic-initialvalue---promise"><code>Promise.reduce</code></a></td><td><code>reduce</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#props---promise"><code>.props</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisepropsobjectpromise-object---promise"><code>Promise.props</code></a></td><td><code>props</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#settle---promise"><code>.settle</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisesettlearraydynamicpromise-values---promise"><code>Promise.settle</code></a></td><td><code>settle</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#someint-count---promise"><code>.some</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisesomearraydynamicpromise-values-int-count---promise"><code>Promise.some</code></a></td><td><code>some</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#nodeifyfunction-callback---promise"><code>.nodeify</code></a></td><td><code>nodeify</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisecoroutinegeneratorfunction-generatorfunction---function"><code>Promise.coroutine</code></a> and <a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisespawngeneratorfunction-generatorfunction---promise"><code>Promise.spawn</code></a></td><td><code>generators</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#progression">Progression</a></td><td><code>progress</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#promisification">Promisification</a></td><td><code>promisify</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#cancellation">Cancellation</a></td><td><code>cancel</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#synchronous-inspection">Synchronous inspection</a></td><td><code>synchronous_inspection</code></td></tr>
+        <tr><td><a href="https://github.com/petkaantonov/bluebird/blob/master/API.md#timers">Timers</a></td><td><code>timers</code></td></tr>
+
+    </tbody>
+</table>
+
+
+Make sure you have cloned the repo somewhere and did `npm install` successfully.
+
+After that you can run:
+
+    grunt build --features="core"
+
+
+The above builds the most minimal build you can get. You can add more features separated by spaces from the above list:
+
+    grunt build --features="core filter map reduce"
+
+The custom build file will be found from `/js/browser/bluebird.js`. It will have a comment that lists the disabled and enabled features.
+
+Note that the build leaves the `/js/main` etc folders with same features so if you use the folder for node.js at the same time, don't forget to build
+a full version afterwards (after having taken a copy of the bluebird.js somewhere):
+
+    grunt build
+
+<hr>
+
+##For library authors
+
+Building a library that depends on bluebird? You should know about a few features.
+
+If your library needs to do something obtrusive like adding or modifying methods on the `Promise` prototype, uses long stack traces or uses a custom unhandled rejection handler then... that's totally ok as long as you don't use `require("bluebird")`. Instead you should create a file
+that creates an isolated copy. For example, creating a file called `bluebird-extended.js` that contains:
+
+```js
+                //NOTE the function call right after
+module.exports = require("bluebird/js/main/promise")();
+```
+
+Your library can then use `var Promise = require("bluebird-extended");` and do whatever it wants with it. Then if the application or other library uses their own bluebird promises they will all play well together because of Promises/A+ thenable assimilation magic.
+
+You should also know about [`.nodeify()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#nodeifyfunction-callback---promise) which makes it easy to provide a dual callback/promise API.
+
+<hr>
+
+##What is the sync build?
+
+You may now use sync build by:
+
+    var Promise = require("bluebird/zalgo");
+
+The sync build is provided to see how forced asynchronity affects benchmarks. It should not be used in real code due to the implied hazards.
+
+The normal async build gives Promises/A+ guarantees about asynchronous resolution of promises. Some people think this affects performance or just plain love their code having a possibility
+of stack overflow errors and non-deterministic behavior.
+
+The sync build skips the async call trampoline completely, e.g code like:
+
+    async.invoke( this.fn, this, val );
+
+Appears as this in the sync build:
+
+    this.fn(val);
+
+This should pressure the CPU slightly less and thus the sync build should perform better. Indeed it does, but only marginally. The biggest performance boosts are from writing efficient Javascript, not from compromising determinism.
+
+Note that while some benchmarks are waiting for the next event tick, the CPU is actually not in use during that time. So the resulting benchmark result is not completely accurate because on node.js you only care about how much the CPU is taxed. Any time spent on CPU is time the whole process (or server) is paralyzed. And it is not graceful like it would be with threads.
+
+
+```js
+var cache = new Map(); //ES6 Map or DataStructures/Map or whatever...
+function getResult(url) {
+    var resolver = Promise.pending();
+    if (cache.has(url)) {
+        resolver.resolve(cache.get(url));
+    }
+    else {
+        http.get(url, function(err, content) {
+            if (err) resolver.reject(err);
+            else {
+                cache.set(url, content);
+                resolver.resolve(content);
+            }
+        });
+    }
+    return resolver.promise;
+}
+
+
+
+//The result of console.log is truly random without async guarantees
+function guessWhatItPrints( url ) {
+    var i = 3;
+    getResult(url).then(function(){
+        i = 4;
+    });
+    console.log(i);
+}
+```
+
+#Optimization guide
+
+Articles about optimization will be periodically posted in [the wiki section](https://github.com/petkaantonov/bluebird/wiki), polishing edits are welcome.
+
+A single cohesive guide compiled from the articles will probably be done eventually.
+
+#License
+
+Copyright (c) 2014 Petka Antonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:</p>
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/benchmark/package.json
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/benchmark/package.json b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/benchmark/package.json
new file mode 100644
index 0000000..19cefed
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/benchmark/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "async-compare",
+  "version": "0.1.1",
+  "description": "Compare the performance and code of multiple async patterns",
+  "main": "perf.js",
+  "dependencies": {
+    "async": "~0.2.9",
+    "deferred": "~0.6.6",
+    "kew": "~0.3.0",
+    "liar": "~0.6.0",
+    "optimist": "~0.6.0",
+    "q": "~1.0.0",
+    "rsvp": "~3.0.0",
+    "text-table": "~0.2.0",
+    "when": "~3.0.0",
+    "vow": "~0.4.1",
+    "davy": "~0.2.0"
+  },
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "generators",
+    "fibers",
+    "promises",
+    "callbacks",
+    "comparison",
+    "compare",
+    "async"
+  ],
+  "author": "spion",
+  "license": "MIT"
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bower.json
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bower.json b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bower.json
new file mode 100644
index 0000000..396073a
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bower.json
@@ -0,0 +1,35 @@
+{
+  "name": "bluebird",
+  "version": "1.0.0",
+  "homepage": "https://github.com/petkaantonov/bluebird",
+  "authors": [
+    "Petka Antonov <petka_antonov@hotmail.com>"
+  ],
+  "description": "Bluebird is a full featured promise library with unmatched performance.",
+  "main": "js/browser/bluebird.js",
+  "license": "MIT",
+  "ignore": [
+    "**/.*",
+    "benchmark",
+    "bower_components",
+    "./browser",
+    "js/zalgo",
+    "node_modules",
+    "test"
+  ],
+  "keywords": [
+    "promise",
+    "performance",
+    "promises",
+    "promises-a",
+    "promises-aplus",
+    "async",
+    "await",
+    "deferred",
+    "deferreds",
+    "future",
+    "flow control",
+    "dsl",
+    "fluent interface"
+  ]
+}

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bundle.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bundle.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/bundle.js
new file mode 100644
index 0000000..e69de29

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/changelog.md
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/changelog.md b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/changelog.md
new file mode 100644
index 0000000..9ae6be2
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/changelog.md
@@ -0,0 +1,1135 @@
+## 1.1.1 (2014-03-18)
+
+Bugfixes:
+
+ - [#138](https://github.com/petkaantonov/bluebird/issues/138)
+ - [#144](https://github.com/petkaantonov/bluebird/issues/144)
+ - [#148](https://github.com/petkaantonov/bluebird/issues/148)
+ - [#151](https://github.com/petkaantonov/bluebird/issues/151)
+
+## 1.1.0 (2014-03-08)
+
+Features:
+
+ - Implement [`Promise.prototype.tap()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#tapfunction-handler---promise)
+ - Implement [`Promise.coroutine.addYieldHandler()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#promisecoroutineaddyieldhandlerfunction-handler---void)
+ - Deprecate `Promise.prototype.spawn`
+
+Bugfixes:
+
+ - Fix already rejected promises being reported as unhandled when handled through collection methods
+ - Fix browserisfy crashing from checking `process.version.indexOf`
+
+## 1.0.8 (2014-03-03)
+
+Bugfixes:
+
+ - Fix active domain being lost across asynchronous boundaries in Node.JS 10.xx
+
+## 1.0.7 (2014-02-25)
+
+Bugfixes:
+
+ - Fix handled errors being reported
+
+## 1.0.6 (2014-02-17)
+
+Bugfixes:
+
+ -  Fix bug with unhandled rejections not being reported
+    when using `Promise.try` or `Promise.method` without
+    attaching further handlers
+
+## 1.0.5 (2014-02-15)
+
+Features:
+
+ - Node.js performance: promisified functions try to check amount of passed arguments in most optimal order
+ - Node.js promisified functions will have same `.length` as the original function minus one (for the callback parameter)
+
+## 1.0.4 (2014-02-09)
+
+Features:
+
+ - Possibly unhandled rejection handler will always get a stack trace, even if the rejection or thrown error was not an error
+ - Unhandled rejections are tracked per promise, not per error. So if you create multiple branches from a single ancestor and that ancestor gets rejected, each branch with no error handler with the end will cause a possibly unhandled rejection handler invocation
+
+Bugfixes:
+
+ - Fix unhandled non-writable objects or primitives not reported by possibly unhandled rejection handler
+
+## 1.0.3 (2014-02-05)
+
+Bugfixes:
+
+ - [#93](https://github.com/petkaantonov/bluebird/issues/88)
+
+## 1.0.2 (2014-02-04)
+
+Features:
+
+ - Significantly improve performance of foreign bluebird thenables
+
+Bugfixes:
+
+ - [#88](https://github.com/petkaantonov/bluebird/issues/88)
+
+## 1.0.1 (2014-01-28)
+
+Features:
+
+ - Error objects that have property `.isAsync = true` will now be caught by `.error()`
+
+Bugfixes:
+
+ - Fix TypeError and RangeError shims not working without `new` operator
+
+## 1.0.0 (2014-01-12)
+
+Features:
+
+ - `.filter`, `.map`, and `.reduce` no longer skip sparse array holes. This is a backwards incompatible change.
+ - Like `.map` and `.filter`, `.reduce` now allows returning promises and thenables from the iteration function.
+
+Bugfixes:
+
+ - [#58](https://github.com/petkaantonov/bluebird/issues/58)
+ - [#61](https://github.com/petkaantonov/bluebird/issues/61)
+ - [#64](https://github.com/petkaantonov/bluebird/issues/64)
+ - [#60](https://github.com/petkaantonov/bluebird/issues/60)
+
+## 0.11.6-1 (2013-12-29)
+
+## 0.11.6-0 (2013-12-29)
+
+Features:
+
+ - You may now return promises and thenables from the filterer function used in `Promise.filter` and `Promise.prototype.filter`.
+
+ - `.error()` now catches additional sources of rejections:
+
+    - Rejections originating from `Promise.reject`
+
+    - Rejections originating from thenables using
+    the `reject` callback
+
+    - Rejections originating from promisified callbacks
+    which use the `errback` argument
+
+    - Rejections originating from `new Promise` constructor
+    where the `reject` callback is called explicitly
+
+    - Rejections originating from `PromiseResolver` where
+    `.reject()` method is called explicitly
+
+Bugfixes:
+
+ - Fix `captureStackTrace` being called when it was `null`
+ - Fix `Promise.map` not unwrapping thenables
+
+## 0.11.5-1 (2013-12-15)
+
+## 0.11.5-0 (2013-12-03)
+
+Features:
+
+ - Improve performance of collection methods
+ - Improve performance of promise chains
+
+## 0.11.4-1 (2013-12-02)
+
+## 0.11.4-0 (2013-12-02)
+
+Bugfixes:
+
+ - Fix `Promise.some` behavior with arguments like negative integers, 0...
+ - Fix stack traces of synchronously throwing promisified functions'
+
+## 0.11.3-0 (2013-12-02)
+
+Features:
+
+ - Improve performance of generators
+
+Bugfixes:
+
+ - Fix critical bug with collection methods.
+
+## 0.11.2-0 (2013-12-02)
+
+Features:
+
+ - Improve performance of all collection methods
+
+## 0.11.1-0 (2013-12-02)
+
+Features:
+
+- Improve overall performance.
+- Improve performance of promisified functions.
+- Improve performance of catch filters.
+- Improve performance of .finally.
+
+Bugfixes:
+
+- Fix `.finally()` rejecting if passed non-function. It will now ignore non-functions like `.then`.
+- Fix `.finally()` not converting thenables returned from the handler to promises.
+- `.spread()` now rejects if the ultimate value given to it is not spreadable.
+
+## 0.11.0-0 (2013-12-02)
+
+Features:
+
+ - Improve overall performance when not using `.bind()` or cancellation.
+ - Promises are now not cancellable by default. This is backwards incompatible change - see [`.cancellable()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#cancellable---promise)
+ - [`Promise.delay`](https://github.com/petkaantonov/bluebird/blob/master/API.md#promisedelaydynamic-value-int-ms---promise)
+ - [`.delay()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#delayint-ms---promise)
+ - [`.timeout()`](https://github.com/petkaantonov/bluebird/blob/master/API.md#timeoutint-ms--string-message---promise)
+
+## 0.10.14-0 (2013-12-01)
+
+Bugfixes:
+
+ - Fix race condition when mixing 3rd party asynchrony.
+
+## 0.10.13-1 (2013-11-30)
+
+## 0.10.13-0 (2013-11-30)
+
+Bugfixes:
+
+ - Fix another bug with progression.
+
+## 0.10.12-0 (2013-11-30)
+
+Bugfixes:
+
+ - Fix bug with progression.
+
+## 0.10.11-4 (2013-11-29)
+
+## 0.10.11-2 (2013-11-29)
+
+Bugfixes:
+
+ - Fix `.race()` not propagating bound values.
+
+## 0.10.11-1 (2013-11-29)
+
+Features:
+
+ - Improve performance of `Promise.race`
+
+## 0.10.11-0 (2013-11-29)
+
+Bugfixes:
+
+ - Fixed `Promise.promisifyAll` invoking property accessors. Only data properties with function values are considered.
+
+## 0.10.10-0 (2013-11-28)
+
+Features:
+
+ - Disable long stack traces in browsers by default. Call `Promise.longStackTraces()` to enable them.
+
+## 0.10.9-1 (2013-11-27)
+
+Bugfixes:
+
+ - Fail early when `new Promise` is constructed incorrectly
+
+## 0.10.9-0 (2013-11-27)
+
+Bugfixes:
+
+ - Promise.props now takes a [thenable-for-collection](https://github.com/petkaantonov/bluebird/blob/f41edac61b7c421608ff439bb5a09b7cffeadcf9/test/mocha/props.js#L197-L217)
+ - All promise collection methods now reject when a promise-or-thenable-for-collection turns out not to give a collection
+
+## 0.10.8-0 (2013-11-25)
+
+Features:
+
+ - All static collection methods take thenable-for-collection
+
+## 0.10.7-0 (2013-11-25)
+
+Features:
+
+ - throw TypeError when thenable resolves with itself
+ - Make .race() and Promise.race() forever pending on empty collections
+
+## 0.10.6-0 (2013-11-25)
+
+Bugfixes:
+
+ - Promise.resolve and PromiseResolver.resolve follow thenables too.
+
+## 0.10.5-0 (2013-11-24)
+
+Bugfixes:
+
+ - Fix infinite loop when thenable resolves with itself
+
+## 0.10.4-1 (2013-11-24)
+
+Bugfixes:
+
+ - Fix a file missing from build. (Critical fix)
+
+## 0.10.4-0 (2013-11-24)
+
+Features:
+
+ - Remove dependency of es5-shim and es5-sham when using ES3.
+
+## 0.10.3-0 (2013-11-24)
+
+Features:
+
+ - Improve performance of `Promise.method`
+
+## 0.10.2-1 (2013-11-24)
+
+Features:
+
+ - Rename PromiseResolver#asCallback to PromiseResolver#callback
+
+## 0.10.2-0 (2013-11-24)
+
+Features:
+
+ - Remove memoization of thenables
+
+## 0.10.1-0 (2013-11-21)
+
+Features:
+
+ - Add methods `Promise.resolve()`, `Promise.reject()`, `Promise.defer()` and `.resolve()`.
+
+## 0.10.0-1 (2013-11-17)
+
+## 0.10.0-0 (2013-11-17)
+
+Features:
+
+ - Implement `Promise.method()`
+ - Implement `.return()`
+ - Implement `.throw()`
+
+Bugfixes:
+
+ - Fix promises being able to use themselves as resolution or follower value
+
+## 0.9.11-1 (2013-11-14)
+
+Features:
+
+ - Implicit `Promise.all()` when yielding an array from generators
+
+## 0.9.11-0 (2013-11-13)
+
+Bugfixes:
+
+ - Fix `.spread` not unwrapping thenables
+
+## 0.9.10-2 (2013-11-13)
+
+Features:
+
+ - Improve performance of promisified functions on V8
+
+Bugfixes:
+
+ - Report unhandled rejections even when long stack traces are disabled
+ - Fix `.error()` showing up in stack traces
+
+## 0.9.10-1 (2013-11-05)
+
+Bugfixes:
+
+ - Catch filter method calls showing in stack traces
+
+## 0.9.10-0 (2013-11-05)
+
+Bugfixes:
+
+ - Support primitives in catch filters
+
+## 0.9.9-0 (2013-11-05)
+
+Features:
+
+ - Add `Promise.race()` and `.race()`
+
+## 0.9.8-0 (2013-11-01)
+
+Bugfixes:
+
+ - Fix bug with `Promise.try` not unwrapping returned promises and thenables
+
+## 0.9.7-0 (2013-10-29)
+
+Bugfixes:
+
+ - Fix bug with build files containing duplicated code for promise.js
+
+## 0.9.6-0 (2013-10-28)
+
+Features:
+
+ - Improve output of reporting unhandled non-errors
+ - Implement RejectionError wrapping and `.error()` method
+
+## 0.9.5-0 (2013-10-27)
+
+Features:
+
+ - Allow fresh copies of the library to be made
+
+## 0.9.4-1 (2013-10-27)
+
+## 0.9.4-0 (2013-10-27)
+
+Bugfixes:
+
+ - Rollback non-working multiple fresh copies feature
+
+## 0.9.3-0 (2013-10-27)
+
+Features:
+
+ - Allow fresh copies of the library to be made
+ - Add more components to customized builds
+
+## 0.9.2-1 (2013-10-25)
+
+## 0.9.2-0 (2013-10-25)
+
+Features:
+
+ - Allow custom builds
+
+## 0.9.1-1 (2013-10-22)
+
+Bugfixes:
+
+ - Fix unhandled rethrown exceptions not reported
+
+## 0.9.1-0 (2013-10-22)
+
+Features:
+
+ - Improve performance of `Promise.try`
+ - Extend `Promise.try` to accept arguments and ctx to make it more usable in promisification of synchronous functions.
+
+## 0.9.0-0 (2013-10-18)
+
+Features:
+
+ - Implement `.bind` and `Promise.bind`
+
+Bugfixes:
+
+ - Fix `.some()` when argument is a pending promise that later resolves to an array
+
+## 0.8.5-1 (2013-10-17)
+
+Features:
+
+ - Enable process wide long stack traces through BLUEBIRD_DEBUG environment variable
+
+## 0.8.5-0 (2013-10-16)
+
+Features:
+
+ - Improve performance of all collection methods
+
+Bugfixes:
+
+ - Fix .finally passing the value to handlers
+ - Remove kew from benchmarks due to bugs in the library breaking the benchmark
+ - Fix some bluebird library calls potentially appearing in stack traces
+
+## 0.8.4-1 (2013-10-15)
+
+Bugfixes:
+
+ - Fix .pending() call showing in long stack traces
+
+## 0.8.4-0 (2013-10-15)
+
+Bugfixes:
+
+ - Fix PromiseArray and its sub-classes swallowing possibly unhandled rejections
+
+## 0.8.3-3 (2013-10-14)
+
+Bugfixes:
+
+ - Fix AMD-declaration using named module.
+
+## 0.8.3-2 (2013-10-14)
+
+Features:
+
+ - The mortals that can handle it may now release Zalgo by `require("bluebird/zalgo");`
+
+## 0.8.3-1 (2013-10-14)
+
+Bugfixes:
+
+ - Fix memory leak when using the same promise to attach handlers over and over again
+
+## 0.8.3-0 (2013-10-13)
+
+Features:
+
+ - Add `Promise.props()` and `Promise.prototype.props()`. They work like `.all()` for object properties.
+
+Bugfixes:
+
+ - Fix bug with .some returning garbage when sparse arrays have rejections
+
+## 0.8.2-2 (2013-10-13)
+
+Features:
+
+ - Improve performance of `.reduce()` when `initialValue` can be synchronously cast to a value
+
+## 0.8.2-1 (2013-10-12)
+
+Bugfixes:
+
+ - Fix .npmignore having irrelevant files
+
+## 0.8.2-0 (2013-10-12)
+
+Features:
+
+ - Improve performance of `.some()`
+
+## 0.8.1-0 (2013-10-11)
+
+Bugfixes:
+
+ - Remove uses of dynamic evaluation (`new Function`, `eval` etc) when strictly not necessary. Use feature detection to use static evaluation to avoid errors when dynamic evaluation is prohibited.
+
+## 0.8.0-3 (2013-10-10)
+
+Features:
+
+ - Add `.asCallback` property to `PromiseResolver`s
+
+## 0.8.0-2 (2013-10-10)
+
+## 0.8.0-1 (2013-10-09)
+
+Features:
+
+ - Improve overall performance. Be able to sustain infinite recursion when using promises.
+
+## 0.8.0-0 (2013-10-09)
+
+Bugfixes:
+
+ - Fix stackoverflow error when function calls itself "synchronously" from a promise handler
+
+## 0.7.12-2 (2013-10-09)
+
+Bugfixes:
+
+ - Fix safari 6 not using `MutationObserver` as a scheduler
+ - Fix process exceptions interfering with internal queue flushing
+
+## 0.7.12-1 (2013-10-09)
+
+Bugfixes:
+
+ - Don't try to detect if generators are available to allow shims to be used
+
+## 0.7.12-0 (2013-10-08)
+
+Features:
+
+ - Promisification now consider all functions on the object and its prototype chain
+ - Individual promisifcation uses current `this` if no explicit receiver is given
+ - Give better stack traces when promisified callbacks throw or errback primitives such as strings by wrapping them in an `Error` object.
+
+Bugfixes:
+
+ - Fix runtime APIs throwing synchronous errors
+
+## 0.7.11-0 (2013-10-08)
+
+Features:
+
+ - Deprecate `Promise.promisify(Object target)` in favor of `Promise.promisifyAll(Object target)` to avoid confusion with function objects
+ - Coroutines now throw error when a non-promise is `yielded`
+
+## 0.7.10-1 (2013-10-05)
+
+Features:
+
+ - Make tests pass Internet Explorer 8
+
+## 0.7.10-0 (2013-10-05)
+
+Features:
+
+ - Create browser tests
+
+## 0.7.9-1 (2013-10-03)
+
+Bugfixes:
+
+ - Fix promise cast bug when thenable fulfills using itself as the fulfillment value
+
+## 0.7.9-0 (2013-10-03)
+
+Features:
+
+ - More performance improvements when long stack traces are enabled
+
+## 0.7.8-1 (2013-10-02)
+
+Features:
+
+ - Performance improvements when long stack traces are enabled
+
+## 0.7.8-0 (2013-10-02)
+
+Bugfixes:
+
+ - Fix promisified methods not turning synchronous exceptions into rejections
+
+## 0.7.7-1 (2013-10-02)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.7-0 (2013-10-01)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.6-0 (2013-09-29)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.5-0 (2013-09-28)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.4-1 (2013-09-28)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.4-0 (2013-09-28)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.3-1 (2013-09-28)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.3-0 (2013-09-27)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.2-0 (2013-09-27)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.1-5 (2013-09-26)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.1-4 (2013-09-25)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.1-3 (2013-09-25)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.1-2 (2013-09-24)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.1-1 (2013-09-24)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.1-0 (2013-09-24)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.0-1 (2013-09-23)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.7.0-0 (2013-09-23)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.5-2 (2013-09-20)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.5-1 (2013-09-18)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.5-0 (2013-09-18)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.4-1 (2013-09-18)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.4-0 (2013-09-18)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.3-4 (2013-09-18)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.3-3 (2013-09-18)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.3-2 (2013-09-16)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.3-1 (2013-09-16)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.3-0 (2013-09-15)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.2-1 (2013-09-14)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.2-0 (2013-09-14)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.1-0 (2013-09-14)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.6.0-0 (2013-09-13)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-6 (2013-09-12)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-5 (2013-09-12)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-4 (2013-09-12)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-3 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-2 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-1 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.9-0 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.8-1 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.8-0 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.7-0 (2013-09-11)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.6-1 (2013-09-10)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.6-0 (2013-09-10)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.5-1 (2013-09-10)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.5-0 (2013-09-09)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.4-1 (2013-09-08)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.4-0 (2013-09-08)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.3-0 (2013-09-07)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.2-0 (2013-09-07)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.1-0 (2013-09-07)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.5.0-0 (2013-09-07)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.4.0-0 (2013-09-06)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.3.0-1 (2013-09-06)
+
+Features:
+
+ - feature
+
+Bugfixes:
+
+ - bugfix
+
+## 0.3.0 (2013-09-06)

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/any.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/any.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/any.js
new file mode 100644
index 0000000..8d174cf
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/any.js
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2014 Petka Antonov
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:</p>
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ * 
+ */
+"use strict";
+module.exports = function(Promise, Promise$_CreatePromiseArray, PromiseArray) {
+
+    var SomePromiseArray = require("./some_promise_array.js")(PromiseArray);
+    function Promise$_Any(promises, useBound, caller) {
+        var ret = Promise$_CreatePromiseArray(
+            promises,
+            SomePromiseArray,
+            caller,
+            useBound === true && promises._isBound()
+                ? promises._boundTo
+                : void 0
+       );
+        var promise = ret.promise();
+        if (promise.isRejected()) {
+            return promise;
+        }
+        ret.setHowMany(1);
+        ret.setUnwrap();
+        ret.init();
+        return promise;
+    }
+
+    Promise.any = function Promise$Any(promises) {
+        return Promise$_Any(promises, false, Promise.any);
+    };
+
+    Promise.prototype.any = function Promise$any() {
+        return Promise$_Any(this, true, this.any);
+    };
+
+};

http://git-wip-us.apache.org/repos/asf/cordova-firefoxos/blob/b2b43200/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/assert.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/assert.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/assert.js
new file mode 100644
index 0000000..4adb8c2
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/main/assert.js
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2014 Petka Antonov
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:</p>
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ * 
+ */
+"use strict";
+module.exports = (function(){
+    var AssertionError = (function() {
+        function AssertionError(a) {
+            this.constructor$(a);
+            this.message = a;
+            this.name = "AssertionError";
+        }
+        AssertionError.prototype = new Error();
+        AssertionError.prototype.constructor = AssertionError;
+        AssertionError.prototype.constructor$ = Error;
+        return AssertionError;
+    })();
+
+    function getParams(args) {
+        var params = [];
+        for (var i = 0; i < args.length; ++i) params.push("arg" + i);
+        return params;
+    }
+
+    function nativeAssert(callName, args, expect) {
+        try {
+            var params = getParams(args);
+            var constructorArgs = params;
+            constructorArgs.push("return " +
+                    callName + "("+ params.join(",") + ");");
+            var fn = Function.apply(null, constructorArgs);
+            return fn.apply(null, args);
+        }
+        catch (e) {
+            if (!(e instanceof SyntaxError)) {
+                throw e;
+            }
+            else {
+                return expect;
+            }
+        }
+    }
+
+    return function assert(boolExpr, message) {
+        if (boolExpr === true) return;
+
+        if (typeof boolExpr === "string" &&
+            boolExpr.charAt(0) === "%") {
+            var nativeCallName = boolExpr;
+            var $_len = arguments.length;var args = new Array($_len - 2); for(var $_i = 2; $_i < $_len; ++$_i) {args[$_i - 2] = arguments[$_i];}
+            if (nativeAssert(nativeCallName, args, message) === message) return;
+            message = (nativeCallName + " !== " + message);
+        }
+
+        var ret = new AssertionError(message);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(ret, assert);
+        }
+        if (console && console.error) {
+            console.error(ret.stack + "");
+        }
+        throw ret;
+
+    };
+})();


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message