You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by za...@apache.org on 2015/04/01 16:22:47 UTC
[20/52] [abbrv] [partial] cordova-firefoxos git commit: CB-4548
Install new node-firefox-* dependencies in node_modules
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/zalgo/filter.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/filter.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/filter.js
new file mode 100644
index 0000000..a4b8ae7
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/filter.js
@@ -0,0 +1,53 @@
+/**
+ * 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) {
+ var isArray = require("./util.js").isArray;
+
+ function Promise$_filter(booleans) {
+ var values = this._settledValue;
+ var len = values.length;
+ var ret = new Array(len);
+ var j = 0;
+
+ for (var i = 0; i < len; ++i) {
+ if (booleans[i]) ret[j++] = values[i];
+
+ }
+ ret.length = j;
+ return ret;
+ }
+
+ var ref = {ref: null};
+ Promise.filter = function Promise$Filter(promises, fn) {
+ return Promise.map(promises, fn, ref)
+ ._then(Promise$_filter, void 0, void 0,
+ ref.ref, void 0, Promise.filter);
+ };
+
+ Promise.prototype.filter = function Promise$filter(fn) {
+ return this.map(fn, ref)
+ ._then(Promise$_filter, void 0, void 0,
+ ref.ref, void 0, this.filter);
+ };
+};
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/zalgo/finally.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/finally.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/finally.js
new file mode 100644
index 0000000..ef1e0ef
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/finally.js
@@ -0,0 +1,132 @@
+/**
+ * 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, NEXT_FILTER) {
+ var util = require("./util.js");
+ var wrapsPrimitiveReceiver = util.wrapsPrimitiveReceiver;
+ var isPrimitive = util.isPrimitive;
+ var thrower = util.thrower;
+
+
+ function returnThis() {
+ return this;
+ }
+ function throwThis() {
+ throw this;
+ }
+ function makeReturner(r) {
+ return function Promise$_returner() {
+ return r;
+ };
+ }
+ function makeThrower(r) {
+ return function Promise$_thrower() {
+ throw r;
+ };
+ }
+ function promisedFinally(ret, reasonOrValue, isFulfilled) {
+ var useConstantFunction =
+ wrapsPrimitiveReceiver && isPrimitive(reasonOrValue);
+
+ if (isFulfilled) {
+ return ret._then(
+ useConstantFunction
+ ? returnThis
+ : makeReturner(reasonOrValue),
+ thrower, void 0, reasonOrValue, void 0, promisedFinally);
+ }
+ else {
+ return ret._then(
+ useConstantFunction
+ ? throwThis
+ : makeThrower(reasonOrValue),
+ thrower, void 0, reasonOrValue, void 0, promisedFinally);
+ }
+ }
+
+ function finallyHandler(reasonOrValue) {
+ var promise = this.promise;
+ var handler = this.handler;
+
+ var ret = promise._isBound()
+ ? handler.call(promise._boundTo)
+ : handler();
+
+ if (ret !== void 0) {
+ var maybePromise = Promise._cast(ret, finallyHandler, void 0);
+ if (maybePromise instanceof Promise) {
+ return promisedFinally(maybePromise, reasonOrValue,
+ promise.isFulfilled());
+ }
+ }
+
+ if (promise.isRejected()) {
+ NEXT_FILTER.e = reasonOrValue;
+ return NEXT_FILTER;
+ }
+ else {
+ return reasonOrValue;
+ }
+ }
+
+ function tapHandler(value) {
+ var promise = this.promise;
+ var handler = this.handler;
+
+ var ret = promise._isBound()
+ ? handler.call(promise._boundTo, value)
+ : handler(value);
+
+ if (ret !== void 0) {
+ var maybePromise = Promise._cast(ret, tapHandler, void 0);
+ if (maybePromise instanceof Promise) {
+ return promisedFinally(maybePromise, value, true);
+ }
+ }
+ return value;
+ }
+
+ Promise.prototype._passThroughHandler =
+ function Promise$_passThroughHandler(handler, isFinally, caller) {
+ if (typeof handler !== "function") return this.then();
+
+ var promiseAndHandler = {
+ promise: this,
+ handler: handler
+ };
+
+ return this._then(
+ isFinally ? finallyHandler : tapHandler,
+ isFinally ? finallyHandler : void 0, void 0,
+ promiseAndHandler, void 0, caller);
+ };
+
+ Promise.prototype.lastly =
+ Promise.prototype["finally"] = function Promise$finally(handler) {
+ return this._passThroughHandler(handler, true, this.lastly);
+ };
+
+ Promise.prototype.tap = function Promise$tap(handler) {
+ return this._passThroughHandler(handler, false, this.tap);
+ };
+};
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/zalgo/generators.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/generators.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/generators.js
new file mode 100644
index 0000000..9632ae7
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/generators.js
@@ -0,0 +1,56 @@
+/**
+ * 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, apiRejection, INTERNAL) {
+ var PromiseSpawn = require("./promise_spawn.js")(Promise, INTERNAL);
+ var errors = require("./errors.js");
+ var TypeError = errors.TypeError;
+ var deprecated = require("./util.js").deprecated;
+
+ Promise.coroutine = function Promise$Coroutine(generatorFunction) {
+ if (typeof generatorFunction !== "function") {
+ throw new TypeError("generatorFunction must be a function");
+ }
+ var PromiseSpawn$ = PromiseSpawn;
+ return function anonymous() {
+ var generator = generatorFunction.apply(this, arguments);
+ var spawn = new PromiseSpawn$(void 0, void 0, anonymous);
+ spawn._generator = generator;
+ spawn._next(void 0);
+ return spawn.promise();
+ };
+ };
+
+ Promise.coroutine.addYieldHandler = PromiseSpawn.addYieldHandler;
+
+ Promise.spawn = function Promise$Spawn(generatorFunction) {
+ deprecated("Promise.spawn is deprecated. Use Promise.coroutine instead.");
+ if (typeof generatorFunction !== "function") {
+ return apiRejection("generatorFunction must be a function");
+ }
+ var spawn = new PromiseSpawn(generatorFunction, this, Promise.spawn);
+ var ret = spawn.promise();
+ spawn._run(Promise.spawn);
+ return ret;
+ };
+};
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/zalgo/global.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/global.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/global.js
new file mode 100644
index 0000000..1ab1947
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/global.js
@@ -0,0 +1,42 @@
+/**
+ * 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(){
+ if (typeof this !== "undefined") {
+ return this;
+ }
+ if (typeof process !== "undefined" &&
+ typeof global !== "undefined" &&
+ typeof process.execPath === "string") {
+ return global;
+ }
+ if (typeof window !== "undefined" &&
+ typeof document !== "undefined" &&
+ typeof navigator !== "undefined" && navigator !== null &&
+ typeof navigator.appName === "string") {
+ if(window.wrappedJSObject !== undefined){
+ return window.wrappedJSObject;
+ }
+ return window;
+ }
+})();
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/zalgo/map.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/map.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/map.js
new file mode 100644
index 0000000..b2a36b0
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/map.js
@@ -0,0 +1,127 @@
+/**
+ * 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, apiRejection) {
+
+ function Promise$_mapper(values) {
+ var fn = this;
+ var receiver = void 0;
+
+ if (typeof fn !== "function") {
+ receiver = fn.receiver;
+ fn = fn.fn;
+ }
+ var shouldDefer = false;
+
+ var ret = new Array(values.length);
+
+ if (receiver === void 0) {
+ for (var i = 0, len = values.length; i < len; ++i) {
+ var value = fn(values[i], i, len);
+ if (!shouldDefer) {
+ var maybePromise = Promise._cast(value,
+ Promise$_mapper, void 0);
+ if (maybePromise instanceof Promise) {
+ if (maybePromise.isFulfilled()) {
+ ret[i] = maybePromise._settledValue;
+ continue;
+ }
+ else {
+ shouldDefer = true;
+ }
+ value = maybePromise;
+ }
+ }
+ ret[i] = value;
+ }
+ }
+ else {
+ for (var i = 0, len = values.length; i < len; ++i) {
+ var value = fn.call(receiver, values[i], i, len);
+ if (!shouldDefer) {
+ var maybePromise = Promise._cast(value,
+ Promise$_mapper, void 0);
+ if (maybePromise instanceof Promise) {
+ if (maybePromise.isFulfilled()) {
+ ret[i] = maybePromise._settledValue;
+ continue;
+ }
+ else {
+ shouldDefer = true;
+ }
+ value = maybePromise;
+ }
+ }
+ ret[i] = value;
+ }
+ }
+ return shouldDefer
+ ? Promise$_CreatePromiseArray(ret, PromiseArray,
+ Promise$_mapper, void 0).promise()
+ : ret;
+ }
+
+ function Promise$_Map(promises, fn, useBound, caller, ref) {
+ if (typeof fn !== "function") {
+ return apiRejection("fn must be a function");
+ }
+
+ if (useBound === true && promises._isBound()) {
+ fn = {
+ fn: fn,
+ receiver: promises._boundTo
+ };
+ }
+
+ var ret = Promise$_CreatePromiseArray(
+ promises,
+ PromiseArray,
+ caller,
+ useBound === true && promises._isBound()
+ ? promises._boundTo
+ : void 0
+ ).promise();
+
+ if (ref !== void 0) {
+ ref.ref = ret;
+ }
+
+ return ret._then(
+ Promise$_mapper,
+ void 0,
+ void 0,
+ fn,
+ void 0,
+ caller
+ );
+ }
+
+ Promise.prototype.map = function Promise$map(fn, ref) {
+ return Promise$_Map(this, fn, true, this.map, ref);
+ };
+
+ Promise.map = function Promise$Map(promises, fn, ref) {
+ return Promise$_Map(promises, fn, false, Promise.map, ref);
+ };
+};
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/zalgo/nodeify.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/nodeify.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/nodeify.js
new file mode 100644
index 0000000..9fe25f9
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/nodeify.js
@@ -0,0 +1,64 @@
+/**
+ * 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) {
+ var util = require("./util.js");
+ var async = require("./async.js");
+ var tryCatch2 = util.tryCatch2;
+ var tryCatch1 = util.tryCatch1;
+ var errorObj = util.errorObj;
+
+ function thrower(r) {
+ throw r;
+ }
+
+ function Promise$_successAdapter(val, receiver) {
+ var nodeback = this;
+ var ret = tryCatch2(nodeback, receiver, null, val);
+ if (ret === errorObj) {
+ async.invokeLater(thrower, void 0, ret.e);
+ }
+ }
+ function Promise$_errorAdapter(reason, receiver) {
+ var nodeback = this;
+ var ret = tryCatch1(nodeback, receiver, reason);
+ if (ret === errorObj) {
+ async.invokeLater(thrower, void 0, ret.e);
+ }
+ }
+
+ Promise.prototype.nodeify = function Promise$nodeify(nodeback) {
+ if (typeof nodeback == "function") {
+ this._then(
+ Promise$_successAdapter,
+ Promise$_errorAdapter,
+ void 0,
+ nodeback,
+ this._isBound() ? this._boundTo : null,
+ this.nodeify
+ );
+ return;
+ }
+ return this;
+ };
+};
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/zalgo/progress.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/progress.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/progress.js
new file mode 100644
index 0000000..668f5f7
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/progress.js
@@ -0,0 +1,111 @@
+/**
+ * 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, isPromiseArrayProxy) {
+ var util = require("./util.js");
+ var async = require("./async.js");
+ var errors = require("./errors.js");
+ var tryCatch1 = util.tryCatch1;
+ var errorObj = util.errorObj;
+
+ Promise.prototype.progressed = function Promise$progressed(handler) {
+ return this._then(void 0, void 0, handler,
+ void 0, void 0, this.progressed);
+ };
+
+ Promise.prototype._progress = function Promise$_progress(progressValue) {
+ if (this._isFollowingOrFulfilledOrRejected()) return;
+ this._progressUnchecked(progressValue);
+
+ };
+
+ Promise.prototype._progressHandlerAt =
+ function Promise$_progressHandlerAt(index) {
+ if (index === 0) return this._progressHandler0;
+ return this[index + 2 - 5];
+ };
+
+ Promise.prototype._doProgressWith =
+ function Promise$_doProgressWith(progression) {
+ var progressValue = progression.value;
+ var handler = progression.handler;
+ var promise = progression.promise;
+ var receiver = progression.receiver;
+
+ this._pushContext();
+ var ret = tryCatch1(handler, receiver, progressValue);
+ this._popContext();
+
+ if (ret === errorObj) {
+ if (ret.e != null &&
+ ret.e.name !== "StopProgressPropagation") {
+ var trace = errors.canAttach(ret.e)
+ ? ret.e : new Error(ret.e + "");
+ promise._attachExtraTrace(trace);
+ promise._progress(ret.e);
+ }
+ }
+ else if (Promise.is(ret)) {
+ ret._then(promise._progress, null, null, promise, void 0,
+ this._progress);
+ }
+ else {
+ promise._progress(ret);
+ }
+ };
+
+
+ Promise.prototype._progressUnchecked =
+ function Promise$_progressUnchecked(progressValue) {
+ if (!this.isPending()) return;
+ var len = this._length();
+
+ for (var i = 0; i < len; i += 5) {
+ var handler = this._progressHandlerAt(i);
+ var promise = this._promiseAt(i);
+ if (!Promise.is(promise)) {
+ var receiver = this._receiverAt(i);
+ if (typeof handler === "function") {
+ handler.call(receiver, progressValue, promise);
+ }
+ else if (Promise.is(receiver) && receiver._isProxied()) {
+ receiver._progressUnchecked(progressValue);
+ }
+ else if (isPromiseArrayProxy(receiver, promise)) {
+ receiver._promiseProgressed(progressValue, promise);
+ }
+ continue;
+ }
+
+ if (typeof handler === "function") {
+ this._doProgressWith(({handler: handler,
+promise: promise,
+receiver: this._receiverAt(i),
+value: progressValue}));
+ }
+ else {
+ promise._progress(progressValue);
+ }
+ }
+ };
+};
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/zalgo/promise.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise.js
new file mode 100644
index 0000000..f1c9ddc
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise.js
@@ -0,0 +1,1167 @@
+/**
+ * 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 global = require("./global.js");
+var util = require("./util.js");
+var async = require("./async.js");
+var errors = require("./errors.js");
+
+var INTERNAL = function(){};
+var APPLY = {};
+var NEXT_FILTER = {e: null};
+
+var PromiseArray = require("./promise_array.js")(Promise, INTERNAL);
+var CapturedTrace = require("./captured_trace.js")();
+var CatchFilter = require("./catch_filter.js")(NEXT_FILTER);
+var PromiseResolver = require("./promise_resolver.js");
+
+var isArray = util.isArray;
+
+var errorObj = util.errorObj;
+var tryCatch1 = util.tryCatch1;
+var tryCatch2 = util.tryCatch2;
+var tryCatchApply = util.tryCatchApply;
+var RangeError = errors.RangeError;
+var TypeError = errors.TypeError;
+var CancellationError = errors.CancellationError;
+var TimeoutError = errors.TimeoutError;
+var RejectionError = errors.RejectionError;
+var originatesFromRejection = errors.originatesFromRejection;
+var markAsOriginatingFromRejection = errors.markAsOriginatingFromRejection;
+var canAttach = errors.canAttach;
+var thrower = util.thrower;
+var apiRejection = require("./errors_api_rejection")(Promise);
+
+
+var makeSelfResolutionError = function Promise$_makeSelfResolutionError() {
+ return new TypeError("circular promise resolution chain");
+};
+
+function isPromise(obj) {
+ if (obj === void 0) return false;
+ return obj instanceof Promise;
+}
+
+function isPromiseArrayProxy(receiver, promiseSlotValue) {
+ if (receiver instanceof PromiseArray) {
+ return promiseSlotValue >= 0;
+ }
+ return false;
+}
+
+function Promise(resolver) {
+ if (typeof resolver !== "function") {
+ throw new TypeError("the promise constructor requires a resolver function");
+ }
+ if (this.constructor !== Promise) {
+ throw new TypeError("the promise constructor cannot be invoked directly");
+ }
+ this._bitField = 0;
+ this._fulfillmentHandler0 = void 0;
+ this._rejectionHandler0 = void 0;
+ this._promise0 = void 0;
+ this._receiver0 = void 0;
+ this._settledValue = void 0;
+ this._boundTo = void 0;
+ if (resolver !== INTERNAL) this._resolveFromResolver(resolver);
+}
+
+Promise.prototype.bind = function Promise$bind(thisArg) {
+ var ret = new Promise(INTERNAL);
+ if (debugging) ret._setTrace(this.bind, this);
+ ret._follow(this);
+ ret._setBoundTo(thisArg);
+ if (this._cancellable()) {
+ ret._setCancellable();
+ ret._cancellationParent = this;
+ }
+ return ret;
+};
+
+Promise.prototype.toString = function Promise$toString() {
+ return "[object Promise]";
+};
+
+Promise.prototype.caught = Promise.prototype["catch"] =
+function Promise$catch(fn) {
+ var len = arguments.length;
+ if (len > 1) {
+ var catchInstances = new Array(len - 1),
+ j = 0, i;
+ for (i = 0; i < len - 1; ++i) {
+ var item = arguments[i];
+ if (typeof item === "function") {
+ catchInstances[j++] = item;
+ }
+ else {
+ var catchFilterTypeError =
+ new TypeError(
+ "A catch filter must be an error constructor "
+ + "or a filter function");
+
+ this._attachExtraTrace(catchFilterTypeError);
+ this._reject(catchFilterTypeError);
+ return;
+ }
+ }
+ catchInstances.length = j;
+ fn = arguments[i];
+
+ this._resetTrace(this.caught);
+ var catchFilter = new CatchFilter(catchInstances, fn, this);
+ return this._then(void 0, catchFilter.doFilter, void 0,
+ catchFilter, void 0, this.caught);
+ }
+ return this._then(void 0, fn, void 0, void 0, void 0, this.caught);
+};
+
+Promise.prototype.then =
+function Promise$then(didFulfill, didReject, didProgress) {
+ return this._then(didFulfill, didReject, didProgress,
+ void 0, void 0, this.then);
+};
+
+
+Promise.prototype.done =
+function Promise$done(didFulfill, didReject, didProgress) {
+ var promise = this._then(didFulfill, didReject, didProgress,
+ void 0, void 0, this.done);
+ promise._setIsFinal();
+};
+
+Promise.prototype.spread = function Promise$spread(didFulfill, didReject) {
+ return this._then(didFulfill, didReject, void 0,
+ APPLY, void 0, this.spread);
+};
+
+Promise.prototype.isFulfilled = function Promise$isFulfilled() {
+ return (this._bitField & 268435456) > 0;
+};
+
+
+Promise.prototype.isRejected = function Promise$isRejected() {
+ return (this._bitField & 134217728) > 0;
+};
+
+Promise.prototype.isPending = function Promise$isPending() {
+ return !this.isResolved();
+};
+
+
+Promise.prototype.isResolved = function Promise$isResolved() {
+ return (this._bitField & 402653184) > 0;
+};
+
+
+Promise.prototype.isCancellable = function Promise$isCancellable() {
+ return !this.isResolved() &&
+ this._cancellable();
+};
+
+Promise.prototype.toJSON = function Promise$toJSON() {
+ var ret = {
+ isFulfilled: false,
+ isRejected: false,
+ fulfillmentValue: void 0,
+ rejectionReason: void 0
+ };
+ if (this.isFulfilled()) {
+ ret.fulfillmentValue = this._settledValue;
+ ret.isFulfilled = true;
+ }
+ else if (this.isRejected()) {
+ ret.rejectionReason = this._settledValue;
+ ret.isRejected = true;
+ }
+ return ret;
+};
+
+Promise.prototype.all = function Promise$all() {
+ return Promise$_all(this, true, this.all);
+};
+
+
+Promise.is = isPromise;
+
+function Promise$_all(promises, useBound, caller) {
+ return Promise$_CreatePromiseArray(
+ promises,
+ PromiseArray,
+ caller,
+ useBound === true && promises._isBound()
+ ? promises._boundTo
+ : void 0
+ ).promise();
+}
+Promise.all = function Promise$All(promises) {
+ return Promise$_all(promises, false, Promise.all);
+};
+
+Promise.join = function Promise$Join() {
+ var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
+ return Promise$_CreatePromiseArray(
+ args, PromiseArray, Promise.join, void 0).promise();
+};
+
+Promise.resolve = Promise.fulfilled =
+function Promise$Resolve(value, caller) {
+ var ret = new Promise(INTERNAL);
+ if (debugging) ret._setTrace(typeof caller === "function"
+ ? caller
+ : Promise.resolve, void 0);
+ if (ret._tryFollow(value)) {
+ return ret;
+ }
+ ret._cleanValues();
+ ret._setFulfilled();
+ ret._settledValue = value;
+ return ret;
+};
+
+Promise.reject = Promise.rejected = function Promise$Reject(reason) {
+ var ret = new Promise(INTERNAL);
+ if (debugging) ret._setTrace(Promise.reject, void 0);
+ markAsOriginatingFromRejection(reason);
+ ret._cleanValues();
+ ret._setRejected();
+ ret._settledValue = reason;
+ if (!canAttach(reason)) {
+ var trace = new Error(reason + "");
+ ret._setCarriedStackTrace(trace);
+ }
+ ret._ensurePossibleRejectionHandled();
+ return ret;
+};
+
+Promise.prototype.error = function Promise$_error(fn) {
+ return this.caught(originatesFromRejection, fn);
+};
+
+Promise.prototype._resolveFromSyncValue =
+function Promise$_resolveFromSyncValue(value, caller) {
+ if (value === errorObj) {
+ this._cleanValues();
+ this._setRejected();
+ this._settledValue = value.e;
+ this._ensurePossibleRejectionHandled();
+ }
+ else {
+ var maybePromise = Promise._cast(value, caller, void 0);
+ if (maybePromise instanceof Promise) {
+ this._follow(maybePromise);
+ }
+ else {
+ this._cleanValues();
+ this._setFulfilled();
+ this._settledValue = value;
+ }
+ }
+};
+
+Promise.method = function Promise$_Method(fn) {
+ if (typeof fn !== "function") {
+ throw new TypeError("fn must be a function");
+ }
+ return function Promise$_method() {
+ var value;
+ switch(arguments.length) {
+ case 0: value = tryCatch1(fn, this, void 0); break;
+ case 1: value = tryCatch1(fn, this, arguments[0]); break;
+ case 2: value = tryCatch2(fn, this, arguments[0], arguments[1]); break;
+ default:
+ var $_len = arguments.length;var args = new Array($_len); for(var $_i = 0; $_i < $_len; ++$_i) {args[$_i] = arguments[$_i];}
+ value = tryCatchApply(fn, args, this); break;
+ }
+ var ret = new Promise(INTERNAL);
+ if (debugging) ret._setTrace(Promise$_method, void 0);
+ ret._resolveFromSyncValue(value, Promise$_method);
+ return ret;
+ };
+};
+
+Promise.attempt = Promise["try"] = function Promise$_Try(fn, args, ctx) {
+
+ if (typeof fn !== "function") {
+ return apiRejection("fn must be a function");
+ }
+ var value = isArray(args)
+ ? tryCatchApply(fn, args, ctx)
+ : tryCatch1(fn, ctx, args);
+
+ var ret = new Promise(INTERNAL);
+ if (debugging) ret._setTrace(Promise.attempt, void 0);
+ ret._resolveFromSyncValue(value, Promise.attempt);
+ return ret;
+};
+
+Promise.defer = Promise.pending = function Promise$Defer(caller) {
+ var promise = new Promise(INTERNAL);
+ if (debugging) promise._setTrace(typeof caller === "function"
+ ? caller : Promise.defer, void 0);
+ return new PromiseResolver(promise);
+};
+
+Promise.bind = function Promise$Bind(thisArg) {
+ var ret = new Promise(INTERNAL);
+ if (debugging) ret._setTrace(Promise.bind, void 0);
+ ret._setFulfilled();
+ ret._setBoundTo(thisArg);
+ return ret;
+};
+
+Promise.cast = function Promise$_Cast(obj, caller) {
+ if (typeof caller !== "function") {
+ caller = Promise.cast;
+ }
+ var ret = Promise._cast(obj, caller, void 0);
+ if (!(ret instanceof Promise)) {
+ return Promise.resolve(ret, caller);
+ }
+ return ret;
+};
+
+Promise.onPossiblyUnhandledRejection =
+function Promise$OnPossiblyUnhandledRejection(fn) {
+ if (typeof fn === "function") {
+ CapturedTrace.possiblyUnhandledRejection = fn;
+ }
+ else {
+ CapturedTrace.possiblyUnhandledRejection = void 0;
+ }
+};
+
+var debugging = false || !!(
+ typeof process !== "undefined" &&
+ typeof process.execPath === "string" &&
+ typeof process.env === "object" &&
+ (process.env["BLUEBIRD_DEBUG"] ||
+ process.env["NODE_ENV"] === "development")
+);
+
+
+Promise.longStackTraces = function Promise$LongStackTraces() {
+ if (async.haveItemsQueued() &&
+ debugging === false
+ ) {
+ throw new Error("cannot enable long stack traces after promises have been created");
+ }
+ debugging = CapturedTrace.isSupported();
+};
+
+Promise.hasLongStackTraces = function Promise$HasLongStackTraces() {
+ return debugging && CapturedTrace.isSupported();
+};
+
+Promise.prototype._setProxyHandlers =
+function Promise$_setProxyHandlers(receiver, promiseSlotValue) {
+ var index = this._length();
+
+ if (index >= 1048575 - 5) {
+ index = 0;
+ this._setLength(0);
+ }
+ if (index === 0) {
+ this._promise0 = promiseSlotValue;
+ this._receiver0 = receiver;
+ }
+ else {
+ var i = index - 5;
+ this[i + 3] = promiseSlotValue;
+ this[i + 4] = receiver;
+ this[i + 0] =
+ this[i + 1] =
+ this[i + 2] = void 0;
+ }
+ this._setLength(index + 5);
+};
+
+Promise.prototype._proxyPromiseArray =
+function Promise$_proxyPromiseArray(promiseArray, index) {
+ this._setProxyHandlers(promiseArray, index);
+};
+
+Promise.prototype._proxyPromise = function Promise$_proxyPromise(promise) {
+ promise._setProxied();
+ this._setProxyHandlers(promise, -1);
+};
+
+Promise.prototype._then =
+function Promise$_then(
+ didFulfill,
+ didReject,
+ didProgress,
+ receiver,
+ internalData,
+ caller
+) {
+ var haveInternalData = internalData !== void 0;
+ var ret = haveInternalData ? internalData : new Promise(INTERNAL);
+
+ if (debugging && !haveInternalData) {
+ var haveSameContext = this._peekContext() === this._traceParent;
+ ret._traceParent = haveSameContext ? this._traceParent : this;
+ ret._setTrace(typeof caller === "function"
+ ? caller
+ : this._then, this);
+ }
+
+ if (!haveInternalData && this._isBound()) {
+ ret._setBoundTo(this._boundTo);
+ }
+
+ var callbackIndex =
+ this._addCallbacks(didFulfill, didReject, didProgress, ret, receiver);
+
+ if (!haveInternalData && this._cancellable()) {
+ ret._setCancellable();
+ ret._cancellationParent = this;
+ }
+
+ if (this.isResolved()) {
+ this._queueSettleAt(callbackIndex);
+ }
+
+ return ret;
+};
+
+Promise.prototype._length = function Promise$_length() {
+ return this._bitField & 1048575;
+};
+
+Promise.prototype._isFollowingOrFulfilledOrRejected =
+function Promise$_isFollowingOrFulfilledOrRejected() {
+ return (this._bitField & 939524096) > 0;
+};
+
+Promise.prototype._isFollowing = function Promise$_isFollowing() {
+ return (this._bitField & 536870912) === 536870912;
+};
+
+Promise.prototype._setLength = function Promise$_setLength(len) {
+ this._bitField = (this._bitField & -1048576) |
+ (len & 1048575);
+};
+
+Promise.prototype._setFulfilled = function Promise$_setFulfilled() {
+ this._bitField = this._bitField | 268435456;
+};
+
+Promise.prototype._setRejected = function Promise$_setRejected() {
+ this._bitField = this._bitField | 134217728;
+};
+
+Promise.prototype._setFollowing = function Promise$_setFollowing() {
+ this._bitField = this._bitField | 536870912;
+};
+
+Promise.prototype._setIsFinal = function Promise$_setIsFinal() {
+ this._bitField = this._bitField | 33554432;
+};
+
+Promise.prototype._isFinal = function Promise$_isFinal() {
+ return (this._bitField & 33554432) > 0;
+};
+
+Promise.prototype._cancellable = function Promise$_cancellable() {
+ return (this._bitField & 67108864) > 0;
+};
+
+Promise.prototype._setCancellable = function Promise$_setCancellable() {
+ this._bitField = this._bitField | 67108864;
+};
+
+Promise.prototype._unsetCancellable = function Promise$_unsetCancellable() {
+ this._bitField = this._bitField & (~67108864);
+};
+
+Promise.prototype._setRejectionIsUnhandled =
+function Promise$_setRejectionIsUnhandled() {
+ this._bitField = this._bitField | 2097152;
+};
+
+Promise.prototype._unsetRejectionIsUnhandled =
+function Promise$_unsetRejectionIsUnhandled() {
+ this._bitField = this._bitField & (~2097152);
+};
+
+Promise.prototype._isRejectionUnhandled =
+function Promise$_isRejectionUnhandled() {
+ return (this._bitField & 2097152) > 0;
+};
+
+Promise.prototype._setCarriedStackTrace =
+function Promise$_setCarriedStackTrace(capturedTrace) {
+ this._bitField = this._bitField | 1048576;
+ this._fulfillmentHandler0 = capturedTrace;
+};
+
+Promise.prototype._unsetCarriedStackTrace =
+function Promise$_unsetCarriedStackTrace() {
+ this._bitField = this._bitField & (~1048576);
+ this._fulfillmentHandler0 = void 0;
+};
+
+Promise.prototype._isCarryingStackTrace =
+function Promise$_isCarryingStackTrace() {
+ return (this._bitField & 1048576) > 0;
+};
+
+Promise.prototype._getCarriedStackTrace =
+function Promise$_getCarriedStackTrace() {
+ return this._isCarryingStackTrace()
+ ? this._fulfillmentHandler0
+ : void 0;
+};
+
+Promise.prototype._receiverAt = function Promise$_receiverAt(index) {
+ var ret;
+ if (index === 0) {
+ ret = this._receiver0;
+ }
+ else {
+ ret = this[index + 4 - 5];
+ }
+ if (this._isBound() && ret === void 0) {
+ return this._boundTo;
+ }
+ return ret;
+};
+
+Promise.prototype._promiseAt = function Promise$_promiseAt(index) {
+ if (index === 0) return this._promise0;
+ return this[index + 3 - 5];
+};
+
+Promise.prototype._fulfillmentHandlerAt =
+function Promise$_fulfillmentHandlerAt(index) {
+ if (index === 0) return this._fulfillmentHandler0;
+ return this[index + 0 - 5];
+};
+
+Promise.prototype._rejectionHandlerAt =
+function Promise$_rejectionHandlerAt(index) {
+ if (index === 0) return this._rejectionHandler0;
+ return this[index + 1 - 5];
+};
+
+Promise.prototype._unsetAt = function Promise$_unsetAt(index) {
+ if (index === 0) {
+ this._rejectionHandler0 =
+ this._progressHandler0 =
+ this._promise0 =
+ this._receiver0 = void 0;
+ if (!this._isCarryingStackTrace()) {
+ this._fulfillmentHandler0 = void 0;
+ }
+ }
+ else {
+ this[index - 5 + 0] =
+ this[index - 5 + 1] =
+ this[index - 5 + 2] =
+ this[index - 5 + 3] =
+ this[index - 5 + 4] = void 0;
+ }
+};
+
+Promise.prototype._resolveFromResolver =
+function Promise$_resolveFromResolver(resolver) {
+ var promise = this;
+ var localDebugging = debugging;
+ if (localDebugging) {
+ this._setTrace(this._resolveFromResolver, void 0);
+ this._pushContext();
+ }
+ function Promise$_resolver(val) {
+ if (promise._tryFollow(val)) {
+ return;
+ }
+ promise._fulfill(val);
+ }
+ function Promise$_rejecter(val) {
+ var trace = canAttach(val) ? val : new Error(val + "");
+ promise._attachExtraTrace(trace);
+ markAsOriginatingFromRejection(val);
+ promise._reject(val, trace === val ? void 0 : trace);
+ }
+ var r = tryCatch2(resolver, void 0, Promise$_resolver, Promise$_rejecter);
+ if (localDebugging) this._popContext();
+
+ if (r !== void 0 && r === errorObj) {
+ var e = r.e;
+ var trace = canAttach(e) ? e : new Error(e + "");
+ promise._reject(e, trace);
+ }
+};
+
+Promise.prototype._addCallbacks = function Promise$_addCallbacks(
+ fulfill,
+ reject,
+ progress,
+ promise,
+ receiver
+) {
+ var index = this._length();
+
+ if (index >= 1048575 - 5) {
+ index = 0;
+ this._setLength(0);
+ }
+
+ if (index === 0) {
+ this._promise0 = promise;
+ if (receiver !== void 0) this._receiver0 = receiver;
+ if (typeof fulfill === "function" && !this._isCarryingStackTrace())
+ this._fulfillmentHandler0 = fulfill;
+ if (typeof reject === "function") this._rejectionHandler0 = reject;
+ if (typeof progress === "function") this._progressHandler0 = progress;
+ }
+ else {
+ var i = index - 5;
+ this[i + 3] = promise;
+ this[i + 4] = receiver;
+ this[i + 0] = typeof fulfill === "function"
+ ? fulfill : void 0;
+ this[i + 1] = typeof reject === "function"
+ ? reject : void 0;
+ this[i + 2] = typeof progress === "function"
+ ? progress : void 0;
+ }
+ this._setLength(index + 5);
+ return index;
+};
+
+
+
+Promise.prototype._setBoundTo = function Promise$_setBoundTo(obj) {
+ if (obj !== void 0) {
+ this._bitField = this._bitField | 8388608;
+ this._boundTo = obj;
+ }
+ else {
+ this._bitField = this._bitField & (~8388608);
+ }
+};
+
+Promise.prototype._isBound = function Promise$_isBound() {
+ return (this._bitField & 8388608) === 8388608;
+};
+
+Promise.prototype._spreadSlowCase =
+function Promise$_spreadSlowCase(targetFn, promise, values, boundTo) {
+ var promiseForAll =
+ Promise$_CreatePromiseArray
+ (values, PromiseArray, this._spreadSlowCase, boundTo)
+ .promise()
+ ._then(function() {
+ return targetFn.apply(boundTo, arguments);
+ }, void 0, void 0, APPLY, void 0, this._spreadSlowCase);
+
+ promise._follow(promiseForAll);
+};
+
+Promise.prototype._callSpread =
+function Promise$_callSpread(handler, promise, value, localDebugging) {
+ var boundTo = this._isBound() ? this._boundTo : void 0;
+ if (isArray(value)) {
+ var caller = this._settlePromiseFromHandler;
+ for (var i = 0, len = value.length; i < len; ++i) {
+ if (isPromise(Promise._cast(value[i], caller, void 0))) {
+ this._spreadSlowCase(handler, promise, value, boundTo);
+ return;
+ }
+ }
+ }
+ if (localDebugging) promise._pushContext();
+ return tryCatchApply(handler, value, boundTo);
+};
+
+Promise.prototype._callHandler =
+function Promise$_callHandler(
+ handler, receiver, promise, value, localDebugging) {
+ var x;
+ if (receiver === APPLY && !this.isRejected()) {
+ x = this._callSpread(handler, promise, value, localDebugging);
+ }
+ else {
+ if (localDebugging) promise._pushContext();
+ x = tryCatch1(handler, receiver, value);
+ }
+ if (localDebugging) promise._popContext();
+ return x;
+};
+
+Promise.prototype._settlePromiseFromHandler =
+function Promise$_settlePromiseFromHandler(
+ handler, receiver, value, promise
+) {
+ if (!isPromise(promise)) {
+ handler.call(receiver, value, promise);
+ return;
+ }
+
+ var localDebugging = debugging;
+ var x = this._callHandler(handler, receiver,
+ promise, value, localDebugging);
+
+ if (promise._isFollowing()) return;
+
+ if (x === errorObj || x === promise || x === NEXT_FILTER) {
+ var err = x === promise
+ ? makeSelfResolutionError()
+ : x.e;
+ var trace = canAttach(err) ? err : new Error(err + "");
+ if (x !== NEXT_FILTER) promise._attachExtraTrace(trace);
+ promise._rejectUnchecked(err, trace);
+ }
+ else {
+ var castValue = Promise._cast(x,
+ localDebugging ? this._settlePromiseFromHandler : void 0,
+ promise);
+
+ if (isPromise(castValue)) {
+ if (castValue.isRejected() &&
+ !castValue._isCarryingStackTrace() &&
+ !canAttach(castValue._settledValue)) {
+ var trace = new Error(castValue._settledValue + "");
+ promise._attachExtraTrace(trace);
+ castValue._setCarriedStackTrace(trace);
+ }
+ promise._follow(castValue);
+ if (castValue._cancellable()) {
+ promise._cancellationParent = castValue;
+ promise._setCancellable();
+ }
+ }
+ else {
+ promise._fulfillUnchecked(x);
+ }
+ }
+};
+
+Promise.prototype._follow =
+function Promise$_follow(promise) {
+ this._setFollowing();
+
+ if (promise.isPending()) {
+ if (promise._cancellable() ) {
+ this._cancellationParent = promise;
+ this._setCancellable();
+ }
+ promise._proxyPromise(this);
+ }
+ else if (promise.isFulfilled()) {
+ this._fulfillUnchecked(promise._settledValue);
+ }
+ else {
+ this._rejectUnchecked(promise._settledValue,
+ promise._getCarriedStackTrace());
+ }
+
+ if (promise._isRejectionUnhandled()) promise._unsetRejectionIsUnhandled();
+
+ if (debugging &&
+ promise._traceParent == null) {
+ promise._traceParent = this;
+ }
+};
+
+Promise.prototype._tryFollow =
+function Promise$_tryFollow(value) {
+ if (this._isFollowingOrFulfilledOrRejected() ||
+ value === this) {
+ return false;
+ }
+ var maybePromise = Promise._cast(value, this._tryFollow, void 0);
+ if (!isPromise(maybePromise)) {
+ return false;
+ }
+ this._follow(maybePromise);
+ return true;
+};
+
+Promise.prototype._resetTrace = function Promise$_resetTrace(caller) {
+ if (debugging) {
+ var context = this._peekContext();
+ var isTopLevel = context === void 0;
+ this._trace = new CapturedTrace(
+ typeof caller === "function"
+ ? caller
+ : this._resetTrace,
+ isTopLevel
+ );
+ }
+};
+
+Promise.prototype._setTrace = function Promise$_setTrace(caller, parent) {
+ if (debugging) {
+ var context = this._peekContext();
+ this._traceParent = context;
+ var isTopLevel = context === void 0;
+ if (parent !== void 0 &&
+ parent._traceParent === context) {
+ this._trace = parent._trace;
+ }
+ else {
+ this._trace = new CapturedTrace(
+ typeof caller === "function"
+ ? caller
+ : this._setTrace,
+ isTopLevel
+ );
+ }
+ }
+ return this;
+};
+
+Promise.prototype._attachExtraTrace =
+function Promise$_attachExtraTrace(error) {
+ if (debugging) {
+ var promise = this;
+ var stack = error.stack;
+ stack = typeof stack === "string"
+ ? stack.split("\n") : [];
+ var headerLineCount = 1;
+
+ while(promise != null &&
+ promise._trace != null) {
+ stack = CapturedTrace.combine(
+ stack,
+ promise._trace.stack.split("\n")
+ );
+ promise = promise._traceParent;
+ }
+
+ var max = Error.stackTraceLimit + headerLineCount;
+ var len = stack.length;
+ if (len > max) {
+ stack.length = max;
+ }
+ if (stack.length <= headerLineCount) {
+ error.stack = "(No stack trace)";
+ }
+ else {
+ error.stack = stack.join("\n");
+ }
+ }
+};
+
+Promise.prototype._cleanValues = function Promise$_cleanValues() {
+ if (this._cancellable()) {
+ this._cancellationParent = void 0;
+ }
+};
+
+Promise.prototype._fulfill = function Promise$_fulfill(value) {
+ if (this._isFollowingOrFulfilledOrRejected()) return;
+ this._fulfillUnchecked(value);
+};
+
+Promise.prototype._reject =
+function Promise$_reject(reason, carriedStackTrace) {
+ if (this._isFollowingOrFulfilledOrRejected()) return;
+ this._rejectUnchecked(reason, carriedStackTrace);
+};
+
+Promise.prototype._settlePromiseAt = function Promise$_settlePromiseAt(index) {
+ var handler = this.isFulfilled()
+ ? this._fulfillmentHandlerAt(index)
+ : this._rejectionHandlerAt(index);
+
+ var value = this._settledValue;
+ var receiver = this._receiverAt(index);
+ var promise = this._promiseAt(index);
+
+ if (typeof handler === "function") {
+ this._settlePromiseFromHandler(handler, receiver, value, promise);
+ }
+ else {
+ var done = false;
+ var isFulfilled = this.isFulfilled();
+ if (receiver !== void 0) {
+ if (receiver instanceof Promise &&
+ receiver._isProxied()) {
+ receiver._unsetProxied();
+
+ if (isFulfilled) receiver._fulfillUnchecked(value);
+ else receiver._rejectUnchecked(value,
+ this._getCarriedStackTrace());
+ done = true;
+ }
+ else if (isPromiseArrayProxy(receiver, promise)) {
+
+ if (isFulfilled) receiver._promiseFulfilled(value, promise);
+ else receiver._promiseRejected(value, promise);
+
+ done = true;
+ }
+ }
+
+ if (!done) {
+
+ if (isFulfilled) promise._fulfill(value);
+ else promise._reject(value, this._getCarriedStackTrace());
+
+ }
+ }
+
+ if (index >= 256) {
+ this._queueGC();
+ }
+};
+
+Promise.prototype._isProxied = function Promise$_isProxied() {
+ return (this._bitField & 4194304) === 4194304;
+};
+
+Promise.prototype._setProxied = function Promise$_setProxied() {
+ this._bitField = this._bitField | 4194304;
+};
+
+Promise.prototype._unsetProxied = function Promise$_unsetProxied() {
+ this._bitField = this._bitField & (~4194304);
+};
+
+Promise.prototype._isGcQueued = function Promise$_isGcQueued() {
+ return (this._bitField & -1073741824) === -1073741824;
+};
+
+Promise.prototype._setGcQueued = function Promise$_setGcQueued() {
+ this._bitField = this._bitField | -1073741824;
+};
+
+Promise.prototype._unsetGcQueued = function Promise$_unsetGcQueued() {
+ this._bitField = this._bitField & (~-1073741824);
+};
+
+Promise.prototype._queueGC = function Promise$_queueGC() {
+ if (this._isGcQueued()) return;
+ this._setGcQueued();
+ async.invokeLater(this._gc, this, void 0);
+};
+
+Promise.prototype._gc = function Promise$gc() {
+ var len = this._length();
+ this._unsetAt(0);
+ for (var i = 0; i < len; i++) {
+ delete this[i];
+ }
+ this._setLength(0);
+ this._unsetGcQueued();
+};
+
+Promise.prototype._queueSettleAt = function Promise$_queueSettleAt(index) {
+ if (this._isRejectionUnhandled()) this._unsetRejectionIsUnhandled();
+ this._settlePromiseAt(index);
+};
+
+Promise.prototype._fulfillUnchecked =
+function Promise$_fulfillUnchecked(value) {
+ if (!this.isPending()) return;
+ if (value === this) {
+ var err = makeSelfResolutionError();
+ this._attachExtraTrace(err);
+ return this._rejectUnchecked(err, void 0);
+ }
+ this._cleanValues();
+ this._setFulfilled();
+ this._settledValue = value;
+ var len = this._length();
+
+ if (len > 0) {
+ this._fulfillPromises(len);
+ }
+};
+
+Promise.prototype._rejectUncheckedCheckError =
+function Promise$_rejectUncheckedCheckError(reason) {
+ var trace = canAttach(reason) ? reason : new Error(reason + "");
+ this._rejectUnchecked(reason, trace === reason ? void 0 : trace);
+};
+
+Promise.prototype._rejectUnchecked =
+function Promise$_rejectUnchecked(reason, trace) {
+ if (!this.isPending()) return;
+ if (reason === this) {
+ var err = makeSelfResolutionError();
+ this._attachExtraTrace(err);
+ return this._rejectUnchecked(err);
+ }
+ this._cleanValues();
+ this._setRejected();
+ this._settledValue = reason;
+
+ if (this._isFinal()) {
+ async.invokeLater(thrower, void 0, trace === void 0 ? reason : trace);
+ return;
+ }
+ var len = this._length();
+
+ if (trace !== void 0) this._setCarriedStackTrace(trace);
+
+ if (len > 0) {
+ this._rejectPromises(null);
+ }
+ else {
+ this._ensurePossibleRejectionHandled();
+ }
+};
+
+Promise.prototype._rejectPromises = function Promise$_rejectPromises() {
+ var len = this._length();
+ for (var i = 0; i < len; i+= 5) {
+ this._settlePromiseAt(i);
+ }
+ this._unsetCarriedStackTrace();
+};
+
+Promise.prototype._fulfillPromises = function Promise$_fulfillPromises(len) {
+ len = this._length();
+ for (var i = 0; i < len; i+= 5) {
+ this._settlePromiseAt(i);
+ }
+};
+
+Promise.prototype._ensurePossibleRejectionHandled =
+function Promise$_ensurePossibleRejectionHandled() {
+ this._setRejectionIsUnhandled();
+ if (CapturedTrace.possiblyUnhandledRejection !== void 0) {
+ async.invokeLater(this._notifyUnhandledRejection, this, void 0);
+ }
+};
+
+Promise.prototype._notifyUnhandledRejection =
+function Promise$_notifyUnhandledRejection() {
+ if (this._isRejectionUnhandled()) {
+ var reason = this._settledValue;
+ var trace = this._getCarriedStackTrace();
+
+ this._unsetRejectionIsUnhandled();
+
+ if (trace !== void 0) {
+ this._unsetCarriedStackTrace();
+ reason = trace;
+ }
+ if (typeof CapturedTrace.possiblyUnhandledRejection === "function") {
+ CapturedTrace.possiblyUnhandledRejection(reason, this);
+ }
+ }
+};
+
+var contextStack = [];
+Promise.prototype._peekContext = function Promise$_peekContext() {
+ var lastIndex = contextStack.length - 1;
+ if (lastIndex >= 0) {
+ return contextStack[lastIndex];
+ }
+ return void 0;
+
+};
+
+Promise.prototype._pushContext = function Promise$_pushContext() {
+ if (!debugging) return;
+ contextStack.push(this);
+};
+
+Promise.prototype._popContext = function Promise$_popContext() {
+ if (!debugging) return;
+ contextStack.pop();
+};
+
+function Promise$_CreatePromiseArray(
+ promises, PromiseArrayConstructor, caller, boundTo) {
+
+ var list = null;
+ if (isArray(promises)) {
+ list = promises;
+ }
+ else {
+ list = Promise._cast(promises, caller, void 0);
+ if (list !== promises) {
+ list._setBoundTo(boundTo);
+ }
+ else if (!isPromise(list)) {
+ list = null;
+ }
+ }
+ if (list !== null) {
+ return new PromiseArrayConstructor(
+ list,
+ typeof caller === "function"
+ ? caller
+ : Promise$_CreatePromiseArray,
+ boundTo
+ );
+ }
+ return {
+ promise: function() {return apiRejection("expecting an array, a promise or a thenable");}
+ };
+}
+
+var old = global.Promise;
+
+Promise.noConflict = function() {
+ if (global.Promise === Promise) {
+ global.Promise = old;
+ }
+ return Promise;
+};
+
+if (!CapturedTrace.isSupported()) {
+ Promise.longStackTraces = function(){};
+ debugging = false;
+}
+
+Promise._makeSelfResolutionError = makeSelfResolutionError;
+require("./finally.js")(Promise, NEXT_FILTER);
+require("./direct_resolve.js")(Promise);
+require("./thenables.js")(Promise, INTERNAL);
+Promise.RangeError = RangeError;
+Promise.CancellationError = CancellationError;
+Promise.TimeoutError = TimeoutError;
+Promise.TypeError = TypeError;
+Promise.RejectionError = RejectionError;
+
+util.toFastProperties(Promise);
+util.toFastProperties(Promise.prototype);
+require('./timers.js')(Promise,INTERNAL);
+require('./synchronous_inspection.js')(Promise);
+require('./any.js')(Promise,Promise$_CreatePromiseArray,PromiseArray);
+require('./race.js')(Promise,INTERNAL);
+require('./call_get.js')(Promise);
+require('./filter.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection);
+require('./generators.js')(Promise,apiRejection,INTERNAL);
+require('./map.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection);
+require('./nodeify.js')(Promise);
+require('./promisify.js')(Promise,INTERNAL);
+require('./props.js')(Promise,PromiseArray);
+require('./reduce.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection,INTERNAL);
+require('./settle.js')(Promise,Promise$_CreatePromiseArray,PromiseArray);
+require('./some.js')(Promise,Promise$_CreatePromiseArray,PromiseArray,apiRejection);
+require('./progress.js')(Promise,isPromiseArrayProxy);
+require('./cancel.js')(Promise,INTERNAL);
+
+Promise.prototype = Promise.prototype;
+return Promise;
+
+};
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/zalgo/promise_array.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_array.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_array.js
new file mode 100644
index 0000000..6d43606
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_array.js
@@ -0,0 +1,233 @@
+/**
+ * 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, INTERNAL) {
+var canAttach = require("./errors.js").canAttach;
+var util = require("./util.js");
+var async = require("./async.js");
+var hasOwn = {}.hasOwnProperty;
+var isArray = util.isArray;
+
+function toResolutionValue(val) {
+ switch(val) {
+ case -1: return void 0;
+ case -2: return [];
+ case -3: return {};
+ }
+}
+
+function PromiseArray(values, caller, boundTo) {
+ var promise = this._promise = new Promise(INTERNAL);
+ var parent = void 0;
+ if (Promise.is(values)) {
+ parent = values;
+ if (values._cancellable()) {
+ promise._setCancellable();
+ promise._cancellationParent = values;
+ }
+ if (values._isBound()) {
+ promise._setBoundTo(boundTo);
+ }
+ }
+ promise._setTrace(caller, parent);
+ this._values = values;
+ this._length = 0;
+ this._totalResolved = 0;
+ this._init(void 0, -2);
+}
+PromiseArray.PropertiesPromiseArray = function() {};
+
+PromiseArray.prototype.length = function PromiseArray$length() {
+ return this._length;
+};
+
+PromiseArray.prototype.promise = function PromiseArray$promise() {
+ return this._promise;
+};
+
+PromiseArray.prototype._init =
+function PromiseArray$_init(_, resolveValueIfEmpty) {
+ var values = this._values;
+ if (Promise.is(values)) {
+ if (values.isFulfilled()) {
+ values = values._settledValue;
+ if (!isArray(values)) {
+ var err = new Promise.TypeError("expecting an array, a promise or a thenable");
+ this.__hardReject__(err);
+ return;
+ }
+ this._values = values;
+ }
+ else if (values.isPending()) {
+ values._then(
+ this._init,
+ this._reject,
+ void 0,
+ this,
+ resolveValueIfEmpty,
+ this.constructor
+ );
+ return;
+ }
+ else {
+ this._reject(values._settledValue);
+ return;
+ }
+ }
+
+ if (values.length === 0) {
+ this._resolve(toResolutionValue(resolveValueIfEmpty));
+ return;
+ }
+ var len = values.length;
+ var newLen = len;
+ var newValues;
+ if (this instanceof PromiseArray.PropertiesPromiseArray) {
+ newValues = this._values;
+ }
+ else {
+ newValues = new Array(len);
+ }
+ var isDirectScanNeeded = false;
+ for (var i = 0; i < len; ++i) {
+ var promise = values[i];
+ if (promise === void 0 && !hasOwn.call(values, i)) {
+ newLen--;
+ continue;
+ }
+ var maybePromise = Promise._cast(promise, void 0, void 0);
+ if (maybePromise instanceof Promise) {
+ if (maybePromise.isPending()) {
+ maybePromise._proxyPromiseArray(this, i);
+ }
+ else {
+ maybePromise._unsetRejectionIsUnhandled();
+ isDirectScanNeeded = true;
+ }
+ }
+ else {
+ isDirectScanNeeded = true;
+ }
+ newValues[i] = maybePromise;
+ }
+ if (newLen === 0) {
+ if (resolveValueIfEmpty === -2) {
+ this._resolve(newValues);
+ }
+ else {
+ this._resolve(toResolutionValue(resolveValueIfEmpty));
+ }
+ return;
+ }
+ this._values = newValues;
+ this._length = newLen;
+ if (isDirectScanNeeded) {
+ var scanMethod = newLen === len
+ ? this._scanDirectValues
+ : this._scanDirectValuesHoled;
+ scanMethod.call(this, len);
+ }
+};
+
+PromiseArray.prototype._settlePromiseAt =
+function PromiseArray$_settlePromiseAt(index) {
+ var value = this._values[index];
+ if (!Promise.is(value)) {
+ this._promiseFulfilled(value, index);
+ }
+ else if (value.isFulfilled()) {
+ this._promiseFulfilled(value._settledValue, index);
+ }
+ else if (value.isRejected()) {
+ this._promiseRejected(value._settledValue, index);
+ }
+};
+
+PromiseArray.prototype._scanDirectValuesHoled =
+function PromiseArray$_scanDirectValuesHoled(len) {
+ for (var i = 0; i < len; ++i) {
+ if (this._isResolved()) {
+ break;
+ }
+ if (hasOwn.call(this._values, i)) {
+ this._settlePromiseAt(i);
+ }
+ }
+};
+
+PromiseArray.prototype._scanDirectValues =
+function PromiseArray$_scanDirectValues(len) {
+ for (var i = 0; i < len; ++i) {
+ if (this._isResolved()) {
+ break;
+ }
+ this._settlePromiseAt(i);
+ }
+};
+
+PromiseArray.prototype._isResolved = function PromiseArray$_isResolved() {
+ return this._values === null;
+};
+
+PromiseArray.prototype._resolve = function PromiseArray$_resolve(value) {
+ this._values = null;
+ this._promise._fulfill(value);
+};
+
+PromiseArray.prototype.__hardReject__ =
+PromiseArray.prototype._reject = function PromiseArray$_reject(reason) {
+ this._values = null;
+ var trace = canAttach(reason) ? reason : new Error(reason + "");
+ this._promise._attachExtraTrace(trace);
+ this._promise._reject(reason, trace);
+};
+
+PromiseArray.prototype._promiseProgressed =
+function PromiseArray$_promiseProgressed(progressValue, index) {
+ if (this._isResolved()) return;
+ this._promise._progress({
+ index: index,
+ value: progressValue
+ });
+};
+
+
+PromiseArray.prototype._promiseFulfilled =
+function PromiseArray$_promiseFulfilled(value, index) {
+ if (this._isResolved()) return;
+ this._values[index] = value;
+ var totalResolved = ++this._totalResolved;
+ if (totalResolved >= this._length) {
+ this._resolve(this._values);
+ }
+};
+
+PromiseArray.prototype._promiseRejected =
+function PromiseArray$_promiseRejected(reason, index) {
+ if (this._isResolved()) return;
+ this._totalResolved++;
+ this._reject(reason);
+};
+
+return PromiseArray;
+};
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/zalgo/promise_inspection.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_inspection.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_inspection.js
new file mode 100644
index 0000000..0aa233b
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_inspection.js
@@ -0,0 +1,66 @@
+/**
+ * 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";
+var TypeError = require("./errors.js").TypeError;
+
+function PromiseInspection(promise) {
+ if (promise !== void 0) {
+ this._bitField = promise._bitField;
+ this._settledValue = promise.isResolved()
+ ? promise._settledValue
+ : void 0;
+ }
+ else {
+ this._bitField = 0;
+ this._settledValue = void 0;
+ }
+}
+PromiseInspection.prototype.isFulfilled =
+function PromiseInspection$isFulfilled() {
+ return (this._bitField & 268435456) > 0;
+};
+
+PromiseInspection.prototype.isRejected =
+function PromiseInspection$isRejected() {
+ return (this._bitField & 134217728) > 0;
+};
+
+PromiseInspection.prototype.isPending = function PromiseInspection$isPending() {
+ return (this._bitField & 402653184) === 0;
+};
+
+PromiseInspection.prototype.value = function PromiseInspection$value() {
+ if (!this.isFulfilled()) {
+ throw new TypeError("cannot get fulfillment value of a non-fulfilled promise");
+ }
+ return this._settledValue;
+};
+
+PromiseInspection.prototype.error = function PromiseInspection$error() {
+ if (!this.isRejected()) {
+ throw new TypeError("cannot get rejection reason of a non-rejected promise");
+ }
+ return this._settledValue;
+};
+
+module.exports = PromiseInspection;
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/zalgo/promise_resolver.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_resolver.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_resolver.js
new file mode 100644
index 0000000..ea14069
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_resolver.js
@@ -0,0 +1,152 @@
+/**
+ * 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";
+var util = require("./util.js");
+var maybeWrapAsError = util.maybeWrapAsError;
+var errors = require("./errors.js");
+var TimeoutError = errors.TimeoutError;
+var RejectionError = errors.RejectionError;
+var async = require("./async.js");
+var haveGetters = util.haveGetters;
+var es5 = require("./es5.js");
+
+function isUntypedError(obj) {
+ return obj instanceof Error &&
+ es5.getPrototypeOf(obj) === Error.prototype;
+}
+
+function wrapAsRejectionError(obj) {
+ var ret;
+ if (isUntypedError(obj)) {
+ ret = new RejectionError(obj);
+ }
+ else {
+ ret = obj;
+ }
+ errors.markAsOriginatingFromRejection(ret);
+ return ret;
+}
+
+function nodebackForPromise(promise) {
+ function PromiseResolver$_callback(err, value) {
+ if (promise === null) return;
+
+ if (err) {
+ var wrapped = wrapAsRejectionError(maybeWrapAsError(err));
+ promise._attachExtraTrace(wrapped);
+ promise._reject(wrapped);
+ }
+ else {
+ if (arguments.length > 2) {
+ var $_len = arguments.length;var args = new Array($_len - 1); for(var $_i = 1; $_i < $_len; ++$_i) {args[$_i - 1] = arguments[$_i];}
+ promise._fulfill(args);
+ }
+ else {
+ promise._fulfill(value);
+ }
+ }
+
+ promise = null;
+ }
+ return PromiseResolver$_callback;
+}
+
+
+var PromiseResolver;
+if (!haveGetters) {
+ PromiseResolver = function PromiseResolver(promise) {
+ this.promise = promise;
+ this.asCallback = nodebackForPromise(promise);
+ this.callback = this.asCallback;
+ };
+}
+else {
+ PromiseResolver = function PromiseResolver(promise) {
+ this.promise = promise;
+ };
+}
+if (haveGetters) {
+ var prop = {
+ get: function() {
+ return nodebackForPromise(this.promise);
+ }
+ };
+ es5.defineProperty(PromiseResolver.prototype, "asCallback", prop);
+ es5.defineProperty(PromiseResolver.prototype, "callback", prop);
+}
+
+PromiseResolver._nodebackForPromise = nodebackForPromise;
+
+PromiseResolver.prototype.toString = function PromiseResolver$toString() {
+ return "[object PromiseResolver]";
+};
+
+PromiseResolver.prototype.resolve =
+PromiseResolver.prototype.fulfill = function PromiseResolver$resolve(value) {
+ var promise = this.promise;
+ if (promise._tryFollow(value)) {
+ return;
+ }
+ promise._fulfill(value);
+};
+
+PromiseResolver.prototype.reject = function PromiseResolver$reject(reason) {
+ var promise = this.promise;
+ errors.markAsOriginatingFromRejection(reason);
+ var trace = errors.canAttach(reason) ? reason : new Error(reason + "");
+ promise._attachExtraTrace(trace);
+ promise._reject(reason);
+ if (trace !== reason) {
+ this._setCarriedStackTrace(trace);
+ }
+};
+
+PromiseResolver.prototype.progress =
+function PromiseResolver$progress(value) {
+ this.promise._progress(value);
+};
+
+PromiseResolver.prototype.cancel = function PromiseResolver$cancel() {
+ this.promise.cancel((void 0));
+};
+
+PromiseResolver.prototype.timeout = function PromiseResolver$timeout() {
+ this.reject(new TimeoutError("timeout"));
+};
+
+PromiseResolver.prototype.isResolved = function PromiseResolver$isResolved() {
+ return this.promise.isResolved();
+};
+
+PromiseResolver.prototype.toJSON = function PromiseResolver$toJSON() {
+ return this.promise.toJSON();
+};
+
+PromiseResolver.prototype._setCarriedStackTrace =
+function PromiseResolver$_setCarriedStackTrace(trace) {
+ if (this.promise.isRejected()) {
+ this.promise._setCarriedStackTrace(trace);
+ }
+};
+
+module.exports = PromiseResolver;
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/zalgo/promise_spawn.js
----------------------------------------------------------------------
diff --git a/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_spawn.js b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_spawn.js
new file mode 100644
index 0000000..2d6525f
--- /dev/null
+++ b/node_modules/node-firefox-find-devices/node_modules/adbkit/node_modules/bluebird/js/zalgo/promise_spawn.js
@@ -0,0 +1,131 @@
+/**
+ * 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, INTERNAL) {
+var errors = require("./errors.js");
+var TypeError = errors.TypeError;
+var util = require("./util.js");
+var isArray = util.isArray;
+var errorObj = util.errorObj;
+var tryCatch1 = util.tryCatch1;
+var yieldHandlers = [];
+
+function promiseFromYieldHandler(value) {
+ var _yieldHandlers = yieldHandlers;
+ var _errorObj = errorObj;
+ var _Promise = Promise;
+ var len = _yieldHandlers.length;
+ for (var i = 0; i < len; ++i) {
+ var result = tryCatch1(_yieldHandlers[i], void 0, value);
+ if (result === _errorObj) {
+ return _Promise.reject(_errorObj.e);
+ }
+ var maybePromise = _Promise._cast(result,
+ promiseFromYieldHandler, void 0);
+ if (maybePromise instanceof _Promise) return maybePromise;
+ }
+ return null;
+}
+
+function PromiseSpawn(generatorFunction, receiver, caller) {
+ var promise = this._promise = new Promise(INTERNAL);
+ promise._setTrace(caller, void 0);
+ this._generatorFunction = generatorFunction;
+ this._receiver = receiver;
+ this._generator = void 0;
+}
+
+PromiseSpawn.prototype.promise = function PromiseSpawn$promise() {
+ return this._promise;
+};
+
+PromiseSpawn.prototype._run = function PromiseSpawn$_run() {
+ this._generator = this._generatorFunction.call(this._receiver);
+ this._receiver =
+ this._generatorFunction = void 0;
+ this._next(void 0);
+};
+
+PromiseSpawn.prototype._continue = function PromiseSpawn$_continue(result) {
+ if (result === errorObj) {
+ this._generator = void 0;
+ var trace = errors.canAttach(result.e)
+ ? result.e : new Error(result.e + "");
+ this._promise._attachExtraTrace(trace);
+ this._promise._reject(result.e, trace);
+ return;
+ }
+
+ var value = result.value;
+ if (result.done === true) {
+ this._generator = void 0;
+ if (!this._promise._tryFollow(value)) {
+ this._promise._fulfill(value);
+ }
+ }
+ else {
+ var maybePromise = Promise._cast(value, PromiseSpawn$_continue, void 0);
+ if (!(maybePromise instanceof Promise)) {
+ if (isArray(maybePromise)) {
+ maybePromise = Promise.all(maybePromise);
+ }
+ else {
+ maybePromise = promiseFromYieldHandler(maybePromise);
+ }
+ if (maybePromise === null) {
+ this._throw(new TypeError("A value was yielded that could not be treated as a promise"));
+ return;
+ }
+ }
+ maybePromise._then(
+ this._next,
+ this._throw,
+ void 0,
+ this,
+ null,
+ void 0
+ );
+ }
+};
+
+PromiseSpawn.prototype._throw = function PromiseSpawn$_throw(reason) {
+ if (errors.canAttach(reason))
+ this._promise._attachExtraTrace(reason);
+ this._continue(
+ tryCatch1(this._generator["throw"], this._generator, reason)
+ );
+};
+
+PromiseSpawn.prototype._next = function PromiseSpawn$_next(value) {
+ this._continue(
+ tryCatch1(this._generator.next, this._generator, value)
+ );
+};
+
+PromiseSpawn.addYieldHandler = function PromiseSpawn$AddYieldHandler(fn) {
+ if (typeof fn !== "function") throw new TypeError("fn must be a function");
+ yieldHandlers.push(fn);
+};
+
+return PromiseSpawn;
+};
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org