diff --git a/modules/electron-widevinecdm/widevine/manifest.json b/modules/electron-widevinecdm/widevine/manifest.json index 4b9b789..6baf1c9 100644 --- a/modules/electron-widevinecdm/widevine/manifest.json +++ b/modules/electron-widevinecdm/widevine/manifest.json @@ -1,5 +1,5 @@ { - "arch": "x64", + "arch": "ia32", "description": "Widevine Content Decryption Module", "manifest_version": 2, "name": "WidevineCdm", diff --git a/modules/electron-widevinecdm/widevine/widevinecdm.dll b/modules/electron-widevinecdm/widevine/widevinecdm.dll index 22401aa..f3cfbdb 100644 Binary files a/modules/electron-widevinecdm/widevine/widevinecdm.dll and b/modules/electron-widevinecdm/widevine/widevinecdm.dll differ diff --git a/modules/electron-widevinecdm/widevine/widevinecdm.dll.lib b/modules/electron-widevinecdm/widevine/widevinecdm.dll.lib index 5f15f45..e2068ae 100644 Binary files a/modules/electron-widevinecdm/widevine/widevinecdm.dll.lib and b/modules/electron-widevinecdm/widevine/widevinecdm.dll.lib differ diff --git a/modules/electron-widevinecdm/widevine/widevinecdm.dll.sig b/modules/electron-widevinecdm/widevine/widevinecdm.dll.sig index 5a22433..e92ff1c 100644 Binary files a/modules/electron-widevinecdm/widevine/widevinecdm.dll.sig and b/modules/electron-widevinecdm/widevine/widevinecdm.dll.sig differ diff --git a/modules/q-master/.coverignore b/modules/q-master/.coverignore new file mode 100644 index 0000000..1564ca0 --- /dev/null +++ b/modules/q-master/.coverignore @@ -0,0 +1 @@ +spec/ diff --git a/modules/q-master/.gitignore b/modules/q-master/.gitignore new file mode 100644 index 0000000..4aca249 --- /dev/null +++ b/modules/q-master/.gitignore @@ -0,0 +1,12 @@ +node_modules +npm-debug.log +CHANGES.html +README.html +.tmp +q.min.js + +coverage/ + +# IntelliJ IDEA project files +.idea +*.iml diff --git a/modules/q-master/.jshintrc b/modules/q-master/.jshintrc new file mode 100644 index 0000000..387bb8d --- /dev/null +++ b/modules/q-master/.jshintrc @@ -0,0 +1,27 @@ +{ + "browser": true, + "node": true, + + "curly": true, + "eqeqeq": true, + "es3": true, + "newcap": false, + "noarg": true, + "nonew": true, + "quotmark": "double", + "strict": true, + "trailing": true, + "undef": true, + "unused": true, + + "globals": { + "self": false, + "bootstrap": false, + "cajaVM": false, + "define": false, + "ReturnValue": false, + "ses": false, + "setImmediate": false, + "Q": true + } +} diff --git a/modules/q-master/.mailmap b/modules/q-master/.mailmap new file mode 100644 index 0000000..281850a --- /dev/null +++ b/modules/q-master/.mailmap @@ -0,0 +1,2 @@ +Domenic Denicola +Kris Kowal diff --git a/modules/q-master/.travis.yml b/modules/q-master/.travis.yml new file mode 100644 index 0000000..ea9862e --- /dev/null +++ b/modules/q-master/.travis.yml @@ -0,0 +1,5 @@ +language: node_js +node_js: + - "0.10" +script: + npm test diff --git a/modules/q-master/CHANGES.md b/modules/q-master/CHANGES.md new file mode 100644 index 0000000..766fcdc --- /dev/null +++ b/modules/q-master/CHANGES.md @@ -0,0 +1,800 @@ + +## 1.5.1 + + - Q.any now annotates its error message to clarify that Q.any was involved and + includes only the last error emitted. (Ivan Etchart) + - Avoid domain.dispose during tests in preparation for Node.js 9. (Anna + Henningsen) + +## 1.5.0 + + - Q.any gives an error message from the last rejected promise + - Throw if callback supplied to "finally" is invalid (@grahamrhay) + - Long stack trace improvements, can now construct long stack traces + across rethrows. + +## 1.4.1 + + - Address an issue that prevented Q from being used as a ` + + + diff --git a/modules/q-master/examples/async-generators/1-return.js b/modules/q-master/examples/async-generators/1-return.js new file mode 100644 index 0000000..7aab6db --- /dev/null +++ b/modules/q-master/examples/async-generators/1-return.js @@ -0,0 +1,19 @@ +"use strict"; + +var Q = require("../../q"); + +var generator = Q.async(function* () { + var ten = yield 10; + console.log(ten, 10); + var twenty = yield ten + 10; + console.log(twenty, 20); + var thirty = yield twenty + 10; + console.log(thirty, 30); + return thirty + 10; +}); + +generator().then(function (forty) { + console.log(forty, 40); +}, function (reason) { + console.log("reason", reason); +}); diff --git a/modules/q-master/examples/async-generators/2-error-propagation.js b/modules/q-master/examples/async-generators/2-error-propagation.js new file mode 100644 index 0000000..ccd788b --- /dev/null +++ b/modules/q-master/examples/async-generators/2-error-propagation.js @@ -0,0 +1,21 @@ +"use strict"; + +var Q = require("../../q"); + +var generator = Q.async(function* () { + try { + var ten = yield Q.reject(new Error("Rejected!")); + console.log("Should not get here 1"); + } catch (exception) { + console.log("Should get here 1"); + console.log(exception.message, "should be", "Rejected!"); + throw new Error("Threw!"); + } +}); + +generator().then(function () { + console.log("Should not get here 2"); +}, function (reason) { + console.log("Should get here 2"); + console.log(reason.message, "should be", "Threw!"); +}); diff --git a/modules/q-master/examples/async-generators/3-spawn.js b/modules/q-master/examples/async-generators/3-spawn.js new file mode 100644 index 0000000..85fe067 --- /dev/null +++ b/modules/q-master/examples/async-generators/3-spawn.js @@ -0,0 +1,21 @@ +"use strict"; + +var Q = require("../../q"); + +function foo() { + return Q.delay(5, 1000); +} + +function bar() { + return Q.delay(10, 1000); +} + +Q.spawn(function* () { + var x = yield foo(); + console.log(x); + + var y = yield bar(); + console.log(y); + + console.log("result", x + y); +}); diff --git a/modules/q-master/examples/async-generators/4-flow-control.js b/modules/q-master/examples/async-generators/4-flow-control.js new file mode 100644 index 0000000..017bf8a --- /dev/null +++ b/modules/q-master/examples/async-generators/4-flow-control.js @@ -0,0 +1,42 @@ +"use strict"; + +var Q = require("../../q"); + +// We get back blocking semantics: can use promises with `if`, `while`, `for`, +// etc. +var filter = Q.async(function* (promises, test) { + var results = []; + for (var i = 0; i < promises.length; i++) { + var val = yield promises[i]; + if (test(val)) { + results.push(val); + } + } + return results; +}); + +var promises = [ + Q.delay("a", 500), + Q.delay("d", 1000), + Q("l") +]; + +filter(promises, function (letter) { + return "f" > letter; +}).done(function (all) { + console.log(all); // [ "a", "d" ] +}); + + +// we can use try and catch to handle rejected promises +var logRejections = Q.async(function* (work) { + try { + yield work; + console.log("Never end up here"); + } catch (e) { + console.log("Caught:", e.message); + } +}); + +var rejection = Q.reject(new Error("Oh dear")); +logRejections(rejection); // Caught: Oh dear diff --git a/modules/q-master/examples/async-generators/README.md b/modules/q-master/examples/async-generators/README.md new file mode 100644 index 0000000..c409f0b --- /dev/null +++ b/modules/q-master/examples/async-generators/README.md @@ -0,0 +1,66 @@ +:warning: Warning: The behavior described here is likely to be quickly +obseleted by developments in standardization and implementation. Tread with +care. + +Q has an `async` function. This can be used to decorate a generator function +such that `yield` is effectively equivalent to `await` or `defer` syntax as +supported by languages like Go and C# 5. + +Generator functions are presently on the standards track for ES6. As of July +2013, they are only fully supported by bleeding edge V8, which hasn't made it +out to a released Chromium yet but will probably be in Chromium 29. Even then, +they must be enabled from [chrome://flags](chrome://flags) as "Experimental +JavaScript features." SpiderMonkey (used in Firefox) includes an older style of +generators, but these are not supported by Q. + +Here's an example of using generators by themselves, without any Q features: + +```js +function* count() { + var i = 0; + while (true) { + yield i++; + } +} + +var counter = count(); +counter.next().value === 0; +counter.next().value === 1; +counter.next().value === 2; +``` + +`yield` can also return a value, if the `next` method of the generator is +called with a parameter: + +```js +var buffer = (function* () { + var x; + while (true) { + x = yield x; + } +}()); + +buffer.next(1).value === undefined; +buffer.next("a").value === 1; +buffer.value(2).value === "a"; +buffer.next().value === 2; +buffer.next().value === undefined; +buffer.next().value === undefined; +``` + +Inside functions wrapped with `Q.async`, we can use `yield` to wait for a +promise to settle: + +```js +var eventualAdd = Q.async(function* (oneP, twoP) { + var one = yield oneP; + var two = yield twoP; + return one + two; +}); + +eventualAdd(eventualOne, eventualTwo).then(function (three) { + three === 3; +}); +``` +You can see more examples of how this works, as well as the `Q.spawn` function, +in the other files in this folder. diff --git a/modules/q-master/package.json b/modules/q-master/package.json new file mode 100644 index 0000000..8c3b5fe --- /dev/null +++ b/modules/q-master/package.json @@ -0,0 +1,76 @@ +{ + "name": "q", + "version": "1.5.1", + "description": "A library for promises (CommonJS/Promises/A,B,D)", + "homepage": "https://github.com/kriskowal/q", + "author": "Kris Kowal (https://github.com/kriskowal)", + "keywords": [ + "q", + "promise", + "promises", + "promises-a", + "promises-aplus", + "deferred", + "future", + "async", + "flow control", + "fluent", + "browser", + "node" + ], + "contributors": [ + "Kris Kowal (https://github.com/kriskowal)", + "Irakli Gozalishvili (http://jeditoolkit.com)", + "Domenic Denicola (http://domenicdenicola.com)" + ], + "bugs": { + "mail": "kris@cixar.com", + "url": "http://github.com/kriskowal/q/issues" + }, + "license": "MIT", + "main": "q.js", + "files": [ + "LICENSE", + "q.js", + "queue.js" + ], + "repository": { + "type": "git", + "url": "git://github.com/kriskowal/q.git" + }, + "engines": { + "node": ">=0.6.0", + "teleport": ">=0.2.0" + }, + "dependencies": {}, + "devDependencies": { + "cover": "*", + "grunt": "~0.4.1", + "grunt-cli": "~0.1.9", + "grunt-contrib-uglify": "~0.9.1", + "jasmine-node": "1.11.0", + "jshint": "~2.1.9", + "matcha": "~0.2.0", + "opener": "*", + "promises-aplus-tests": "1.x" + }, + "scripts": { + "test": "npm ls -s && jasmine-node spec && promises-aplus-tests spec/aplus-adapter && npm run -s lint", + "test-browser": "opener spec/q-spec.html", + "benchmark": "matcha", + "lint": "jshint q.js", + "cover": "cover run jasmine-node spec && cover report html && opener cover_html/index.html", + "minify": "grunt", + "prepublish": "grunt" + }, + "overlay": { + "teleport": { + "dependencies": { + "system": ">=0.0.4" + } + } + }, + "directories": { + "test": "./spec" + } +} diff --git a/modules/q-master/q.js b/modules/q-master/q.js new file mode 100644 index 0000000..6e46795 --- /dev/null +++ b/modules/q-master/q.js @@ -0,0 +1,2076 @@ +// vim:ts=4:sts=4:sw=4: +/*! + * + * Copyright 2009-2017 Kris Kowal under the terms of the MIT + * license found at https://github.com/kriskowal/q/blob/v1/LICENSE + * + * With parts by Tyler Close + * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found + * at http://www.opensource.org/licenses/mit-license.html + * Forked at ref_send.js version: 2009-05-11 + * + * With parts by Mark Miller + * Copyright (C) 2011 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +(function (definition) { + "use strict"; + + // This file will function properly as a + + + + + + + + + + + + + + + + diff --git a/modules/q-master/spec/q-spec.js b/modules/q-master/spec/q-spec.js new file mode 100644 index 0000000..46d913f --- /dev/null +++ b/modules/q-master/spec/q-spec.js @@ -0,0 +1,2976 @@ +"use strict"; +/*jshint newcap: false*/ +/*global Q: true, describe: false, it: false, expect: false, beforeEach: false, + afterEach: false, require: false, jasmine: false, waitsFor: false, + runs: false */ + +if (typeof Q === "undefined" && typeof require !== "undefined") { + // For Node compatibility. + global.Q = require("../q"); + require("./lib/jasmine-promise"); +} + +var REASON = "this is not an error, but it might show up in the console"; + +// In browsers that support strict mode, it'll be `undefined`; otherwise, the global. +var calledAsFunctionThis = (function () { return this; }()); + +afterEach(function () { + Q.onerror = null; +}); + +describe("computing sum of integers using promises", function() { + it("should compute correct result without blowing stack", function () { + var array = []; + var iters = 1000; + for (var i = 1; i <= iters; i++) { + array.push(i); + } + + var pZero = Q.fulfill(0); + var result = array.reduce(function (promise, nextVal) { + return promise.then(function (currentVal) { + return Q.fulfill(currentVal + nextVal); + }); + }, pZero); + + return result.then(function (value) { + expect(value).toEqual(iters * (iters + 1) / 2); + }); + }); +}); + +describe("Q function", function () { + it("should result in a fulfilled promise when given a value", function () { + expect(Q(5).isFulfilled()).toBe(true); + }); + + it("should be the identity when given promise", function () { + var f = Q.fulfill(5); + var r = Q.reject(new Error("aaargh")); + var p = Q.promise(function () { }); + + expect(Q(f)).toBe(f); + expect(Q(r)).toBe(r); + expect(Q(p)).toBe(p); + }); +}); + +describe("defer and when", function () { + + it("resolve before when", function () { + var turn = 0; + var deferred = Q.defer(); + deferred.resolve(10); + var promise = Q.when(deferred.promise, function (value) { + expect(turn).toEqual(1); + expect(value).toEqual(10); + }); + turn++; + return promise; + }); + + it("reject before when", function () { + var turn = 0; + var deferred = Q.defer(); + deferred.reject(-1); + var promise = Q.when(deferred.promise, function () { + expect(true).toBe(false); + }, function (value) { + expect(turn).toEqual(1); + expect(value).toEqual(-1); + }); + turn++; + return promise; + }); + + it("when before resolve", function () { + var turn = 0; + var deferred = Q.defer(); + var promise = deferred.promise.then(function (value) { + expect(turn).toEqual(2); + expect(value).toEqual(10); + turn++; + }); + Q.nextTick(function () { + expect(turn).toEqual(1); + deferred.resolve(10); + turn++; + }); + turn++; + return promise; + }); + + it("when before reject", function () { + var turn = 0; + var deferred = Q.defer(); + var promise = deferred.promise.then(function () { + expect(true).toBe(false); + }, function (value) { + expect(turn).toEqual(2); + expect(value).toEqual(-1); + turn++; + }); + Q.nextTick(function () { + expect(turn).toEqual(1); + deferred.reject(-1); + turn++; + }); + turn++; + return promise; + }); + + it("resolves multiple observers", function (done) { + var nextTurn = false; + + var resolution = "Taram pam param!"; + var deferred = Q.defer(); + var count = 10; + var i = 0; + + function resolve(value) { + i++; + expect(value).toBe(resolution); + expect(nextTurn).toBe(true); + if (i === count) { + done(); + } + } + + while (++i <= count) { + Q.when(deferred.promise, resolve); + } + + deferred.resolve(resolution); + i = 0; + nextTurn = true; + }); + + it("observers called even after throw", function () { + var threw = false; + var deferred = Q.defer(); + Q.when(deferred.promise, function () { + threw = true; + throw new Error(REASON); + }); + var promise = Q.when(deferred.promise, function (value) { + expect(value).toEqual(10); + }, function () { + expect("not").toEqual("here"); + }); + deferred.resolve(10); + return promise; + }); + + it("returns `undefined` from the deferred's methods", function () { + expect(Q.defer().resolve()).toBe(undefined); + expect(Q.defer().reject()).toBe(undefined); + }); + +}); + +describe("always next tick", function () { + + it("generated by `resolve`", function () { + var turn = 0; + var promise = Q.when(Q(), function () { + expect(turn).toEqual(1); + }); + turn++; + return promise; + }); + + it("generated by `reject`", function () { + var turn = 0; + var promise = Q.when(Q.reject(), function () { + expect(true).toBe(false); + }, function () { + expect(turn).toEqual(1); + }); + turn++; + return promise; + }); + + it("allows overriding global nextTick", function () { + var spy = jasmine.createSpy(); + spyOn(Q, 'nextTick').andCallFake(function immediateTick(task){ + task(); + }); + + Q.when(Q(), spy); + + expect(spy).toHaveBeenCalled(); + expect(Q.nextTick).toHaveBeenCalled(); + }); +}); + +describe("progress", function () { + + it("calls a single progress listener", function () { + var progressed = false; + var deferred = Q.defer(); + + var promise = Q.when( + deferred.promise, + function () { + expect(progressed).toBe(true); + }, + function () { + expect(true).toBe(false); + }, + function () { + progressed = true; + } + ); + + deferred.notify(); + deferred.resolve(); + + return promise; + }); + + it("calls multiple progress listeners", function () { + var progressed1 = false; + var progressed2 = false; + var deferred = Q.defer(); + var promise = Q.when( + deferred.promise, + function () { + expect(progressed1).toBe(true); + expect(progressed2).toBe(true); + }, + function () { + expect(true).toBe(false); + }, + function () { + progressed1 = true; + } + ); + Q.when(deferred.promise, null, null, function () { + progressed2 = true; + }); + + deferred.notify(); + deferred.resolve(); + + return promise; + }); + + it("calls all progress listeners even if one throws", function () { + var progressed1 = false; + var progressed2 = false; + var progressed3 = false; + var deferred = Q.defer(); + var promise = Q.when( + deferred.promise, + function () { + expect(progressed1).toBe(true); + expect(progressed2).toBe(true); + expect(progressed3).toBe(true); + }, + function () { + expect(true).toBe(false); + }, + function () { + progressed1 = true; + } + ); + + Q.onerror = function () { }; + + Q.when(deferred.promise, null, null, function () { + progressed2 = true; + throw new Error("just a test, ok if it shows up in the console"); + }); + Q.when(deferred.promise, null, null, function () { + progressed3 = true; + }); + + deferred.notify(); + deferred.resolve(); + + return promise; + }); + + it("calls the progress listener even if later rejected", function () { + var progressed = false; + var deferred = Q.defer(); + var promise = Q.when( + deferred.promise, + function () { + expect(true).toBe(false); + }, + function () { + expect(progressed).toEqual(true); + }, + function () { + progressed = true; + } + ); + + deferred.notify(); + deferred.reject(); + + return promise; + }); + + it("calls the progress listener with the notify values", function () { + var progressValues = []; + var desiredProgressValues = [{}, {}, "foo", 5]; + var deferred = Q.defer(); + var promise = Q.when( + deferred.promise, + function () { + for (var i = 0; i < desiredProgressValues.length; ++i) { + var desired = desiredProgressValues[i]; + var actual = progressValues[i]; + expect(actual).toBe(desired); + } + }, + function () { + expect(true).toBe(false); + }, + function (value) { + progressValues.push(value); + } + ); + + for (var i = 0; i < desiredProgressValues.length; ++i) { + deferred.notify(desiredProgressValues[i]); + } + deferred.resolve(); + + return promise; + }); + + it("does not call the progress listener if notify is called after fulfillment", function () { + var deferred = Q.defer(); + var called = false; + + Q.when(deferred.promise, null, null, function () { + called = true; + }); + + deferred.resolve(); + deferred.notify(); + + return Q.delay(10).then(function () { + expect(called).toBe(false); + }); + }); + + it("does not call the progress listener if notify is called after rejection", function () { + var deferred = Q.defer(); + var called = false; + + Q.when(deferred.promise, null, null, function () { + called = true; + }); + + deferred.reject(); + deferred.notify(); + + return Q.delay(10).then(function () { + expect(called).toBe(false); + }); + }); + + it("should not save and re-emit progress notifications", function () { + var deferred = Q.defer(); + var progressValues = []; + + deferred.notify(1); + + var promise = Q.when( + deferred.promise, + function () { + expect(progressValues).toEqual([2]); + }, + function () { + expect(true).toBe(false); + }, + function (progressValue) { + progressValues.push(progressValue); + } + ); + + deferred.notify(2); + deferred.resolve(); + + return promise; + }); + + it("should allow attaching progress listeners w/ .progress", function () { + var progressed = false; + var deferred = Q.defer(); + + deferred.promise.progress(function () { + progressed = true; + }); + + deferred.notify(); + deferred.resolve(); + + return deferred.promise; + }); + + it("should allow attaching progress listeners w/ Q.progress", function () { + var progressed = false; + var deferred = Q.defer(); + + Q.progress(deferred.promise, function () { + progressed = true; + }); + + deferred.notify(); + deferred.resolve(); + + return deferred.promise; + }); + + it("should call the progress listener with undefined context", function () { + var progressed = false; + var progressContext = {}; + var deferred = Q.defer(); + var promise = Q.when( + deferred.promise, + function () { + expect(progressed).toBe(true); + expect(progressContext).toBe(calledAsFunctionThis); + }, + function () { + expect(true).toBe(false); + }, + function () { + progressed = true; + progressContext = this; + } + ); + + deferred.notify(); + deferred.resolve(); + + return promise; + }); + + it("should forward only the first notify argument to listeners", function () { + var progressValueArrays = []; + var deferred = Q.defer(); + + var promise = Q.when( + deferred.promise, + function () { + expect(progressValueArrays).toEqual([[1], [2], [4]]); + }, + function () { + expect(true).toBe(false); + }, + function () { + var args = Array.prototype.slice.call(arguments); + progressValueArrays.push(args); + } + ); + + deferred.notify(1); + deferred.notify(2, 3); + deferred.notify(4, 5, 6); + deferred.resolve(); + + return promise; + }); + + it("should work with .then as well", function () { + var progressed = false; + var deferred = Q.defer(); + + var promise = deferred.promise.then( + function () { + expect(progressed).toBe(true); + }, + function () { + expect(true).toBe(false); + }, + function () { + progressed = true; + } + ); + + deferred.notify(); + deferred.resolve(); + + return promise; + }); + + it("should re-throw all errors thrown by listeners to Q.onerror", function () { + var theError = new Error("boo!"); + + var def = Q.defer(); + def.promise.progress(function () { + throw theError; + }); + + var deferred = Q.defer(); + Q.onerror = function (error) { + expect(error).toBe(theError); + deferred.resolve(); + }; + Q.delay(100).then(deferred.reject); + + def.notify(); + + return deferred.promise; + }); +}); + +describe("promises for objects", function () { + + describe("get", function () { + + it("fulfills a promise", function () { + var deferred = Q.defer(); + deferred.resolve({a: 1}); + return deferred.promise.get("a") + .then(function (a) { + expect(a).toBe(1); + }); + }); + + it("propagates a rejection", function () { + var exception = new Error("boo!"); + return Q.fcall(function () { + throw exception; + }) + .get("a") + .then(function () { + expect("be").toBe("not to be"); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + }); + + describe("set", function () { + + it("fulfills a promise", function () { + var object = {}; + return Q(object) + .set("a", 1) + .then(function (result) { + expect(result).toBe(undefined); + expect(object.a).toBe(1); + }); + }); + + it("propagates a rejection", function () { + var exception = new Error("Gah!"); + return Q.reject(exception) + .set("a", 1) + .then(function () { + expect("frozen over").toBe("quite warm"); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + }); + + describe("del", function () { + + it("fulfills a promise", function () { + var object = {a: 10}; + return Q.fcall(function () { + return object; + }) + .del("a") + .then(function (result) { + expect("a" in object).toBe(false); + expect(result).toBe(void 0); + }, function () { + expect("up").toBe("down"); + }); + }); + + it("propagates a rejection", function () { + var exception = new Error("hah-hah"); + return Q.fcall(function () { + throw exception; + }) + .del("a") + .then(function () { + expect(true).toBe(false); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + }); + + describe("post", function () { + + it("fulfills a promise", function () { + var subject = { + a: function a(value) { + this._a = value; + return 1 + value; + } + }; + return Q.when(Q.post(subject, "a", [1]), function (two) { + expect(subject._a).toBe(1); + expect(two).toBe(2); + }); + }); + + it("works as apply when given no name", function () { + return Q(function (a, b, c) { + return a + b + c; + }) + .post(undefined, [1, 2, 3]) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + }); + + describe("send", function () { + + it("fulfills a promise", function () { + var foo; + var subject = { + foo: function (_bar) { + return _bar; + }, + bar: function (_foo, _bar) { + foo = _foo; + return this.foo(_bar); + } + }; + return Q.send(subject, "bar", 1, 2) + .then(function (two) { + expect(foo).toEqual(1); + expect(two).toEqual(2); + }); + }); + + it("is rejected for undefined method", function () { + var subject = {}; + return Q(subject) + .send("foo") + .then(function () { + expect("here").toEqual("not here"); + }, function () { + }); + }); + + it("is rejected for undefined object", function () { + return Q() + .send("foo") + .then(function () { + expect("here").toEqual("not here"); + }, function () { + }); + }); + + }); + + describe("keys", function () { + + function Klass (a, b) { + this.a = a; + this.b = b; + } + Klass.prototype.notOwn = 1; + + it("fulfills a promise", function () { + return Q.keys(new Klass(10, 20)) + .then(function (keys) { + expect(keys.sort()).toEqual(["a", "b"]); + }); + }); + + }); + +}); + +describe("promises for functions", function () { + + describe("fapply", function () { + it("fulfills a promise using arguments", function () { + return Q(function (a, b, c) { + return a + b + c; + }) + .fapply([1, 2, 3]) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + }); + + describe("fcall", function () { + it("fulfills a promise using arguments", function () { + return Q(function (a, b, c) { + return a + b + c; + }) + .fcall(1, 2, 3) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + }); + + describe("fbind", function () { + + it("accepts a promise for a function", function () { + return Q.fbind(Q(function (high, low) { + return high - low; + })) + (2, 1) + .then(function (difference) { + expect(difference).toEqual(1); + }); + }); + + it("chains partial application on a promise for a function", function () { + return Q(function (a, b) { + return a * b; + }) + .fbind(2)(3) + .then(function (product) { + expect(product).toEqual(6); + }); + }); + + it("returns a fulfilled promise", function () { + var result = {}; + var bound = Q.fbind(function () { + return result; + }); + return bound() + .then(function (_result) { + expect(_result).toBe(result); + }); + }); + + it("returns a rejected promise from a thrown error", function () { + var exception = new Error("Boo!"); + var bound = Q.fbind(function () { + throw exception; + }); + return bound() + .then(function () { + expect("flying pigs").toBe("swillin' pigs"); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + it("passes arguments through", function () { + var x = {}, y = {}; + var bound = Q.fbind(function (a, b) { + expect(a).toBe(x); + expect(b).toBe(y); + }); + return bound(x, y); + }); + + it("passes and also partially applies arguments", function () { + var x = {}, y = {}; + var bound = Q.fbind(function (a, b) { + expect(a).toBe(x); + expect(b).toBe(y); + }, x); + return bound(y); + }); + + it("doesn't bind `this`", function () { + var theThis = { me: "this" }; + var bound = Q.fbind(function () { + expect(this).toBe(theThis); + }); + + return bound.call(theThis); + }); + + }); + +}); + +describe("inspect", function () { + + it("for a fulfilled promise", function () { + expect(Q(10).inspect()).toEqual({ + state: "fulfilled", + value: 10 + }); + }); + + it("for a rejected promise", function () { + var error = new Error("In your face."); + var rejected = Q.reject(error); + expect(rejected.inspect()).toEqual({ + state: "rejected", + reason: error + }); + }); + + it("for a pending, unresolved promise", function () { + var pending = Q.defer().promise; + expect(pending.inspect()).toEqual({ state: "pending" }); + }); + + it("for a promise resolved to a rejected promise", function () { + var deferred = Q.defer(); + var error = new Error("Rejected!"); + var rejected = Q.reject(error); + deferred.resolve(rejected); + + expect(deferred.promise.inspect()).toEqual({ + state: "rejected", + reason: error + }); + }); + + it("for a promise resolved to a fulfilled promise", function () { + var deferred = Q.defer(); + var fulfilled = Q(10); + deferred.resolve(fulfilled); + + expect(deferred.promise.inspect()).toEqual({ + state: "fulfilled", + value: 10 + }); + }); + + it("for a promise resolved to a pending promise", function () { + var a = Q.defer(); + var b = Q.defer(); + a.resolve(b.promise); + + expect(a.promise.inspect()).toEqual({ state: "pending" }); + }); + +}); + +describe("promise states", function () { + + it("of fulfilled value", function () { + expect(Q.isFulfilled(void 0)).toBe(true); + expect(Q.isRejected(false)).toBe(false); + expect(Q.isPending(true)).toBe(false); + }); + + it("of fulfillment", function () { + var promise = Q(10); + expect(Q.isFulfilled(promise)).toBe(true); + expect(promise.isFulfilled()).toBe(true); + expect(Q.isRejected(promise)).toBe(false); + expect(promise.isRejected()).toBe(false); + expect(Q.isPending(promise)).toBe(false); + expect(promise.isPending()).toBe(false); + }); + + it("of rejection", function () { + var error = new Error("Oh, snap."); + var promise = Q.reject(error); + expect(promise.isFulfilled()).toBe(false); + expect(promise.isRejected()).toBe(true); + expect(promise.isPending()).toBe(false); + }); + + it("of rejection with a falsy value", function () { + var promise = Q.reject(undefined); + expect(promise.isFulfilled()).toBe(false); + expect(promise.isRejected()).toBe(true); + expect(promise.isPending()).toBe(false); + }); + + it("of deferred", function () { + var deferred = Q.defer(); + var promise = deferred.promise; + expect(promise.isFulfilled()).toBe(false); + expect(promise.isRejected()).toBe(false); + expect(promise.isPending()).toBe(true); + }); + + it("of deferred rejection", function () { + var deferred = Q.defer(); + var rejection = Q.reject(new Error("Rejected!")); + deferred.resolve(rejection); + var promise = deferred.promise; + expect(promise.isFulfilled()).toBe(false); + expect(promise.isRejected()).toBe(true); + expect(promise.isPending()).toBe(false); + }); + + it("of deferred fulfillment", function () { + var deferred = Q.defer(); + deferred.resolve(10); + var promise = deferred.promise; + expect(promise.isFulfilled()).toBe(true); + expect(promise.isRejected()).toBe(false); + expect(promise.isPending()).toBe(false); + }); + + it("of deferred deferred", function () { + var a = Q.defer(); + var b = Q.defer(); + a.resolve(b.promise); + var promise = a.promise; + expect(promise.isFulfilled()).toBe(false); + expect(promise.isRejected()).toBe(false); + expect(promise.isPending()).toBe(true); + }); + + it("of isFulfilled side effects", function () { + var deferred = Q.defer(); + var finished = false; + + waitsFor(function () { + return finished; + }); + + var parentPromise = deferred.promise; + + var childPromise = parentPromise.then(function () { + expect(parentPromise.isFulfilled()).toBe(true); + expect(childPromise.isFulfilled()).toBe(false); + + return parentPromise.then(function (value) { + finished = true; + return value + 1; + }); + }); + + deferred.resolve(1); + + runs(function () { + expect(childPromise.isPending()).toBe(false); + expect(childPromise.isRejected()).toBe(false); + expect(childPromise.isFulfilled()).toBe(true); + expect(childPromise.inspect().value).toBe(2); + }); + }); + +}); + +describe("propagation", function () { + + it("propagate through then with no callback", function () { + return Q(10) + .then() + .then(function (ten) { + expect(ten).toBe(10); + }); + }); + + it("propagate through then with modifying callback", function () { + return Q(10) + .then(function (ten) { + return ten + 10; + }) + .then(function (twen) { + expect(twen).toBe(20); + }); + }); + + it("errback recovers from exception", function () { + var error = new Error("Bah!"); + return Q.reject(error) + .then(null, function (_error) { + expect(_error).toBe(error); + return 10; + }) + .then(function (value) { + expect(value).toBe(10); + }); + }); + + it("rejection propagates through then with no errback", function () { + var error = new Error("Foolish mortals!"); + return Q.reject(error) + .then() + .then(null, function (_error) { + expect(_error).toBe(error); + }); + }); + + it("rejection intercepted and rethrown", function () { + var error = new Error("Foolish mortals!"); + var nextError = new Error("Silly humans!"); + return Q.reject(error) + .fail(function () { + throw nextError; + }) + .then(null, function (_error) { + expect(_error).toBe(nextError); + }); + }); + + it("resolution is forwarded through deferred promise", function () { + var a = Q.defer(); + var b = Q.defer(); + a.resolve(b.promise); + b.resolve(10); + return a.promise.then(function (eh) { + expect(eh).toEqual(10); + }); + }); + + it("should propagate progress by default", function () { + var d = Q.defer(); + + var progressValues = []; + var promise = d.promise + .then() + .then( + function () { + expect(progressValues).toEqual([1]); + }, + function () { + expect(true).toBe(false); + }, + function (progressValue) { + progressValues.push(progressValue); + } + ); + + d.notify(1); + d.resolve(); + + return promise; + }); + + it("should allow translation of progress in the progressback", function () { + var d = Q.defer(); + + var progressValues = []; + var promise = d.promise + .progress(function (p) { + return p + 5; + }) + .then( + function () { + expect(progressValues).toEqual([10]); + }, + function () { + expect(true).toBe(false); + }, + function (progressValue) { + progressValues.push(progressValue); + } + ); + + d.notify(5); + d.resolve(); + + return promise; + }); + + + it("should stop progress propagation if an error is thrown", function () { + var def = Q.defer(); + var p2 = def.promise.progress(function () { + throw new Error("boo!"); + }); + + Q.onerror = function () { /* just swallow it for this test */ }; + + var progressValues = []; + var result = p2.then( + function () { + expect(progressValues).toEqual([]); + }, + function () { + expect(true).toBe(false); + }, + function (progressValue) { + progressValues.push(progressValue); + } + ); + + def.notify(); + def.resolve(); + return result; + }); +}); + +describe("all", function () { + it("fulfills when passed an empty array", function () { + return Q.all([]); + }); + + it("rejects after any constituent promise is rejected", function () { + var toResolve = Q.defer(); // never resolve + var toReject = Q.defer(); + var promises = [toResolve.promise, toReject.promise]; + var promise = Q.all(promises); + + toReject.reject(new Error("Rejected")); + + return Q.delay(250) + .then(function () { + expect(promise.isRejected()).toBe(true); + }) + .timeout(1000); + }); + + it("resolves foreign thenables", function () { + var normal = Q(1); + var foreign = { then: function (f) { f(2); } }; + + return Q.all([normal, foreign]) + .then(function (result) { + expect(result).toEqual([1, 2]); + }); + }); + + it("fulfills when passed an sparse array", function () { + var toResolve = Q.defer(); + var promises = []; + promises[0] = Q(0); + promises[2] = toResolve.promise; + var promise = Q.all(promises); + + toResolve.resolve(2); + + return promise.then(function (result) { + expect(result).toEqual([0, void 0, 2]); + }); + }); + + it("modifies the input array", function () { + var input = [Q(0), Q(1)]; + + return Q.all(input).then(function (result) { + expect(result).toBe(input); + expect(input).toEqual([0, 1]); + }); + }); + + it("sends { index, value } progress updates", function () { + var deferred1 = Q.defer(); + var deferred2 = Q.defer(); + + var progressValues = []; + + Q.delay(50).then(function () { + deferred1.notify("a"); + }); + Q.delay(100).then(function () { + deferred2.notify("b"); + deferred2.resolve(); + }); + Q.delay(150).then(function () { + deferred1.notify("c"); + deferred1.resolve(); + }); + + return Q.all([deferred1.promise, deferred2.promise]).then( + function () { + expect(progressValues).toEqual([ + { index: 0, value: "a" }, + { index: 1, value: "b" }, + { index: 0, value: "c" } + ]); + }, + undefined, + function (progressValue) { + progressValues.push(progressValue); + } + ) + }); + +}); + +describe("any", function() { + it("fulfills when passed an empty array", function() { + return Q.any([]); + }); + + it("rejects after all promises are rejected", function() { + var deferreds = [Q.defer(), Q.defer()]; + var promises = [deferreds[0].promise, deferreds[1].promise]; + + return testReject(promises, deferreds, new Error("Rejected")); + }); + + it("rejects after all promises in a sparse array are rejected", function() { + var deferreds = [Q.defer(), Q.defer()]; + var promises = []; + promises[0] = deferreds[0].promise; + promises[3] = deferreds[1].promise; + + return testReject(promises, deferreds, new Error("Rejected")); + }); + + + it("rejects after all promises are rejected with null", function() { + var deferreds = [Q.defer(), Q.defer()]; + var promises = [deferreds[0].promise, deferreds[1].promise]; + + return testReject(promises, deferreds, null); + }); + + it("rejects after all promises are rejected with undefined", function() { + var deferreds = [Q.defer(), Q.defer()]; + var promises = [deferreds[0].promise, deferreds[1].promise]; + + return testReject(promises, deferreds, undefined); + }); + + function testReject(promises, deferreds, rejectionValue) { + var promise = Q.any(promises); + var expectedError; + + if (rejectionValue) { + expectedError = new Error(rejectionValue.message); + } else { + expectedError = new Error("" + rejectionValue); + } + + for (var index = 0; index < deferreds.length; index++) { + var deferred = deferreds[index]; + (function() { + deferred.reject(rejectionValue); + })(); + } + + return Q.delay(250) + .then(function() { + expect(promise.isRejected()).toBe(true); + expect(promise.inspect().reason).toEqual(expectedError); + expect(promise.inspect().reason.message) + .toBe("Q can't get fulfillment value from any promise, all promises were rejected. Last error message: " + expectedError.message); + }) + .timeout(1000); + } + + it("fulfills with the first resolved promise", function() { + var deferreds = [Q.defer(), Q.defer()]; + var promises = [deferreds[0].promise, deferreds[1].promise]; + + testFulfill(promises, deferreds); + }); + + it("fulfills when passed a sparse array", function() { + var deferreds = [Q.defer(), Q.defer()]; + var promises = []; + promises[0] = deferreds[0].promise; + promises[2] = deferreds[1].promise; + + testFulfill(promises, deferreds); + }); + + function testFulfill(promises, deferreds) { + var promise = Q.any(promises); + + var j = 1; + for (var index = 0; index < deferreds.length; index++) { + var toResolve = deferreds[index]; + if (!toResolve || !Q.isPromiseAlike(toResolve.promise)) { + continue; + } + + (function(index, toResolve) { + var time = index * 50; + Q.delay(time).then(function() { + toResolve.resolve('Fulfilled' + index); + }); + })(j, toResolve); + + j++; + } + + return Q.delay(400) + .then(function() { + expect(promise.isFulfilled()).toBe(true); + expect(promise.inspect().value).toBe('Fulfilled1'); + }) + .timeout(1000); + } + + it("fulfills with the first value", function() { + var toResolve1 = Q.defer(); + var toResolve2 = Q.defer(); + var toResolve3 = Q.defer(); + var promises = [toResolve1.promise, toResolve2.promise, 4, 5, + toResolve3.promise + ]; + + var promise = Q.any(promises); + + Q.delay(150).then(function() { + toResolve1.resolve(1); + }); + Q.delay(50).then(function() { + toResolve2.resolve(2); + }); + Q.delay(100).then(function() { + toResolve3.resolve(3); + }); + + return Q.delay(250) + .then(function() { + expect(promise.isFulfilled()).toBe(true); + expect(promise.inspect().value).toBe(4); + }) + .timeout(1000); + }); + + it("fulfills after rejections", function() { + var toReject = [Q.defer(), Q.defer()]; + var toResolve = Q.defer(); + var promises = [toReject[0].promise, toReject[1].promise, + toResolve + .promise + ]; + + var promise = Q.any(promises); + + testFulfillAfterRejections(promises, toReject, toResolve); + }); + + it("fulfills after rejections in sparse array", function() { + var toReject = [Q.defer(), Q.defer()]; + var toResolve = Q.defer(); + var promises = []; + promises[2] = toReject[0].promise; + promises[5] = toReject[1].promise; + promises[9] = toResolve.promise; + + testFulfillAfterRejections(promises, toReject, toResolve); + }); + + function testFulfillAfterRejections(promises, rejectDeferreds, + fulfillDeferred) { + var promise = Q.any(promises); + + for (var index = 0; index < rejectDeferreds.length; index++) { + var toReject = rejectDeferreds[index]; + (function(index, toReject) { + var time = (index + 1) * 50; + Q.delay(time).then(function() { + toReject.reject(new Error('Rejected')); + }); + })(index, toReject); + + index++; + } + Q.delay(index * 50).then(function() { + fulfillDeferred.resolve('Fulfilled'); + }); + + return Q.delay(400) + .then(function() { + expect(promise.isFulfilled()).toBe(true); + expect(promise.inspect().value).toBe('Fulfilled'); + }) + .timeout(1000); + } + + it("resolves foreign thenables", function() { + var normal = Q.delay(150) + .then(function() {}) + .thenResolve(1); + var foreign = { + then: function(f) { + return f(2); + } + }; + + return Q.any([normal, foreign]) + .then(function(result) { + expect(result).toEqual(2); + }); + }); + + it("sends { index, value } progress updates", function() { + var deferred1 = Q.defer(); + var deferred2 = Q.defer(); + + var progressValues = []; + + Q.delay(50).then(function() { + deferred1.notify("a"); + }); + Q.delay(100).then(function() { + deferred2.notify("b"); + deferred2.resolve(); + }); + Q.delay(150).then(function() { + deferred1.notify("c"); // Is lost, deferred2 already resolved. + deferred1.resolve(); + }); + + return Q.any([deferred1.promise, deferred2.promise]) + .delay(250) + .then(function() { + expect(progressValues).toEqual([{ + index: 0, + value: "a" + }, { + index: 1, + value: "b" + }]); + }, + undefined, + function(progressValue) { + progressValues.push(progressValue); + } + ); + }); + +}); + +describe("allSettled", function () { + it("works on an empty array", function () { + return Q.allSettled([]) + .then(function (snapshots) { + expect(snapshots).toEqual([]); + }); + }); + + it("deals with a mix of non-promises and promises", function () { + return Q.allSettled([1, Q(2), Q.reject(3)]) + .then(function (snapshots) { + expect(snapshots).toEqual([ + { state: "fulfilled", value: 1 }, + { state: "fulfilled", value: 2 }, + { state: "rejected", reason: 3 } + ]); + }); + }); + + it("is settled after every constituent promise is settled", function () { + var toFulfill = Q.defer(); + var toReject = Q.defer(); + var promises = [toFulfill.promise, toReject.promise]; + var fulfilled; + var rejected; + + Q.fcall(function () { + toReject.reject(); + rejected = true; + }) + .delay(15) + .then(function () { + toFulfill.resolve(); + fulfilled = true; + }); + + return Q.allSettled(promises) + .then(function () { + expect(fulfilled).toBe(true); + expect(rejected).toBe(true); + }); + }); + + it("does not modify the input array", function () { + var input = [1, Q(2), Q.reject(3)]; + + return Q.allSettled(input) + .then(function (snapshots) { + expect(snapshots).not.toBe(input); + expect(snapshots).toEqual([ + { state: "fulfilled", value: 1 }, + { state: "fulfilled", value: 2 }, + { state: "rejected", reason: 3 } + ]); + }); + }); + +}); + +describe("spread", function () { + + it("spreads values across arguments", function () { + return Q.spread([1, 2, 3], function (a, b) { + expect(b).toBe(2); + }); + }); + + it("spreads promises for arrays across arguments", function () { + return Q([Q(10)]) + .spread(function (value) { + expect(value).toEqual(10); + }); + }); + + it("spreads arrays of promises across arguments", function () { + var deferredA = Q.defer(); + var deferredB = Q.defer(); + + var promise = Q.spread([deferredA.promise, deferredB.promise], + function (a, b) { + expect(a).toEqual(10); + expect(b).toEqual(20); + }); + + Q.delay(5).then(function () { + deferredA.resolve(10); + }); + Q.delay(10).then(function () { + deferredB.resolve(20); + }); + + return promise; + }); + + it("calls the errback when given a rejected promise", function () { + var err = new Error(); + return Q.spread([Q(10), Q.reject(err)], + function () { + expect(true).toBe(false); + }, + function (actual) { + expect(actual).toBe(err); + } + ); + }); + +}); + +describe("fin", function () { + + var exception1 = new Error("boo!"); + var exception2 = new TypeError("evil!"); + + describe("when the promise is fulfilled", function () { + + it("should call the callback", function () { + var called = false; + + return Q("foo") + .fin(function () { + called = true; + }) + .then(function () { + expect(called).toBe(true); + }); + }); + + it("should fulfill with the original value", function () { + return Q("foo") + .fin(function () { + return "bar"; + }) + .then(function (result) { + expect(result).toBe("foo"); + }); + }); + + describe("when the callback returns a promise", function () { + + describe("that is fulfilled", function () { + it("should fulfill with the original reason after that promise resolves", function () { + var promise = Q.delay(250); + + return Q("foo") + .fin(function () { + return promise; + }) + .then(function (result) { + expect(Q.isPending(promise)).toBe(false); + expect(result).toBe("foo"); + }); + }); + }); + + describe("that is rejected", function () { + it("should reject with this new rejection reason", function () { + return Q("foo") + .fin(function () { + return Q.reject(exception1); + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception1); + }); + }); + }); + + }); + + describe("when the callback throws an exception", function () { + it("should reject with this new exception", function () { + return Q("foo") + .fin(function () { + throw exception1; + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception1); + }); + }); + }); + + }); + + describe("when the promise is rejected", function () { + + it("should call the callback", function () { + var called = false; + + return Q.reject(exception1) + .fin(function () { + called = true; + }) + .then(function () { + expect(called).toBe(true); + }, function () { + expect(called).toBe(true); + }); + }); + + it("should reject with the original reason", function () { + return Q.reject(exception1) + .fin(function () { + return "bar"; + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception1); + }); + }); + + describe("when the callback returns a promise", function () { + + describe("that is fulfilled", function () { + it("should reject with the original reason after that promise resolves", function () { + var promise = Q.delay(250); + + return Q.reject(exception1) + .fin(function () { + return promise; + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception1); + expect(Q.isPending(promise)).toBe(false); + }); + }); + }); + + describe("that is rejected", function () { + it("should reject with the new reason", function () { + return Q.reject(exception1) + .fin(function () { + return Q.reject(exception2); + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception2); + }); + }); + }); + + }); + + describe("when the callback throws an exception", function () { + it("should reject with this new exception", function () { + return Q.reject(exception1) + .fin(function () { + throw exception2; + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception2); + }); + }); + }); + + }); + + describe("when the callback is invalid", function () { + describe("undefined", function () { + it("should have a useful error", function () { + var foo = {}, + threw = false; + + try { + Q().fin(foo.bar); + } catch (err) { + expect(err.message).toBe("Q can't apply finally callback"); + threw = true; + } + + expect(threw).toBe(true); + }); + }); + + describe("not a function", function () { + it("should have a useful error", function () { + var threw = false; + + try { + Q().fin(123); + } catch (err) { + expect(err.message).toBe("Q can't apply finally callback"); + threw = true; + } + + expect(threw).toBe(true); + }); + }); + }); +}); + +// Almost like "fin" +describe("tap", function () { + var exception1 = new Error("boo!"); + + describe("when the promise is fulfilled", function () { + it("should call the callback", function () { + var called = false; + return Q("foo") + .tap(function () { + called = true; + }) + .then(function () { + expect(called).toBe(true); + }); + }); + + it("should fulfill with the original value", function () { + return Q("foo") + .tap(function () { + return "bar"; + }) + .then(function (result) { + expect(result).toBe("foo"); + }); + }); + + describe("when the callback returns a promise", function () { + describe("that is fulfilled", function () { + it("should fulfill with the original reason after that promise resolves", function () { + var promise = Q.delay(250); + + return Q("foo") + .tap(function () { + return promise; + }) + .then(function (result) { + expect(Q.isPending(promise)).toBe(false); + expect(result).toBe("foo"); + }); + }); + }); + + describe("that is rejected", function () { + it("should reject with this new rejection reason", function () { + return Q("foo") + .tap(function () { + return Q.reject(exception1); + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception1); + }); + }); + }); + + }); + + describe("when the callback throws an exception", function () { + it("should reject with this new exception", function () { + return Q("foo") + .tap(function () { + throw exception1; + }) + .then(function () { + expect(false).toBe(true); + }, + function (exception) { + expect(exception).toBe(exception1); + }); + }); + }); + + }); + + describe("when the promise is rejected", function () { + it("should not call the callback", function () { + var called = false; + + return Q.reject(exception1) + .tap(function () { + called = true; + }) + .then(function () { + expect(called).toBe(false); + }, function () { + expect(called).toBe(false); + }); + }); + }); +}); + + +describe("done", function () { + describe("when the promise is fulfilled", function () { + describe("and the callback does not throw", function () { + it("should call the callback and return nothing", function () { + var called = false; + + var promise = Q(); + + var returnValue = promise.done(function () { + called = true; + }); + + return promise.fail(function () { }).fin(function () { + expect(called).toBe(true); + expect(returnValue).toBe(undefined); + }); + }); + }); + + describe("and the callback throws", function () { + it("should rethrow that error in the next turn and return nothing", function () { + var turn = 0; + Q.nextTick(function () { + ++turn; + }); + + var returnValue = Q().done( + function () { + throw "foo"; + } + ); + + var deferred = Q.defer(); + Q.onerror = function (error) { + expect(turn).toBe(1); + expect(error).toBe("foo"); + expect(returnValue).toBe(undefined); + deferred.resolve(); + }; + Q.delay(100).then(deferred.reject); + + return deferred.promise; + }); + }); + }); + + describe("when the promise is rejected", function () { + describe("and the errback handles it", function () { + it("should call the errback and return nothing", function () { + var called = false; + + var promise = Q.reject(new Error()); + + var returnValue = promise.done( + function () { }, + function () { + called = true; + } + ); + + return promise.fail(function () { }).fin(function () { + expect(called).toBe(true); + expect(returnValue).toBe(undefined); + }); + }); + }); + + describe("and the errback throws", function () { + it("should rethrow that error in the next turn and return nothing", function () { + var turn = 0; + Q.nextTick(function () { + ++turn; + }); + + var returnValue = Q.reject("bar").done( + null, + function () { + throw "foo"; + } + ); + + var deferred = Q.defer(); + Q.onerror = function (error) { + expect(turn).toBe(1); + expect(error).toBe("foo"); + expect(returnValue).toBe(undefined); + deferred.resolve(); + }; + Q.delay(100).then(deferred.reject); + + return deferred.promise; + }); + }); + + describe("and there is no errback", function () { + it("should throw the original error in the next turn", function () { + var turn = 0; + Q.nextTick(function () { + ++turn; + }); + + var returnValue = Q.reject("bar").done(); + + var deferred = Q.defer(); + Q.onerror = function (error) { + expect(turn).toBe(1); + expect(error).toBe("bar"); + expect(returnValue).toBe(undefined); + deferred.resolve(); + }; + Q.delay(10).then(deferred.reject); + + return deferred.promise; + }); + }); + }); + + it("should attach a progress listener", function () { + var deferred = Q.defer(); + + var spy = jasmine.createSpy(); + deferred.promise.done(null, null, spy); + + deferred.notify(10); + deferred.resolve(); + + return deferred.promise.then(function () { + expect(spy).toHaveBeenCalledWith(10); + }); + }); +}); + +describe("timeout", function () { + it("should do nothing if the promise fulfills quickly", function () { + return Q.delay(10).timeout(200); + }); + + it("should do nothing if the promise rejects quickly", function () { + var goodError = new Error("haha!"); + return Q.delay(10) + .then(function () { + throw goodError; + }) + .timeout(200) + .then(undefined, function (error) { + expect(error).toBe(goodError); + }); + }); + + it("should reject with a timeout error if the promise is too slow", function () { + return Q.delay(100) + .timeout(10) + .then( + function () { + expect(true).toBe(false); + }, + function (error) { + expect(/time/i.test(error.message)).toBe(true); + } + ); + }); + + it("should pass through progress notifications", function () { + var deferred = Q.defer(); + + var progressValsSeen = []; + var promise = Q.timeout(deferred.promise, 300).then(function () { + expect(progressValsSeen).toEqual([1, 2, 3]); + }, undefined, function (progressVal) { + progressValsSeen.push(progressVal); + }); + + Q.delay(5).then(function () { deferred.notify(1); }); + Q.delay(15).then(function () { deferred.notify(2); }); + Q.delay(25).then(function () { deferred.notify(3); }); + Q.delay(35).then(function () { deferred.resolve(); }); + + return promise; + }); + + it("should reject with a custom timeout error if the promise is too slow and msg was provided", function () { + return Q.delay(100) + .timeout(10, "custom") + .then( + function () { + expect(true).toBe(false); + }, + function (error) { + expect(/custom/i.test(error.message)).toBe(true); + expect(error.code).toBe("ETIMEDOUT"); + } + ); + }); + + it("should reject with a custom timeout error if the promise is too slow and Error object was provided", function () { + var customError = new Error("custom"); + customError.isCustom = true; + return Q.delay(100) + .timeout(10, customError) + .then( + function () { + expect(true).toBe(false); + }, + function (error) { + expect(/custom/i.test(error.message)).toBe(true); + expect(error.isCustom).toBe(true); + } + ); + }); + +}); + +describe("delay", function () { + it("should delay fulfillment", function () { + var promise = Q(5).delay(50); + + setTimeout(function () { + expect(promise.isPending()).toBe(true); + }, 40); + + return promise; + }); + + it("should not delay rejection", function () { + var promise = Q.reject(5).delay(50); + + return Q.delay(20).then(function () { + expect(promise.isPending()).toBe(false); + }); + }); + + it("should treat a single argument as a time", function () { + var promise = Q.delay(50); + + setTimeout(function () { + expect(promise.isPending()).toBe(true); + }, 40); + + return promise; + }); + + it("should treat two arguments as a value + a time", function () { + var promise = Q.delay("what", 50); + + setTimeout(function () { + expect(promise.isPending()).toBe(true); + }, 40); + + return promise.then(function (value) { + expect(value).toBe("what"); + }); + }); + + it("should delay after resolution", function () { + var promise1 = Q.delay("what", 30); + var promise2 = promise1.delay(30); + + setTimeout(function () { + expect(promise1.isPending()).toBe(false); + expect(promise2.isPending()).toBe(true); + }, 40); + + return promise2.then(function (value) { + expect(value).toBe("what"); + }); + }); + + + it("should pass through progress notifications from passed promises", function () { + var deferred = Q.defer(); + + var progressValsSeen = []; + var promise = Q.delay(deferred.promise, 100).then(function () { + expect(progressValsSeen).toEqual([1, 2, 3]); + }, undefined, function (progressVal) { + progressValsSeen.push(progressVal); + }); + + Q.delay(5).then(function () { deferred.notify(1); }); + Q.delay(15).then(function () { deferred.notify(2); }); + Q.delay(25).then(function () { deferred.notify(3); }); + Q.delay(35).then(function () { deferred.resolve(); }); + + return promise; + }); +}); + +describe("thenResolve", function () { + describe("Resolving with a non-thenable value", function () { + it("returns a promise for that object once the promise is resolved", function () { + var waited = false; + return Q.delay(20) + .then(function () { + waited = true; + }) + .thenResolve("foo") + .then(function (val) { + expect(waited).toBe(true); + expect(val).toBe("foo"); + }); + }); + + describe("based off a rejected promise", function () { + it("does nothing, letting the rejection flow through", function () { + return Q.reject("boo") + .thenResolve("foo") + .then( + function () { + expect(true).toBe(false); + }, + function (reason) { + expect(reason).toBe("boo"); + } + ); + }); + }); + }); + + describe("Resolving with an promise", function () { + it("returns a promise for the result of that promise once the promise is resolved", function () { + var waited = false; + return Q.delay(20) + .then(function () { + waited = true; + }) + .thenResolve(Q("foo")) + .then(function (val) { + expect(waited).toBe(true); + expect(val).toBe("foo"); + }); + }); + }); +}); + +describe("thenReject", function () { + describe("Rejecting with a reason", function () { + it("returns a promise rejected with that object once the original promise is resolved", function () { + var waited = false; + return Q.delay(20) + .then(function () { + waited = true; + }) + .thenReject("foo") + .then( + function () { + expect(true).toBe(false); + }, + function (reason) { + expect(waited).toBe(true); + expect(reason).toBe("foo"); + } + ); + }); + + describe("based off a rejected promise", function () { + it("does nothing, letting the rejection flow through", function () { + return Q.reject("boo") + .thenResolve("foo") + .then( + function () { + expect(true).toBe(false); + }, + function (reason) { + expect(reason).toBe("boo"); + } + ); + }); + }); + }); +}); + +describe("thenables", function () { + + it("assimilates a thenable with fulfillment with resolve", function () { + return Q({ + then: function (resolved) { + resolved(10); + } + }) + .then(function (ten) { + expect(ten).toEqual(10); + }) + .then(function (undefined) { + expect(undefined).toEqual(void 0); + }); + }); + + it("assimilates a thenable with progress and fulfillment (using resolve)", function () { + var progressValueArrays = []; + return Q({ + then: function (fulfilled, rejected, progressed) { + Q.nextTick(function () { + progressed(1, 2); + progressed(3, 4, 5); + fulfilled(); + }); + } + }) + .progress(function () { + progressValueArrays.push(Array.prototype.slice.call(arguments)); + }) + .then(function () { + expect(progressValueArrays).toEqual([[1], [3]]); + }); + }); + + it("assimilates a thenable with progress and fulfillment (using when)", function () { + var progressValueArrays = []; + return Q.when({ + then: function (fulfilled, rejected, progressed) { + Q.nextTick(function () { + progressed(1, 2); + progressed(3, 4, 5); + fulfilled(); + }); + } + }) + .progress(function () { + progressValueArrays.push(Array.prototype.slice.call(arguments)); + }) + .then(function () { + expect(progressValueArrays).toEqual([[1], [3]]); + }); + }); + + it("flows fulfillment into a promise pipeline", function () { + return Q({ + then: function (resolved) { + resolved([10]); + } + }) + .get(0) + .then(function (ten) { + expect(ten).toEqual(10); + }); + }); + + it("assimilates an immediately-fulfilled thenable in allSettled", function () { + return Q.allSettled([ + {then: function (win) { + win(10); + }} + ]) + .then(function (snapshots) { + expect(snapshots).toEqual([{ state: "fulfilled", value: 10 }]); + }); + }); + + it("assimilates an eventually-fulfilled thenable in allSettled", function () { + return Q.allSettled([ + {then: function (win) { + setTimeout(function () { + win(10); + }, 100); + }} + ]) + .then(function (snapshots) { + expect(snapshots).toEqual([{ state: "fulfilled", value: 10 }]); + }); + }); + +}); + +describe("node support", function () { + + var exception = new Error("That is not your favorite color."); + + var obj = { + method: function (a, b, c, callback) { + callback(null, a + b + c); + }, + thispChecker: function (callback) { + callback(null, this === obj); + }, + errorCallbacker: function (a, b, c, callback) { + callback(exception); + }, + errorThrower: function () { + throw exception; + } + }; + + describe("nfapply", function () { + + it("fulfills with callback result", function () { + return Q.nfapply(function (a, b, c, callback) { + callback(null, a + b + c); + }, [1, 2, 3]) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + it("rejects with callback error", function () { + var exception = new Error("That is not your favorite color."); + return Q.nfapply(function (a, b, c, callback) { + callback(exception); + }, [1, 2, 3]) + .then(function () { + expect(true).toBe(false); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + }); + + describe("nfcall", function () { + it("fulfills with callback result", function () { + return Q.nfcall(function (a, b, c, callback) { + callback(null, a + b + c); + }, 1, 2, 3) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + it("rejects with callback error", function () { + var exception = new Error("That is not your favorite color."); + return Q.nfcall(function (a, b, c, callback) { + callback(exception); + }, 1, 2, 3) + .then(function () { + expect(true).toBe(false); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + }); + + describe("nfbind", function () { + + it("mixes partial application with complete application", function () { + return Q.nfbind(function (a, b, c, d, callback) { + callback(null, a + b + c + d); + }, 1, 2).call({}, 3, 4) + .then(function (ten) { + expect(ten).toBe(10); + }); + }); + + }); + + describe("nbind", function () { + + it("binds this, and mixes partial application with complete application", function () { + return Q.nbind(function (a, b, c, callback) { + callback(null, this + a + b + c); + }, 1, 2).call(3 /* effectively ignored as fn bound to 1 */, 4, 5) + .then(function (twelve) { + expect(twelve).toBe(12); + }); + }); + + it("second arg binds this", function() { + var expectedThis = { test: null }; + + return Q.nbind(function(callback) { + callback(null, this); + }, expectedThis).call() + .then(function(actualThis) { + expect(actualThis).toEqual(expectedThis); + }); + }); + + }); + + describe("npost", function () { + + it("fulfills with callback result", function () { + return Q.npost(obj, "method", [1, 2, 3]) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + it("gets the correct thisp", function () { + return Q.npost(obj, "thispChecker", []) + .then(function (result) { + expect(result).toBe(true); + }); + }); + + it("rejects with callback error", function () { + return Q.npost(obj, "errorCallbacker", [1, 2, 3]) + .then(function () { + expect("blue").toBe("no, yellow!"); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + it("rejects with thrown error", function () { + return Q.npost(obj, "errorThrower", [1, 2, 3]) + .then(function () { + expect(true).toBe(false); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + it("works on promises for objects with Node methods", function () { + return Q(obj) + .npost("method", [1, 2, 3]) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + }); + + describe("nsend", function () { + + it("fulfills with callback result", function () { + return Q.nsend(obj, "method", 1, 2, 3) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + it("gets the correct thisp", function () { + return Q.nsend(obj, "thispChecker") + .then(function (result) { + expect(result).toBe(true); + }); + }); + + it("rejects with callback error", function () { + return Q.nsend(obj, "errorCallbacker", 1, 2, 3) + .then(function () { + expect("blue").toBe("no, yellow!"); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + it("rejects with thrown error", function () { + return Q.nsend(obj, "errorThrower", 1, 2, 3) + .then(function () { + expect(true).toBe(false); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + it("works on promises for objects with Node methods", function () { + return Q(obj) + .nsend("method", 1, 2, 3) + .then(function (sum) { + expect(sum).toEqual(6); + }); + }); + + }); + + describe("deferred.makeNodeResolver", function () { + + it("fulfills a promise with a single callback argument", function () { + var deferred = Q.defer(); + var callback = deferred.makeNodeResolver(); + callback(null, 10); + return deferred.promise.then(function (value) { + expect(value).toBe(10); + }); + }); + + it("fulfills a promise with multiple callback arguments", function () { + var deferred = Q.defer(); + var callback = deferred.makeNodeResolver(); + callback(null, 10, 20); + return deferred.promise.then(function (value) { + expect(value).toEqual([10, 20]); + }); + }); + + it("rejects a promise", function () { + var deferred = Q.defer(); + var callback = deferred.makeNodeResolver(); + var exception = new Error("Holy Exception of Anitoch"); + callback(exception); + return deferred.promise.then(function () { + expect(5).toBe(3); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + + }); + + describe("nodeify", function () { + + it("calls back with a resolution", function () { + var spy = jasmine.createSpy(); + Q(10).nodeify(spy); + waitsFor(function () { + return spy.argsForCall.length; + }); + runs(function () { + expect(spy.argsForCall).toEqual([[null, 10]]); + }); + }); + + it("calls back with an error", function () { + var spy = jasmine.createSpy(); + Q.reject(10).nodeify(spy); + waitsFor(function () { + return spy.argsForCall.length; + }); + runs(function () { + expect(spy.argsForCall).toEqual([[10]]); + }); + }); + + it("forwards a promise", function () { + return Q(10).nodeify().then(function (ten) { + expect(ten).toBe(10); + }); + }); + + }); + +}); + +describe("browser support", function () { + var _Q; + + beforeEach(function() { + _Q = Q; + }); + + afterEach(function() { + Q = _Q; + }); + + it("sets the global Q object to its original value", function() { + if (typeof window !== 'undefined') { + // If window is not undefined, the tests are running in the browser + // assert that Q.noConflict returns window.Q to it's initial value + // In this context the original value of Q is undefined + Q.noConflict(); + expect(Q).toEqual(undefined); + } + }); + + it("throws an error if Q.noConflict is called in node", function () { + if (typeof window === 'undefined') { + // If window is undefined the tests are being run in node, and + // Q.noConflict should throw an error + expect(Q.noConflict).toThrow(); + } + }); +}); + +describe("isPromise", function () { + it("returns true if passed a promise", function () { + expect(Q.isPromise(Q(10))).toBe(true); + }); + + it("returns false if not passed a promise", function () { + expect(Q.isPromise(undefined)).toBe(false); + expect(Q.isPromise(null)).toBe(false); + expect(Q.isPromise(10)).toBe(false); + expect(Q.isPromise("str")).toBe(false); + expect(Q.isPromise("")).toBe(false); + expect(Q.isPromise(true)).toBe(false); + expect(Q.isPromise(false)).toBe(false); + expect(Q.isPromise({})).toBe(false); + expect(Q.isPromise({ + then: function () {} + })).toBe(false); + expect(Q.isPromise(function () {})).toBe(false); + }); +}); + +describe("isPromiseAlike", function () { + it("returns true if passed a promise like object", function () { + expect(Q.isPromiseAlike(Q(10))).toBe(true); + expect(Q.isPromiseAlike({ + then: function () {} + })).toBe(true); + }); + + it("returns false if not passed a promise like object", function () { + expect(Q.isPromiseAlike(undefined)).toBe(false); + expect(Q.isPromiseAlike(null)).toBe(false); + expect(Q.isPromiseAlike(10)).toBe(false); + expect(Q.isPromiseAlike("str")).toBe(false); + expect(Q.isPromiseAlike("")).toBe(false); + expect(Q.isPromiseAlike(true)).toBe(false); + expect(Q.isPromiseAlike(false)).toBe(false); + expect(Q.isPromiseAlike({})).toBe(false); + expect(Q.isPromiseAlike(function () {})).toBe(false); + }); +}); + +if (typeof require === "function") { + var domain; + try { + domain = require("domain"); + } catch (e) { } + + if (domain) { + var EventEmitter = require("events").EventEmitter; + + describe("node domain support", function () { + var d; + + beforeEach(function () { + d = domain.create(); + }); + + it("should work for non-promise async inside a promise handler", + function (done) { + var error = new Error("should be caught by the domain"); + + d.run(function () { + Q().then(function () { + setTimeout(function () { + throw error; + }, 10); + }); + }); + + var errorTimeout = setTimeout(function () { + done(new Error("Wasn't caught")); + }, 100); + + d.on("error", function (theError) { + expect(theError).toBe(error); + clearTimeout(errorTimeout); + done(); + }); + }); + + it("should transfer errors from `done` into the domain", + function (done) { + var error = new Error("should be caught by the domain"); + + d.run(function () { + Q.reject(error).done(); + }); + + var errorTimeout = setTimeout(function () { + done(new Error("Wasn't caught")); + }, 100); + + d.on("error", function (theError) { + expect(theError).toBe(error); + clearTimeout(errorTimeout); + done(); + }); + }); + + it("should take care of re-used event emitters", function (done) { + // See discussion in https://github.com/kriskowal/q/issues/120 + var error = new Error("should be caught by the domain"); + + var e = new EventEmitter(); + + d.run(function () { + callAsync().done(); + }); + setTimeout(function () { + e.emit("beep"); + }, 100); + + var errorTimeout = setTimeout(function () { + done(new Error("Wasn't caught")); + }, 500); + + d.on("error", function (theError) { + expect(theError).toBe(error); + clearTimeout(errorTimeout); + done(); + }); + + function callAsync() { + var def = Q.defer(); + e.once("beep", function () { + def.reject(error); + }); + return def.promise; + } + }); + }); + } +} + +describe("decorator functions", function () { + describe("promised", function () { + var exception = new Error("That is not the meaning of life."); + it("resolves promised arguments", function () { + var sum = Q.promised(function add(a, b) { + return a + b; + }); + return sum(Q(4), Q(5)).then(function (sum) { + expect(sum).toEqual(9); + }); + }); + it("resolves promised `this`", function () { + var inc = Q.promised(function inc(a) { + return this + a; + }); + return inc.call(Q(4), Q(5)).then(function (sum) { + expect(sum).toEqual(9); + }); + }); + it("is rejected if an argument is rejected", function () { + var sum = Q.promised(function add(a, b) { + return a + b; + }); + return sum(Q.reject(exception), Q(4)).then(function () { + expect(4).toEqual(42); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + it("is rejected if `this` is rejected", function () { + var inc = Q.promised(function inc(a) { + return this + a; + }); + return inc.call(Q.reject(exception), Q(4)).then(function () { + expect(4).toEqual(42); + }, function (_exception) { + expect(_exception).toBe(exception); + }); + }); + }); +}); + +describe("stack trace formatting", function () { + it("doesn't mangle a stack trace that gets handled twice", function () { + var d1 = Q.defer(); + var d2 = Q.defer(); + var captured = []; + d1.promise.done(); + d2.promise.done(); + + Q.onerror = function (err) { + captured.push(err.stack); + }; + + var error = new Error("boom!"); + d1.reject(error); + d2.reject(error); + + return Q.all([d1.promise.fail(function () {}), d2.promise.fail(function () { })]) + .then(function () { + expect(captured[0]).toEqual(captured[1]); + }); + }); +}); + +describe("long stack traces", function () { + beforeEach(function () { + Q.longStackSupport = true; + }); + + afterEach(function () { + Q.longStackSupport = false; + }); + + it("include all the calling functions", function () { + function func1() { + return Q().then(function () { return func2(); }); + } + function func2() { + return new Q.Promise(function (resolve, reject) { + func3().then(resolve, reject); + }); + } + function func3() { + return new Q.Promise(function (resolve, reject) { + setTimeout(function () { + reject(new Error(REASON)); + }, 0); + }); + } + + return func1() + .catch(function (err) { + expect(err.stack).toMatch(/func3(.|\n)*func2(.|\n)*func1/); + }); + }); + + it("does not duplicate lines when rethrowing an error", function () { + function func1() { + return func2() + .catch(function rethrow (err) {throw err;}) + .catch(function rethrow (err) {throw err;}); + } + function func2() { + return Q().then(function () { + return func3(); + }); + } + function func3() { + return Q.reject(new Error(REASON)); + } + + return func1() + .catch(function (err) { + expect(err.stack).toMatch(/func3(.|\n)*func2(.|\n)*func1/); + expect(err.stack.match(/func1/g).length).toBe(1); + }); + }); + + it("does not add visible properties to thrown errors", function () { + return Q().then(function () { throw new Error(REASON); }) + .catch(function (err) { + var keys = []; + for (var key in err) { + keys.push(key); + } + expect(keys.length).toBe(0); + }); + }); +}); + +describe("possible regressions", function () { + + describe("gh-9", function () { + it("treats falsy values as resolved values without error", function () { + expect(Q.isPending(null)).toEqual(false); + expect(Q.isPending(void 0)).toEqual(false); + expect(Q.isPending(false)).toEqual(false); + expect(Q.isPending()).toEqual(false); + }); + }); + + describe("gh-22", function () { + it("ensures that the array prototype is intact", function () { + var keys = []; + for (var key in []) { + keys.push(key); + } + expect(keys.length).toBe(0); + }); + }); + + describe("gh-73", function () { + it("does not choke on non-error rejection reasons", function () { + Q.reject(REASON).done(); + + var deferred = Q.defer(); + + Q.onerror = function (error) { + expect(error).toBe(REASON); + deferred.resolve(); + }; + Q.delay(10).then(deferred.reject); + + return deferred.promise; + }); + }); + + describe("gh-90", function () { + it("does not choke on rejection reasons with an undefined `stack`", function () { + var error = new RangeError(REASON); + error.stack = undefined; + Q.reject(error).done(); + + var deferred = Q.defer(); + + Q.onerror = function (theError) { + expect(theError).toBe(error); + deferred.resolve(); + }; + Q.delay(10).then(deferred.reject); + + return deferred.promise; + }); + }); + + describe("gh-75", function () { + it("does not double-resolve misbehaved promises", function () { + var badPromise = Q.makePromise({ + post: function () { return "hello"; } + }); + + var resolutions = 0; + function onResolution() { + ++resolutions; + } + + return Q.when(badPromise, onResolution, onResolution).then(function () { + expect(resolutions).toBe(1); + }); + }); + }); + +}); + +describe("unhandled rejection reporting", function () { + beforeEach(function () { + Q.resetUnhandledRejections(); + }); + + it("doesn't report a resolve, then reject (gh-252)", function () { + var deferred = Q.defer(); + deferred.resolve(); + deferred.reject(); + + expect(Q.getUnhandledReasons().length).toEqual(0); + }); + + it("doesn't report when you chain off a rejection", function () { + return Q.reject("this will be handled").get("property").fail(function () { + // now it should be handled. + }).fin(function() { + expect(Q.getUnhandledReasons().length).toEqual(0); + }); + }); + + it("reports the most basic case", function () { + Q.reject("a reason"); + + expect(Q.getUnhandledReasons()).toEqual(["(no stack) a reason"]); + }); + + it("reports a stack trace", function () { + var error = new Error("a reason"); + Q.reject(error); + + expect(Q.getUnhandledReasons()).toEqual([error.stack]); + }); + + it("doesn't let you mutate the internal array", function () { + Q.reject("a reason"); + + Q.getUnhandledReasons().length = 0; + expect(Q.getUnhandledReasons()).toEqual(["(no stack) a reason"]); + }); + + it("resets after calling `Q.resetUnhandledRejections`", function () { + Q.reject("a reason"); + + Q.resetUnhandledRejections(); + expect(Q.getUnhandledReasons()).toEqual([]); + }); + + it("stops tracking after calling `Q.stopUnhandledRejectionTracking`", function () { + Q.reject("a reason"); + + Q.stopUnhandledRejectionTracking(); + + Q.reject("another reason"); + + expect(Q.getUnhandledReasons()).toEqual([]); + }); +}); diff --git a/modules/q-master/spec/queue-spec.js b/modules/q-master/spec/queue-spec.js new file mode 100644 index 0000000..4cec14e --- /dev/null +++ b/modules/q-master/spec/queue-spec.js @@ -0,0 +1,180 @@ + +var Q = require("../q"); +var Queue = require("../queue"); + +global.Q = Q; +require("./lib/jasmine-promise"); + +describe("queue", function () { + + it("should enqueue then dequeue", function () { + var queue = Queue(); + queue.put(1); + return queue.get().then(function (value) { + expect(value).toBe(1); + }); + }); + + it("should dequeue then enqueue", function () { + var queue = Queue(); + var promise = queue.get().then(function (value) { + expect(value).toBe(1); + }); + queue.put(1); + return promise; + }); + + it("should stream", function () { + var queue = Queue(); + + Q.try(function () { + return Q.delay(20).then(function () { + queue.put(1); + }) + }) + .then(function () { + return Q.delay(20).then(function () { + queue.put(2); + }) + }) + .then(function () { + return Q.delay(20).then(function () { + queue.put(3); + }) + }) + .done(); + + return Q.try(function () { + return queue.get() + .then(function (value) { + expect(value).toBe(1); + }); + }) + .then(function () { + return queue.get() + .then(function (value) { + expect(value).toBe(2); + }); + }) + .then(function () { + return queue.get() + .then(function (value) { + expect(value).toBe(3); + }); + }) + + }); + + it("should be order agnostic", function () { + var queue = Queue(); + + Q.try(function () { + return Q.delay(20).then(function () { + queue.put(1); + }) + }) + .then(function () { + return Q.delay(20).then(function () { + queue.put(2); + }) + }) + .then(function () { + return Q.delay(20).then(function () { + queue.put(3); + }) + }) + .done(); + + return Q.all([ + queue.get() + .then(function (value) { + expect(value).toBe(1); + }), + queue.get() + .then(function (value) { + expect(value).toBe(2); + }), + queue.get() + .then(function (value) { + expect(value).toBe(3); + }) + ]); + }); + + it("should close", function () { + + var queue = Queue(); + + Q.try(function () { + return Q.delay(20).then(function () { + queue.put(1); + }) + }) + .then(function () { + return Q.delay(20).then(function () { + queue.put(2); + }) + }) + .then(function () { + queue.close(); + }) + .done(); + + return Q.try(function () { + return queue.get() + .then(function (value) { + expect(value).toBe(1); + }); + }) + .then(function () { + return queue.get() + .then(function (value) { + expect(value).toBe(2); + }); + }) + .then(function () { + return queue.get() + .then(function (value) { + expect(false).toBe(true); // should not get here + }); + }) + .catch(function (error) { + expect(error.message).toBe("Can't get value from closed queue"); + return queue.get(); + }) + .catch(function (error) { + expect(error.message).toBe("Can't get value from closed queue"); + }) + .then(function () { + return queue.closed; + }) + .then(function (error) { + expect(error.message).toBe("Can't get value from closed queue"); + }) + }); + + it("should close with alternate error", function () { + + var queue = Queue(); + queue.close(new Error("Alternate reason")); + + return Q.try(function () { + return queue.get(); + }) + .catch(function (error) { + expect(error.message).toBe("Alternate reason"); + return queue.get(); + }) + .catch(function (error) { + expect(error.message).toBe("Alternate reason"); + }) + .then(function () { + return queue.closed; + }) + .then(function (error) { + expect(error.message).toBe("Alternate reason"); + }) + }); + +}); + diff --git a/package-lock.json b/package-lock.json index 898c5c0..0aaa2cb 100644 --- a/package-lock.json +++ b/package-lock.json @@ -5,46 +5,100 @@ "requires": true, "dependencies": { "7zip-bin": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-4.1.0.tgz", - "integrity": "sha512-AsnBZN3a8/JcNt+KPkGGODaA4c7l3W5+WpeKgGSbstSLxqWtTXqd1ieJGBQ8IFCtRg8DmmKUcSkIkUc0A4p3YA==", + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.0.3.tgz", + "integrity": "sha512-GLyWIFBbGvpKPGo55JyRZAo4lVbnBiD52cKlw/0Vt+wnmKvWJkpZvsjVoaIolyBXDeAQKSicRtqFNPem9w0WYA==", "dev": true }, + "@develar/schema-utils": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.1.0.tgz", + "integrity": "sha512-qjCqB4ctMig9Gz5bd6lkdFr3bO6arOdQqptdBSpF1ZpCnjofieCciEzkoS9ujY9cMGyllYSCSmBJ3x9OKHXzoA==", + "dev": true, + "requires": { + "ajv": "^6.1.0", + "ajv-keywords": "^3.1.0" + } + }, + "@electron/get": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/@electron/get/-/get-1.9.0.tgz", + "integrity": "sha512-OBIKtF6ttIJotDXe4KJMUyTBO4xMii+mFjlA8R4CORuD4HvCUaCK3lPjhdTRCvuEv6gzWNbAvd9DNBv0v780lw==", + "requires": { + "debug": "^4.1.1", + "env-paths": "^2.2.0", + "fs-extra": "^8.1.0", + "global-agent": "^2.0.2", + "global-tunnel-ng": "^2.7.1", + "got": "^9.6.0", + "progress": "^2.0.3", + "sanitize-filename": "^1.6.2", + "sumchecker": "^3.0.1" + } + }, "@sindresorhus/is": { "version": "0.14.0", "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz", - "integrity": "sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==", - "dev": true + "integrity": "sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==" }, "@szmarczak/http-timer": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz", "integrity": "sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==", - "dev": true, "requires": { "defer-to-connect": "^1.0.1" } }, + "@types/color-name": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@types/color-name/-/color-name-1.1.1.tgz", + "integrity": "sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ==", + "dev": true + }, "@types/debug": { "version": "4.1.5", "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.5.tgz", "integrity": "sha512-Q1y515GcOdTHgagaVFhHnIFQ38ygs/kmxdNpvpou+raI9UO3YZcHDngBSYKQklcKlvA7iuQlmIKbzvmxcOE9CQ==", "dev": true }, + "@types/fs-extra": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-UoOfVEzAUpeSPmjm7h1uk5MH6KZma2z2O7a75onTGjnNvAvMVrPzPL/vBbT65iIGHWj6rokwfmYcmxmlSf2uwg==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, "@types/node": { - "version": "10.17.17", - "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.17.tgz", - "integrity": "sha512-gpNnRnZP3VWzzj5k3qrpRC6Rk3H/uclhAVo1aIvwzK5p5cOrs9yEyQ8H/HBsBY0u5rrWxXEiVPQ0dEB6pkjE8Q==" + "version": "12.12.31", + "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.31.tgz", + "integrity": "sha512-T+wnJno8uh27G9c+1T+a1/WYCHzLeDqtsGJkoEdSp2X8RTh3oOCZQcUnjAx90CS8cmmADX51O0FI/tu9s0yssg==" + }, + "@types/yargs": { + "version": "15.0.4", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-15.0.4.tgz", + "integrity": "sha512-9T1auFmbPZoxHz0enUFlUuKRy3it01R+hlggyVUMtnCTQRunsQYifnSGb8hET4Xo8yiC0o0r1paW3ud5+rbURg==", + "dev": true, + "requires": { + "@types/yargs-parser": "*" + } + }, + "@types/yargs-parser": { + "version": "15.0.0", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-15.0.0.tgz", + "integrity": "sha512-FA/BWv8t8ZWJ+gEOnLLd8ygxH/2UFbAvgEonyfN6yWGLKc7zVjbpl2Y4CTjid9h2RfgPP6SEt6uHwEOply00yw==", + "dev": true }, "ajv": { - "version": "5.5.2", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", - "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "version": "6.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.0.tgz", + "integrity": "sha512-D6gFiFA0RRLyUbvijN74DWAjXSFxWKaWP7mldxkVhyhAV3+SWA9HEJPHQ2c9soIeTFJqcSdFDGFgdqs1iUU2Hw==", "requires": { - "co": "^4.6.0", - "fast-deep-equal": "^1.0.0", + "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.3.0" + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" } }, "ajv-keywords": { @@ -99,75 +153,63 @@ "ansi-regex": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", - "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=", + "dev": true }, "ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.2.1.tgz", + "integrity": "sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==", "dev": true, "requires": { - "color-convert": "^1.9.0" + "@types/color-name": "^1.1.1", + "color-convert": "^2.0.1" } }, "app-builder-bin": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-2.7.1.tgz", - "integrity": "sha512-ubIBeiL9XysjMW4HETBKxj3DC8ika6dGyC0vftPc0kZwGh1iXQ5bycsjoAqY/3t3BBEEIg0VruicvBaUl1pOSQ==", + "version": "3.5.5", + "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-3.5.5.tgz", + "integrity": "sha512-ZcHzJ9Xl+azPqdKzXZKdRZmkNmbxHHZyl4cbobNf8qMQpoPChpcov8riVrZSbu/0cT/JqJ8LOwJjy1OAwbChaQ==", "dev": true }, "app-builder-lib": { - "version": "20.44.4", - "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-20.44.4.tgz", - "integrity": "sha512-1K1xfrhyqDgnibwyuYMgvfwGilGLMF31YwOUJ8IXreyjRef9lUjWW+BZuBXqk4Uqd0C0EYPjhofgpuN0WoAQ+A==", + "version": "22.4.1", + "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-22.4.1.tgz", + "integrity": "sha512-epwUzIM+2pcdy/If9koTP74CKx4v7xGPj75a2Z5cM4rrGN9yVZ3eDUBbfF0e0qE4Qmcv5pd0BAZJ26bGm8NWsQ==", "dev": true, "requires": { - "7zip-bin": "~4.1.0", - "app-builder-bin": "2.7.1", + "7zip-bin": "~5.0.3", + "@develar/schema-utils": "~2.1.0", "async-exit-hook": "^2.0.1", "bluebird-lst": "^1.0.9", - "builder-util": "10.1.2", - "builder-util-runtime": "8.2.5", + "builder-util": "22.4.1", + "builder-util-runtime": "8.6.2", "chromium-pickle-js": "^0.2.0", "debug": "^4.1.1", - "ejs": "^2.6.2", - "electron-osx-sign": "0.4.11", - "electron-publish": "20.44.4", - "fs-extra-p": "^8.0.2", - "hosted-git-info": "^2.7.1", + "ejs": "^3.0.1", + "electron-publish": "22.4.1", + "fs-extra": "^8.1.0", + "hosted-git-info": "^3.0.4", "is-ci": "^2.0.0", - "isbinaryfile": "^4.0.1", + "isbinaryfile": "^4.0.4", "js-yaml": "^3.13.1", "lazy-val": "^1.0.4", "minimatch": "^3.0.4", "normalize-package-data": "^2.5.0", - "plist": "^3.0.1", - "read-config-file": "3.2.2", - "sanitize-filename": "^1.6.1", - "semver": "^6.1.1", - "temp-file": "^3.3.3" + "read-config-file": "5.0.2", + "sanitize-filename": "^1.6.3", + "semver": "^7.1.3", + "temp-file": "^3.3.7" }, "dependencies": { - "debug": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", - "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", + "hosted-git-info": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-3.0.4.tgz", + "integrity": "sha512-4oT62d2jwSDBbLLFLZE+1vPuQ1h8p9wjrJ8Mqx5TjsyWmBMV5B13eJqn8pvluqubLf3cJPTfiYCIwNwDNmzScQ==", "dev": true, "requires": { - "ms": "^2.1.1" + "lru-cache": "^5.1.1" } - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", - "dev": true - }, - "semver": { - "version": "6.3.0", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", - "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", - "dev": true } } }, @@ -178,12 +220,21 @@ "dev": true, "requires": { "sprintf-js": "~1.0.2" + }, + "dependencies": { + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", + "dev": true + } } }, "array-find-index": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz", - "integrity": "sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=" + "integrity": "sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=", + "dev": true }, "asn1": { "version": "0.2.4", @@ -220,14 +271,14 @@ "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" }, "aws4": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz", - "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==" + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.9.1.tgz", + "integrity": "sha512-wMHVg2EOHaMRxbzgFJ9gtjOOCrI80OHLG14rxi28XwOW8ux6IiEbRCGGGqCtdAIg4FQCbW20k9RsT4y3gJlFug==" }, "bad-words": { - "version": "1.6.4", - "resolved": "https://registry.npmjs.org/bad-words/-/bad-words-1.6.4.tgz", - "integrity": "sha512-L/ya7OHAMS/v7Ci3Nu5BVpHvJmMA7nytjloMbse0VkTvJ+kvQaSwaRMEethPQmKd3UALfS1MJF49YA1+X49KBw==", + "version": "1.6.5", + "resolved": "https://registry.npmjs.org/bad-words/-/bad-words-1.6.5.tgz", + "integrity": "sha512-KzDrzFtzS8Z+v4I+KuanePuaj7g6aRms2WYQOt7n+UugfqMPheYS7zcyTypokxMno2Ss6xfo062ya1aVrviB2g==", "requires": { "badwords-list": "^1.0.0" } @@ -243,17 +294,10 @@ "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=", "dev": true }, - "base64-js": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz", - "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g==", - "dev": true - }, "bcrypt-pbkdf": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=", - "optional": true, "requires": { "tweetnacl": "^0.14.3" } @@ -262,7 +306,6 @@ "version": "1.5.0", "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", - "dev": true, "requires": { "file-uri-to-path": "1.0.0" } @@ -282,26 +325,32 @@ "bluebird": "^3.5.5" } }, + "boolean": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.0.1.tgz", + "integrity": "sha512-HRZPIjPcbwAVQvOTxR4YE3o8Xs98NqbbL1iEZDCz7CL8ql0Lt5iOyJFxfnAB0oFs8Oh02F/lLlg30Mexv46LjA==", + "optional": true + }, "boxen": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/boxen/-/boxen-3.2.0.tgz", - "integrity": "sha512-cU4J/+NodM3IHdSL2yN8bqYqnmlBTidDR4RC7nJs61ZmtGz8VZzM3HLQX0zY5mrSmPtR3xWwsq2jOUQqFZN8+A==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/boxen/-/boxen-4.2.0.tgz", + "integrity": "sha512-eB4uT9RGzg2odpER62bBwSLvUeGC+WbRjjyyFhGsKnc8wp/m0+hQsMUvUe3H2V0D5vw0nBdO1hCJoZo5mKeuIQ==", "dev": true, "requires": { "ansi-align": "^3.0.0", "camelcase": "^5.3.1", - "chalk": "^2.4.2", + "chalk": "^3.0.0", "cli-boxes": "^2.2.0", - "string-width": "^3.0.0", - "term-size": "^1.2.0", - "type-fest": "^0.3.0", - "widest-line": "^2.0.0" + "string-width": "^4.1.0", + "term-size": "^2.1.0", + "type-fest": "^0.8.1", + "widest-line": "^3.1.0" }, "dependencies": { "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", "dev": true }, "camelcase": { @@ -310,30 +359,36 @@ "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", "dev": true }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true }, "string-width": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", - "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", "dev": true, "requires": { - "emoji-regex": "^7.0.1", - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^5.1.0" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "strip-ansi": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", - "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", "dev": true, "requires": { - "ansi-regex": "^4.1.0" + "ansi-regex": "^5.0.0" } } } @@ -348,110 +403,52 @@ "concat-map": "0.0.1" } }, - "buffer-alloc": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz", - "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==", - "dev": true, - "requires": { - "buffer-alloc-unsafe": "^1.1.0", - "buffer-fill": "^1.0.0" - } - }, - "buffer-alloc-unsafe": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz", - "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==", - "dev": true - }, "buffer-crc32": { "version": "0.2.13", "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", "integrity": "sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=" }, - "buffer-fill": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz", - "integrity": "sha1-+PeLdniYiO858gXNY39o5wISKyw=", - "dev": true - }, "buffer-from": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==" }, "builder-util": { - "version": "10.1.2", - "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-10.1.2.tgz", - "integrity": "sha512-LQMh36Cg0r4ZfKqNlaUclndS/IXxZ3OdCgmXvw1vdP3QwYT2NkyE7LfMikAFIHpXOs6zsVH+iW+Fe/AX1jfFag==", + "version": "22.4.1", + "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-22.4.1.tgz", + "integrity": "sha512-+ysLc7cC4w6P7rBxmZ5X2aU3QvcwFoWCl1us+mcUKdsGmJAtFUMPJqueeptdxjyPrPShIUOKHzA8uk5A3d1fHg==", "dev": true, "requires": { - "7zip-bin": "~4.1.0", - "@types/debug": "^4.1.4", - "app-builder-bin": "2.7.1", + "7zip-bin": "~5.0.3", + "@types/debug": "^4.1.5", + "@types/fs-extra": "^8.1.0", + "app-builder-bin": "3.5.5", "bluebird-lst": "^1.0.9", - "builder-util-runtime": "^8.2.5", - "chalk": "^2.4.2", + "builder-util-runtime": "8.6.2", + "chalk": "^3.0.0", "debug": "^4.1.1", - "fs-extra-p": "^8.0.2", + "fs-extra": "^8.1.0", "is-ci": "^2.0.0", "js-yaml": "^3.13.1", - "source-map-support": "^0.5.12", - "stat-mode": "^0.3.0", - "temp-file": "^3.3.3" - }, - "dependencies": { - "debug": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", - "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", - "dev": true - } + "source-map-support": "^0.5.16", + "stat-mode": "^1.0.0", + "temp-file": "^3.3.7" } }, "builder-util-runtime": { - "version": "8.2.5", - "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-8.2.5.tgz", - "integrity": "sha512-YILT+YUlxrE3yNB6mDC1tF+Q24mr1LSYdjP5U861jbBeDZfvy1/VPDzW3boMVrDtzYnDnvkYrzLJnoh6TXA75w==", + "version": "8.6.2", + "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-8.6.2.tgz", + "integrity": "sha512-9QnIBISfhgQ2BxtRLidVqf/v5HD73vSKZDllpUmGd2L6VORGQk7cZAPmPtw4HQM3gPBelyVJ5yIjMNZ8xjmd1A==", "dev": true, "requires": { - "bluebird-lst": "^1.0.9", "debug": "^4.1.1", - "fs-extra-p": "^8.0.2", "sax": "^1.2.4" - }, - "dependencies": { - "debug": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", - "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", - "dev": true, - "requires": { - "ms": "^2.1.1" - } - }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", - "dev": true - } } }, "cacheable-request": { "version": "6.1.0", "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-6.1.0.tgz", "integrity": "sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg==", - "dev": true, "requires": { "clone-response": "^1.0.2", "get-stream": "^5.1.0", @@ -466,7 +463,6 @@ "version": "5.1.0", "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.1.0.tgz", "integrity": "sha512-EXr1FOzrzTfGeL0gQdeFEvOMm2mzMOglyiOXSTpPC+iAjAKftbr3jpCMWynogwYnM+eSj9sHGc6wjIcDvYiygw==", - "dev": true, "requires": { "pump": "^3.0.0" } @@ -474,20 +470,21 @@ "lowercase-keys": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", - "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", - "dev": true + "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==" } } }, "camelcase": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-2.1.1.tgz", - "integrity": "sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=" + "integrity": "sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=", + "dev": true }, "camelcase-keys": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz", "integrity": "sha1-MIvur/3ygRkFHvodkyITyRuPkuc=", + "dev": true, "requires": { "camelcase": "^2.0.0", "map-obj": "^1.0.0" @@ -499,14 +496,13 @@ "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" }, "chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz", + "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==", "dev": true, "requires": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" } }, "chromium-pickle-js": { @@ -528,46 +524,52 @@ "dev": true }, "cliui": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", - "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz", + "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==", "dev": true, "requires": { - "string-width": "^3.1.0", - "strip-ansi": "^5.2.0", - "wrap-ansi": "^5.1.0" + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^6.2.0" }, "dependencies": { "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true }, "string-width": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", - "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", "dev": true, "requires": { - "emoji-regex": "^7.0.1", - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^5.1.0" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "strip-ansi": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", - "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", "dev": true, "requires": { - "ansi-regex": "^4.1.0" + "ansi-regex": "^5.0.0" } } } @@ -576,50 +578,39 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz", "integrity": "sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=", - "dev": true, "requires": { "mimic-response": "^1.0.0" } }, - "co": { - "version": "4.6.0", - "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", - "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" - }, "code-point-at": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", - "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=" + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", + "dev": true }, "color-convert": { - "version": "1.9.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", - "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, "requires": { - "color-name": "1.1.3" + "color-name": "~1.1.4" } }, "color-name": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", - "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", "dev": true }, "combined-stream": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.6.tgz", - "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", "requires": { "delayed-stream": "~1.0.0" } }, - "compare-version": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz", - "integrity": "sha1-AWLsLZNR9d3VmpICy6k1NmpyUIA=", - "dev": true - }, "concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", @@ -637,46 +628,69 @@ "typedarray": "^0.0.6" } }, + "config-chain": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.12.tgz", + "integrity": "sha512-a1eOIcu8+7lUInge4Rpf/n4Krkf3Dd9lqhljRzII1/Zno/kRtUWnznPO3jOKBmTEktkt3fkxisUcivoj0ebzoA==", + "optional": true, + "requires": { + "ini": "^1.3.4", + "proto-list": "~1.2.1" + } + }, "configstore": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/configstore/-/configstore-4.0.0.tgz", - "integrity": "sha512-CmquAXFBocrzaSM8mtGPMM/HiWmyIpr4CcJl/rgY2uCObZ/S7cKU0silxslqJejl+t/T9HS8E0PUNQD81JGUEQ==", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/configstore/-/configstore-5.0.1.tgz", + "integrity": "sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA==", "dev": true, "requires": { - "dot-prop": "^4.1.0", + "dot-prop": "^5.2.0", "graceful-fs": "^4.1.2", - "make-dir": "^1.0.0", - "unique-string": "^1.0.0", - "write-file-atomic": "^2.0.0", - "xdg-basedir": "^3.0.0" + "make-dir": "^3.0.0", + "unique-string": "^2.0.0", + "write-file-atomic": "^3.0.0", + "xdg-basedir": "^4.0.0" + }, + "dependencies": { + "make-dir": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.0.2.tgz", + "integrity": "sha512-rYKABKutXa6vXTXhoV18cBE7PaewPXHe/Bdq4v+ZLMhxbWApkFFplT0LcbMW+6BbjnQXzZ/sAvSE/JdguApG5w==", + "dev": true, + "requires": { + "semver": "^6.0.0" + } + }, + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } } }, + "core-js": { + "version": "3.6.4", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.6.4.tgz", + "integrity": "sha512-4paDGScNgZP2IXXilaffL9X7968RuvwlkK3xWtZRVqgd8SYNiVKRJvkFd1aqqEuPfN7E68ZHEp9hDj6lHj4Hyw==", + "optional": true + }, "core-util-is": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" }, - "cross-spawn": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", - "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", - "dev": true, - "requires": { - "lru-cache": "^4.0.1", - "shebang-command": "^1.2.0", - "which": "^1.2.9" - } - }, "crypto-random-string": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-1.0.0.tgz", - "integrity": "sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz", + "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==", "dev": true }, "currently-unhandled": { "version": "0.4.1", "resolved": "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz", "integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=", + "dev": true, "requires": { "array-find-index": "^1.0.1" } @@ -690,23 +704,23 @@ } }, "debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz", + "integrity": "sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==", "requires": { - "ms": "2.0.0" + "ms": "^2.1.1" } }, "decamelize": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", - "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=" + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", + "dev": true }, "decompress-response": { "version": "3.3.0", "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz", "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=", - "dev": true, "requires": { "mimic-response": "^1.0.0" } @@ -714,19 +728,34 @@ "deep-extend": { "version": "0.6.0", "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", - "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==" + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true }, "defer-to-connect": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz", - "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==", - "dev": true + "integrity": "sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ==" + }, + "define-properties": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", + "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", + "optional": true, + "requires": { + "object-keys": "^1.0.12" + } }, "delayed-stream": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" }, + "detect-node": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.0.4.tgz", + "integrity": "sha512-ZIzRpLJrOj7jjP2miAtgqIfmzbxa4ZOr5jJc601zklsfEx9oTzmmj2nVpIPRpNlRTIh8lc1kyViIY7BWSGNmKw==", + "optional": true + }, "discord-rpc": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/discord-rpc/-/discord-rpc-3.1.0.tgz", @@ -737,93 +766,100 @@ } }, "dmg-builder": { - "version": "6.7.2", - "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-6.7.2.tgz", - "integrity": "sha512-xfYOwhHjOSOIqkk8A0h8zcaio/WyzrAWpMTu9hzV3Z5PI4tOG0Pq6a9Lh/mHr1r3bydif8R21qGvKU1Re9CpUg==", + "version": "22.4.1", + "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-22.4.1.tgz", + "integrity": "sha512-hEemh7n0zoVt7zPPwvn7iOttP03oENjJ4ApttPmt8oDnX8T4q42MjGWyDlLkPMplMJfoTxkkNqmm296f0OYM8Q==", "dev": true, "requires": { - "app-builder-lib": "~20.44.4", + "app-builder-lib": "~22.4.1", "bluebird-lst": "^1.0.9", - "builder-util": "~10.1.2", - "fs-extra-p": "^8.0.2", - "iconv-lite": "^0.4.24", + "builder-util": "~22.4.1", + "fs-extra": "^8.1.0", + "iconv-lite": "^0.5.1", "js-yaml": "^3.13.1", - "parse-color": "^1.0.0", - "sanitize-filename": "^1.6.1" + "sanitize-filename": "^1.6.3" } }, "dot-prop": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-4.2.0.tgz", - "integrity": "sha512-tUMXrxlExSW6U2EXiiKGSBVdYgtV8qlHL+C10TsW4PURY/ic+eaysnSkwB4kA/mBlCyy/IKDJ+Lc3wbWeaXtuQ==", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/dot-prop/-/dot-prop-5.2.0.tgz", + "integrity": "sha512-uEUyaDKoSQ1M4Oq8l45hSE26SnTxL6snNnqvK/VWx5wJhmff5z0FUVJDKDanor/6w3kzE3i7XZOk+7wC0EXr1A==", "dev": true, "requires": { - "is-obj": "^1.0.0" + "is-obj": "^2.0.0" } }, "dotenv": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-6.2.0.tgz", - "integrity": "sha512-HygQCKUBSFl8wKQZBSemMywRWcEDNidvNbjGVyZu3nbZ8qq9ubiPoGLMdRDpfSrpkkm9BXYFkpKxxFX38o/76w==", + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.2.0.tgz", + "integrity": "sha512-8sJ78ElpbDJBHNeBzUbUVLsqKdccaa/BXF1uPTw3GrvQTBgrQrtObr2mUrE38vzYd8cEv+m/JBfDLioYcfXoaw==", "dev": true }, "dotenv-expand": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-4.2.0.tgz", - "integrity": "sha1-3vHxyl1gWdJKdm5YeULCEQbOEnU=", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-5.1.0.tgz", + "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==", "dev": true }, "duplexer3": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", - "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=", - "dev": true + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=" }, "ecc-jsbn": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=", - "optional": true, "requires": { "jsbn": "~0.1.0", "safer-buffer": "^2.1.0" } }, "ejs": { - "version": "2.7.4", - "resolved": "https://registry.npmjs.org/ejs/-/ejs-2.7.4.tgz", - "integrity": "sha512-7vmuyh5+kuUyJKePhQfRQBhXV5Ce+RnaeeQArKu1EAMpL3WbgMt5WG6uQZpEVvYSSsxMXRKOewtDk9RaTKXRlA==", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.0.1.tgz", + "integrity": "sha512-cuIMtJwxvzumSAkqaaoGY/L6Fc/t6YvoP9/VIaK0V/CyqKLEQ8sqODmYfy/cjXEdZ9+OOL8TecbJu+1RsofGDw==", "dev": true }, "electron": { "version": "4.2.12", "resolved": "https://registry.npmjs.org/electron/-/electron-4.2.12.tgz", "integrity": "sha512-EES8eMztoW8gEP5E4GQLP8slrfS2jqTYtHbu36mlu3k1xYAaNPyQQr6mCILkYxqj4l3la4CT2Vcs89CUG62vcQ==", + "dev": true, "requires": { "@types/node": "^10.12.18", "electron-download": "^4.1.0", "extract-zip": "^1.0.3" + }, + "dependencies": { + "@types/node": { + "version": "10.17.17", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.17.tgz", + "integrity": "sha512-gpNnRnZP3VWzzj5k3qrpRC6Rk3H/uclhAVo1aIvwzK5p5cOrs9yEyQ8H/HBsBY0u5rrWxXEiVPQ0dEB6pkjE8Q==", + "dev": true + } } }, "electron-builder": { - "version": "20.44.4", - "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-20.44.4.tgz", - "integrity": "sha512-H8zzP01albkKh2Ec1zc0A7RGriUkHb5M99NJskaYtgKtGATTAGH+r9OIWVk5Hk9c1dLMVudbqEeaSlygMF2asw==", + "version": "22.4.1", + "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-22.4.1.tgz", + "integrity": "sha512-13CjZcGeJS+c3EKRwFT/Oty5Niif5g1FwDioBLEbjkPCPQgxdtDsr+rJtCu9qxkiKDYpAoPS+t/clNk0efONvQ==", "dev": true, "requires": { - "app-builder-lib": "20.44.4", + "@types/yargs": "^15.0.4", + "app-builder-lib": "22.4.1", "bluebird-lst": "^1.0.9", - "builder-util": "10.1.2", - "builder-util-runtime": "8.2.5", - "chalk": "^2.4.2", - "dmg-builder": "6.7.2", - "fs-extra-p": "^8.0.2", + "builder-util": "22.4.1", + "builder-util-runtime": "8.6.2", + "chalk": "^3.0.0", + "dmg-builder": "22.4.1", + "fs-extra": "^8.1.0", "is-ci": "^2.0.0", "lazy-val": "^1.0.4", - "read-config-file": "3.2.2", - "sanitize-filename": "^1.6.1", - "update-notifier": "^3.0.0", - "yargs": "^13.2.4" + "read-config-file": "5.0.2", + "sanitize-filename": "^1.6.3", + "update-notifier": "^4.1.0", + "yargs": "^15.1.0" } }, "electron-discord-register": { @@ -833,12 +869,25 @@ "requires": { "electron": ">=1.7.16", "winreg": "^1.2.4" + }, + "dependencies": { + "electron": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/electron/-/electron-8.2.0.tgz", + "integrity": "sha512-mnV43gKCrCUMHLmGws/DU/l8LhaxrFD53A4ofwtthdCqOZWGIdk1+eMphiVumXR5a3lC64XVvmXQ2k28i7F/zw==", + "requires": { + "@electron/get": "^1.0.1", + "@types/node": "^12.0.12", + "extract-zip": "^1.0.3" + } + } } }, "electron-download": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/electron-download/-/electron-download-4.1.1.tgz", "integrity": "sha512-FjEWG9Jb/ppK/2zToP+U5dds114fM1ZOJqMAR4aXXL5CvyPE9fiqBK/9YcwC9poIFQTEJk/EM/zyRwziziRZrg==", + "dev": true, "requires": { "debug": "^3.0.0", "env-paths": "^1.0.0", @@ -855,53 +904,74 @@ "version": "3.2.6", "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, "requires": { "ms": "^2.1.1" } }, - "ms": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" - } - } - }, - "electron-osx-sign": { - "version": "0.4.11", - "resolved": "https://registry.npmjs.org/electron-osx-sign/-/electron-osx-sign-0.4.11.tgz", - "integrity": "sha512-VVd40nrnVqymvFrY9ZkOYgHJOvexHHYTR3di/SN+mjJ0OWhR1I8BRVj3U+Yamw6hnkZZNKZp52rqL5EFAAPFkQ==", - "dev": true, - "requires": { - "bluebird": "^3.5.0", - "compare-version": "^0.1.2", - "debug": "^2.6.8", - "isbinaryfile": "^3.0.2", - "minimist": "^1.2.0", - "plist": "^3.0.1" - }, - "dependencies": { - "isbinaryfile": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-3.0.3.tgz", - "integrity": "sha512-8cJBL5tTd2OS0dM4jz07wQd5g0dCCqIhUxPIGtZfa5L6hWlvV5MHTITy/DBAsF+Oe2LS1X3krBUhNwaGUWpWxw==", + "env-paths": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-1.0.0.tgz", + "integrity": "sha1-QWgTO0K7BcOKNbGuQ5fIKYqzaeA=", + "dev": true + }, + "fs-extra": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.3.tgz", + "integrity": "sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==", "dev": true, "requires": { - "buffer-alloc": "^1.2.0" + "graceful-fs": "^4.1.2", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + } + }, + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + }, + "sumchecker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-2.0.2.tgz", + "integrity": "sha1-D0LBDl0F2l1C7qPlbDOZo31sWz4=", + "dev": true, + "requires": { + "debug": "^2.2.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } } } } }, "electron-publish": { - "version": "20.44.4", - "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-20.44.4.tgz", - "integrity": "sha512-50NzsKOnNqOpGJzPl04vMyitdguUvp15FWKWtu4KISsHfgdLMWGgxHGZwfMphc/vf364zXvPHsYQza3MASgaEQ==", + "version": "22.4.1", + "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-22.4.1.tgz", + "integrity": "sha512-nwKNum3KXm+01rtWX2pc1jhazdzDy2zYnQx+zmXphZchjd6UOMX3ZN0xyZUCKugw5ZliflT6LkgbrcBXBtYD3A==", "dev": true, "requires": { + "@types/fs-extra": "^8.1.0", "bluebird-lst": "^1.0.9", - "builder-util": "~10.1.2", - "builder-util-runtime": "^8.2.5", - "chalk": "^2.4.2", - "fs-extra-p": "^8.0.2", + "builder-util": "~22.4.1", + "builder-util-runtime": "8.6.2", + "chalk": "^3.0.0", + "fs-extra": "^8.1.0", "lazy-val": "^1.0.4", "mime": "^2.4.4" } @@ -918,55 +988,58 @@ "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", "dev": true }, + "encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=", + "optional": true + }, "end-of-stream": { "version": "1.4.4", "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", - "dev": true, "requires": { "once": "^1.4.0" } }, "env-paths": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-1.0.0.tgz", - "integrity": "sha1-QWgTO0K7BcOKNbGuQ5fIKYqzaeA=" + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.0.tgz", + "integrity": "sha512-6u0VYSCo/OW6IoD5WCLLy9JUGARbamfSavcNXry/eu8aHVFei6CD3Sw+VGX5alea1i9pgPHW0mbu6Xj0uBh7gA==" }, "error-ex": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, "requires": { "is-arrayish": "^0.2.1" } }, - "escape-string-regexp": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", - "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=", + "es6-error": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz", + "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==", + "optional": true + }, + "escape-goat": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/escape-goat/-/escape-goat-2.1.1.tgz", + "integrity": "sha512-8/uIhbG12Csjy2JEW7D9pHbreaVaS/OpN3ycnyvElTdwM5n6GY6W6e2IPemfvGZeUMqZ9A/3GqIZMgKnBhAw/Q==", "dev": true }, + "escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "optional": true + }, "esprima": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", "dev": true }, - "execa": { - "version": "0.7.0", - "resolved": "https://registry.npmjs.org/execa/-/execa-0.7.0.tgz", - "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", - "dev": true, - "requires": { - "cross-spawn": "^5.0.1", - "get-stream": "^3.0.0", - "is-stream": "^1.1.0", - "npm-run-path": "^2.0.0", - "p-finally": "^1.0.0", - "signal-exit": "^3.0.0", - "strip-eof": "^1.0.0" - } - }, "extend": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", @@ -981,6 +1054,21 @@ "debug": "^2.6.9", "mkdirp": "^0.5.4", "yauzl": "^2.10.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + } } }, "extsprintf": { @@ -989,14 +1077,14 @@ "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" }, "fast-deep-equal": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", - "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=" + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.1.tgz", + "integrity": "sha512-8UEa58QDLauDNfpbrX55Q9jrGHThw2ZMdOky5Gl1CDtVeJDPVrG4Jxx1N8jw2gkWaff5UUuX1KJd+9zGe2B+ZA==" }, "fast-json-stable-stringify": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", - "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==" }, "fd-slicer": { "version": "1.1.0", @@ -1009,13 +1097,13 @@ "file-uri-to-path": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", - "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==", - "dev": true + "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==" }, "find-up": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "dev": true, "requires": { "path-exists": "^2.0.0", "pinkie-promise": "^2.0.0" @@ -1025,6 +1113,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "dev": true, "requires": { "pinkie-promise": "^2.0.0" } @@ -1037,54 +1126,25 @@ "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" }, "form-data": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.2.tgz", - "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", + "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", "requires": { "asynckit": "^0.4.0", - "combined-stream": "1.0.6", + "combined-stream": "^1.0.6", "mime-types": "^2.1.12" } }, "fs-extra": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.3.tgz", - "integrity": "sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==", + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", "requires": { - "graceful-fs": "^4.1.2", + "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, - "fs-extra-p": { - "version": "8.1.0", - "resolved": "https://registry.npmjs.org/fs-extra-p/-/fs-extra-p-8.1.0.tgz", - "integrity": "sha512-sCLpU5kk5CvrWZvFM9dUlqPgHrE02AEt6XYzF7kDscr5COc7DHfhNfODTXt0bkVNmt5DkvU2uJSYjorxY3bRKA==", - "dev": true, - "requires": { - "bluebird-lst": "^1.0.9", - "fs-extra": "^8.1.0" - }, - "dependencies": { - "fs-extra": { - "version": "8.1.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", - "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", - "dev": true, - "requires": { - "graceful-fs": "^4.2.0", - "jsonfile": "^4.0.0", - "universalify": "^0.1.0" - } - }, - "graceful-fs": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", - "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==", - "dev": true - } - } - }, "get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", @@ -1094,13 +1154,16 @@ "get-stdin": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz", - "integrity": "sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=" + "integrity": "sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=", + "dev": true }, "get-stream": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", - "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=", - "dev": true + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", + "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", + "requires": { + "pump": "^3.0.0" + } }, "getpass": { "version": "0.1.7", @@ -1110,20 +1173,55 @@ "assert-plus": "^1.0.0" } }, + "global-agent": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-2.1.8.tgz", + "integrity": "sha512-VpBe/rhY6Rw2VDOTszAMNambg+4Qv8j0yiTNDYEXXXxkUNGWLHp8A3ztK4YDBbFNcWF4rgsec6/5gPyryya/+A==", + "optional": true, + "requires": { + "boolean": "^3.0.0", + "core-js": "^3.6.4", + "es6-error": "^4.1.1", + "matcher": "^2.1.0", + "roarr": "^2.15.2", + "semver": "^7.1.2", + "serialize-error": "^5.0.0" + } + }, "global-dirs": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-0.1.1.tgz", - "integrity": "sha1-sxnA3UYH81PzvpzKTHL8FIxJ9EU=", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-2.0.1.tgz", + "integrity": "sha512-5HqUqdhkEovj2Of/ms3IeS/EekcO54ytHRLV4PEY2rhRwrHXLQjeVEES0Lhka0xwNDtGYn58wyC4s5+MHsOO6A==", "dev": true, "requires": { - "ini": "^1.3.4" + "ini": "^1.3.5" + } + }, + "global-tunnel-ng": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/global-tunnel-ng/-/global-tunnel-ng-2.7.1.tgz", + "integrity": "sha512-4s+DyciWBV0eK148wqXxcmVAbFVPqtc3sEtUE/GTQfuU80rySLcMhUmHKSHI7/LDj8q0gDYI1lIhRRB7ieRAqg==", + "optional": true, + "requires": { + "encodeurl": "^1.0.2", + "lodash": "^4.17.10", + "npm-conf": "^1.1.3", + "tunnel": "^0.0.6" + } + }, + "globalthis": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.1.tgz", + "integrity": "sha512-mJPRTc/P39NH/iNG4mXa9aIhNymaQikTrnspeCa2ZuJ+mH2QN/rXwtX3XwKrHqWgUQFbNZKtHM105aHzJalElw==", + "optional": true, + "requires": { + "define-properties": "^1.1.3" } }, "got": { "version": "9.6.0", "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz", "integrity": "sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q==", - "dev": true, "requires": { "@sindresorhus/is": "^0.14.0", "@szmarczak/http-timer": "^1.1.2", @@ -1136,23 +1234,12 @@ "p-cancelable": "^1.0.0", "to-readable-stream": "^1.0.0", "url-parse-lax": "^3.0.0" - }, - "dependencies": { - "get-stream": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz", - "integrity": "sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==", - "dev": true, - "requires": { - "pump": "^3.0.0" - } - } } }, "graceful-fs": { - "version": "4.1.11", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", - "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", + "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==" }, "har-schema": { "version": "2.0.0", @@ -1160,18 +1247,18 @@ "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" }, "har-validator": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.0.tgz", - "integrity": "sha512-+qnmNjI4OfH2ipQ9VQOw23bBd/ibtfbVdK2fYbY4acTDqKTW/YDp9McimZdDbG8iV9fZizUqQMD5xvriB146TA==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz", + "integrity": "sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==", "requires": { - "ajv": "^5.3.0", + "ajv": "^6.5.5", "har-schema": "^2.0.0" } }, "has-flag": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", - "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true }, "has-yarn": { @@ -1183,13 +1270,13 @@ "hosted-git-info": { "version": "2.8.8", "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz", - "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==" + "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==", + "dev": true }, "http-cache-semantics": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz", - "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==", - "dev": true + "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==" }, "http-signature": { "version": "1.2.0", @@ -1202,9 +1289,9 @@ } }, "iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.5.1.tgz", + "integrity": "sha512-ONHr16SQvKZNSqjQT9gy5z24Jw+uqfO02/ngBSBoqChZ+W8qXX7GPRa1RoUnzGADw8K63R1BXUMzarCVQBpY8Q==", "dev": true, "requires": { "safer-buffer": ">= 2.1.2 < 3" @@ -1226,6 +1313,7 @@ "version": "2.1.0", "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz", "integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=", + "dev": true, "requires": { "repeating": "^2.0.0" } @@ -1243,7 +1331,8 @@ "is-arrayish": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", - "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=" + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true }, "is-ci": { "version": "2.0.0", @@ -1257,46 +1346,45 @@ "is-finite": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz", - "integrity": "sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==" + "integrity": "sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==", + "dev": true }, "is-fullwidth-code-point": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "dev": true, "requires": { "number-is-nan": "^1.0.0" } }, "is-installed-globally": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.1.0.tgz", - "integrity": "sha1-Df2Y9akRFxbdU13aZJL2e/PSWoA=", + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/is-installed-globally/-/is-installed-globally-0.3.1.tgz", + "integrity": "sha512-oiEcGoQbGc+3/iijAijrK2qFpkNoNjsHOm/5V5iaeydyrS/hnwaRCEgH5cpW0P3T1lSjV5piB7S5b5lEugNLhg==", "dev": true, "requires": { - "global-dirs": "^0.1.0", - "is-path-inside": "^1.0.0" + "global-dirs": "^2.0.1", + "is-path-inside": "^3.0.1" } }, "is-npm": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-3.0.0.tgz", - "integrity": "sha512-wsigDr1Kkschp2opC4G3yA6r9EgVA6NjRpWzIi9axXqeIaAATPRJc4uLujXe3Nd9uO8KoDyA4MD6aZSeXTADhA==", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-4.0.0.tgz", + "integrity": "sha512-96ECIfh9xtDDlPylNPXhzjsykHsMJZ18ASpaWzQyBr4YRTcVjUvzaHayDAES2oU/3KpljhHUjtSRNiDwi0F0ig==", "dev": true }, "is-obj": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", - "integrity": "sha1-PkcprB9f3gJc19g6iW2rn09n2w8=", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-2.0.0.tgz", + "integrity": "sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==", "dev": true }, "is-path-inside": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.1.tgz", - "integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=", - "dev": true, - "requires": { - "path-is-inside": "^1.0.1" - } + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.2.tgz", + "integrity": "sha512-/2UGPSgmtqwo1ktx8NDHjuPwZWmHhO+gj0f93EkhLB5RgW9RZevWYYlIkS6zePc6U2WpOdQYIwHe9YC4DWEBVg==", + "dev": true }, "is-stream": { "version": "1.1.0", @@ -1311,7 +1399,8 @@ "is-utf8": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", - "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=" + "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=", + "dev": true }, "is-yarn-global": { "version": "0.3.0", @@ -1330,12 +1419,6 @@ "integrity": "sha512-Jvz0gpTh1AILHMCBUyqq7xv1ZOQrxTDwyp1/QUq1xFpOBvp4AH5uEobPePJht8KnBGqQIH7We6OR73mXsjG0cA==", "dev": true }, - "isexe": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", - "dev": true - }, "isstream": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", @@ -1359,14 +1442,12 @@ "jsbn": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", - "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", - "optional": true + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=" }, "json-buffer": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.0.tgz", - "integrity": "sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=", - "dev": true + "integrity": "sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=" }, "json-schema": { "version": "0.2.3", @@ -1374,9 +1455,9 @@ "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" }, "json-schema-traverse": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", - "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" }, "json-stringify-safe": { "version": "5.0.1", @@ -1415,7 +1496,6 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/keyv/-/keyv-3.1.0.tgz", "integrity": "sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==", - "dev": true, "requires": { "json-buffer": "3.0.0" } @@ -1439,6 +1519,7 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", + "dev": true, "requires": { "graceful-fs": "^4.1.2", "parse-json": "^2.2.0", @@ -1450,24 +1531,31 @@ "pify": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true } } }, "locate-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", - "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", "dev": true, "requires": { - "p-locate": "^3.0.0", - "path-exists": "^3.0.0" + "p-locate": "^4.1.0" } }, + "lodash": { + "version": "4.17.15", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz", + "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==", + "optional": true + }, "loud-rejection": { "version": "1.6.0", "resolved": "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz", "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", + "dev": true, "requires": { "currently-unhandled": "^0.4.1", "signal-exit": "^3.0.0" @@ -1476,17 +1564,15 @@ "lowercase-keys": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz", - "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==", - "dev": true + "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==" }, "lru-cache": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", - "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", "dev": true, "requires": { - "pseudomap": "^1.0.2", - "yallist": "^2.1.2" + "yallist": "^3.0.2" } }, "make-dir": { @@ -1500,12 +1586,23 @@ "map-obj": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz", - "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=" + "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=", + "dev": true + }, + "matcher": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/matcher/-/matcher-2.1.0.tgz", + "integrity": "sha512-o+nZr+vtJtgPNklyeUKkkH42OsK8WAfdgaJE2FNxcjLPg+5QbeEoT6vRj8Xq/iv18JlQ9cmKsEu0b94ixWf1YQ==", + "optional": true, + "requires": { + "escape-string-regexp": "^2.0.0" + } }, "meow": { "version": "3.7.0", "resolved": "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz", "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", + "dev": true, "requires": { "camelcase-keys": "^2.0.0", "decamelize": "^1.1.2", @@ -1526,23 +1623,22 @@ "dev": true }, "mime-db": { - "version": "1.36.0", - "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.36.0.tgz", - "integrity": "sha512-L+xvyD9MkoYMXb1jAmzI/lWYAxAMCPvIBSWur0PZ5nOf5euahRLVqH//FKW9mWp2lkqUgYiXPgkzfMUFi4zVDw==" + "version": "1.43.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.43.0.tgz", + "integrity": "sha512-+5dsGEEovYbT8UY9yD7eE4XTc4UwJ1jBYlgaQQF38ENsKR3wj/8q8RFZrF9WIZpB2V1ArTVFUva8sAul1NzRzQ==" }, "mime-types": { - "version": "2.1.20", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.20.tgz", - "integrity": "sha512-HrkrPaP9vGuWbLK1B1FfgAkbqNjIuy4eHlIYnFi7kamZyLLrGlo2mpcx0bBmNpKqBtYtAfGbodDddIgddSJC2A==", + "version": "2.1.26", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.26.tgz", + "integrity": "sha512-01paPWYgLrkqAyrlDorC1uDwl2p3qZT7yl806vW7DvDoxwXi46jsjFbg+WdwotBIk6/MbEhO/dh5aZ5sNj/dWQ==", "requires": { - "mime-db": "~1.36.0" + "mime-db": "1.43.0" } }, "mimic-response": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", - "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", - "dev": true + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==" }, "minimatch": { "version": "3.0.4", @@ -1567,20 +1663,19 @@ } }, "moment": { - "version": "2.22.2", - "resolved": "https://registry.npmjs.org/moment/-/moment-2.22.2.tgz", - "integrity": "sha1-PCV/mDn8DpP/UxSWMiOeuQeD/2Y=" + "version": "2.24.0", + "resolved": "https://registry.npmjs.org/moment/-/moment-2.24.0.tgz", + "integrity": "sha512-bV7f+6l2QigeBBZSM/6yTNq4P2fNpSWj/0e7jQcy87A8e7o2nAfP/34/2ky5Vw4B9S446EtIhodAzkFCcR4dQg==" }, "ms": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", - "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" }, "node-addon-api": { "version": "1.7.1", "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.1.tgz", - "integrity": "sha512-2+DuKodWvwRTrCfKOeR24KIc5unKjOh8mz17NCzVnHWfjAdDqbfbjqh7gUT+BkXBRQM52+xCHciKWonJ3CbJMQ==", - "dev": true + "integrity": "sha512-2+DuKodWvwRTrCfKOeR24KIc5unKjOh8mz17NCzVnHWfjAdDqbfbjqh7gUT+BkXBRQM52+xCHciKWonJ3CbJMQ==" }, "node-fetch": { "version": "2.6.0", @@ -1591,32 +1686,42 @@ "version": "2.5.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", "integrity": "sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==", + "dev": true, "requires": { "hosted-git-info": "^2.1.4", "resolve": "^1.10.0", "semver": "2 || 3 || 4 || 5", "validate-npm-package-license": "^3.0.1" + }, + "dependencies": { + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + } } }, "normalize-url": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-4.5.0.tgz", - "integrity": "sha512-2s47yzUxdexf1OhyRi4Em83iQk0aPvwTddtFz4hnSSw9dCEsLEGf6SwIO8ss/19S9iBb5sJaOuTvTGDeZI00BQ==", - "dev": true + "integrity": "sha512-2s47yzUxdexf1OhyRi4Em83iQk0aPvwTddtFz4hnSSw9dCEsLEGf6SwIO8ss/19S9iBb5sJaOuTvTGDeZI00BQ==" }, - "npm-run-path": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz", - "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", - "dev": true, + "npm-conf": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/npm-conf/-/npm-conf-1.1.3.tgz", + "integrity": "sha512-Yic4bZHJOt9RCFbRP3GgpqhScOY4HH3V2P8yBj6CeYq118Qr+BLXqT2JvpJ00mryLESpgOxf5XlFv4ZjXxLScw==", + "optional": true, "requires": { - "path-key": "^2.0.0" + "config-chain": "^1.1.11", + "pify": "^3.0.0" } }, "nugget": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/nugget/-/nugget-2.0.1.tgz", "integrity": "sha1-IBCVpIfhrTYIGzQy+jytpPjQcbA=", + "dev": true, "requires": { "debug": "^2.1.3", "minimist": "^1.1.0", @@ -1625,12 +1730,30 @@ "request": "^2.45.0", "single-line-log": "^1.1.2", "throttleit": "0.0.2" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "dev": true, + "requires": { + "ms": "2.0.0" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", + "dev": true + } } }, "number-is-nan": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", - "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=" + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", + "dev": true }, "oauth-sign": { "version": "0.9.0", @@ -1640,18 +1763,19 @@ "object-assign": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", - "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=", + "dev": true }, "object-keys": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz", - "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=" + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "optional": true }, "once": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", - "dev": true, "requires": { "wrappy": "1" } @@ -1659,14 +1783,7 @@ "p-cancelable": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-1.1.0.tgz", - "integrity": "sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==", - "dev": true - }, - "p-finally": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", - "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=", - "dev": true + "integrity": "sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==" }, "p-limit": { "version": "2.2.2", @@ -1678,12 +1795,12 @@ } }, "p-locate": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", - "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", "dev": true, "requires": { - "p-limit": "^2.0.0" + "p-limit": "^2.2.0" } }, "p-try": { @@ -1712,27 +1829,11 @@ } } }, - "parse-color": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/parse-color/-/parse-color-1.0.0.tgz", - "integrity": "sha1-e3SLlag/A/FqlPU15S1/PZRlhhk=", - "dev": true, - "requires": { - "color-convert": "~0.5.0" - }, - "dependencies": { - "color-convert": { - "version": "0.5.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-0.5.3.tgz", - "integrity": "sha1-vbbGnOZg+t/+CwAHzER+G59ygr0=", - "dev": true - } - } - }, "parse-json": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, "requires": { "error-ex": "^1.2.0" } @@ -1740,29 +1841,20 @@ "path-exists": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", - "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=" - }, - "path-is-inside": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz", - "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=", - "dev": true - }, - "path-key": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", - "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", "dev": true }, "path-parse": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", - "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==" + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "dev": true }, "path-type": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", + "dev": true, "requires": { "graceful-fs": "^4.1.2", "pify": "^2.0.0", @@ -1772,7 +1864,8 @@ "pify": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", - "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true } } }, @@ -1794,37 +1887,28 @@ "pinkie": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", - "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=" + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", + "dev": true }, "pinkie-promise": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", - "requires": { - "pinkie": "^2.0.0" - } - }, - "plist": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/plist/-/plist-3.0.1.tgz", - "integrity": "sha512-GpgvHHocGRyQm74b6FWEZZVRroHKE1I0/BTjAmySaohK+cUn+hZpbqXkc3KWgW3gQYkqcQej35FohcT0FRlkRQ==", "dev": true, "requires": { - "base64-js": "^1.2.3", - "xmlbuilder": "^9.0.7", - "xmldom": "0.1.x" + "pinkie": "^2.0.0" } }, "prepend-http": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-2.0.0.tgz", - "integrity": "sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=", - "dev": true + "integrity": "sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=" }, "pretty-bytes": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-1.0.4.tgz", "integrity": "sha1-CiLoIQYJrTVUL4yNXSFZr/B1HIQ=", + "dev": true, "requires": { "get-stdin": "^4.0.1", "meow": "^3.1.0" @@ -1835,44 +1919,57 @@ "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==" }, + "progress": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz", + "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==" + }, "progress-stream": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/progress-stream/-/progress-stream-1.2.0.tgz", "integrity": "sha1-LNPP6jO6OonJwSHsM0er6asSX3c=", + "dev": true, "requires": { "speedometer": "~0.1.2", "through2": "~0.2.3" } }, - "pseudomap": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", - "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", - "dev": true + "proto-list": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", + "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=", + "optional": true }, "psl": { - "version": "1.1.29", - "resolved": "https://registry.npmjs.org/psl/-/psl-1.1.29.tgz", - "integrity": "sha512-AeUmQ0oLN02flVHXWh9sSJF7mcdFq0ppid/JkErufc3hGIV/AMa8Fo9VgDo/cT2jFdOWoFvHp90qqBH54W+gjQ==" + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz", + "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==" }, "pump": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz", "integrity": "sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==", - "dev": true, "requires": { "end-of-stream": "^1.1.0", "once": "^1.3.1" } }, "punycode": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", - "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", + "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==" + }, + "pupa": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pupa/-/pupa-2.0.1.tgz", + "integrity": "sha512-hEJH0s8PXLY/cdXh66tNEQGndDrIKNqNC5xmrysZy3i5C3oEoLna7YAOad+7u125+zH1HNXUmGEkrhb3c2VriA==", + "dev": true, + "requires": { + "escape-goat": "^2.0.0" + } }, "q": { - "version": "git+https://github.com/kriskowal/q.git#8545bd6f6953dfd2a5e7fa4052ed6b39e010a8c5", - "from": "git+https://github.com/kriskowal/q.git" + "version": "file:modules/q-master" }, "qs": { "version": "6.5.2", @@ -1883,6 +1980,7 @@ "version": "1.2.8", "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "dev": true, "requires": { "deep-extend": "^0.6.0", "ini": "~1.3.0", @@ -1891,73 +1989,24 @@ } }, "read-config-file": { - "version": "3.2.2", - "resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-3.2.2.tgz", - "integrity": "sha512-PuFpMgZF01VB0ydH1dfitAxCP/fh+qnfbA9cYNIPoxPbz0SMngsrafCtaHDWfER7MwlDz4fmrNBhPkakxxFpTg==", - "dev": true, - "requires": { - "ajv": "^6.9.2", - "ajv-keywords": "^3.4.0", - "bluebird-lst": "^1.0.7", - "dotenv": "^6.2.0", - "dotenv-expand": "^4.2.0", - "fs-extra-p": "^7.0.1", - "js-yaml": "^3.12.1", - "json5": "^2.1.0", + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/read-config-file/-/read-config-file-5.0.2.tgz", + "integrity": "sha512-tVt1lsiSjs+FtL/vtfCivqtKR1UNk3BB3uPJQvJqkgtAYDvZjo0xyXFYSVmzaTcO+Jdi5G7O2K2vDV+p1M/oug==", + "dev": true, + "requires": { + "dotenv": "^8.2.0", + "dotenv-expand": "^5.1.0", + "fs-extra": "^8.1.0", + "js-yaml": "^3.13.1", + "json5": "^2.1.1", "lazy-val": "^1.0.4" - }, - "dependencies": { - "ajv": { - "version": "6.12.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.0.tgz", - "integrity": "sha512-D6gFiFA0RRLyUbvijN74DWAjXSFxWKaWP7mldxkVhyhAV3+SWA9HEJPHQ2c9soIeTFJqcSdFDGFgdqs1iUU2Hw==", - "dev": true, - "requires": { - "fast-deep-equal": "^3.1.1", - "fast-json-stable-stringify": "^2.0.0", - "json-schema-traverse": "^0.4.1", - "uri-js": "^4.2.2" - } - }, - "fast-deep-equal": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.1.tgz", - "integrity": "sha512-8UEa58QDLauDNfpbrX55Q9jrGHThw2ZMdOky5Gl1CDtVeJDPVrG4Jxx1N8jw2gkWaff5UUuX1KJd+9zGe2B+ZA==", - "dev": true - }, - "fs-extra": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz", - "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==", - "dev": true, - "requires": { - "graceful-fs": "^4.1.2", - "jsonfile": "^4.0.0", - "universalify": "^0.1.0" - } - }, - "fs-extra-p": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/fs-extra-p/-/fs-extra-p-7.0.1.tgz", - "integrity": "sha512-yhd2OV0HnHt2oitlp+X9hl2ReX4X/7kQeL7/72qzPHTZj5eUPGzAKOvEglU02Fa1OeG2rSy/aKB4WGVaLiF8tw==", - "dev": true, - "requires": { - "bluebird-lst": "^1.0.7", - "fs-extra": "^7.0.1" - } - }, - "json-schema-traverse": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", - "dev": true - } } }, "read-pkg": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", + "dev": true, "requires": { "load-json-file": "^1.0.0", "normalize-package-data": "^2.3.2", @@ -1968,6 +2017,7 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", + "dev": true, "requires": { "find-up": "^1.0.0", "read-pkg": "^1.0.0" @@ -1991,6 +2041,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz", "integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=", + "dev": true, "requires": { "indent-string": "^2.1.0", "strip-indent": "^1.0.1" @@ -2000,7 +2051,6 @@ "version": "0.0.2", "resolved": "https://registry.npmjs.org/register-scheme/-/register-scheme-0.0.2.tgz", "integrity": "sha512-tMExba6xoLEZVtNnue+oSgnVLs489Df5toLlYThHLC4rsWcf/o+VGDK3VXSqEb8GzQ3NMmkHSMNIzI/Qm2j6Hw==", - "dev": true, "requires": { "bindings": "^1.3.0", "node-addon-api": "^1.3.0" @@ -2028,14 +2078,15 @@ "version": "2.0.1", "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz", "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", + "dev": true, "requires": { "is-finite": "^1.0.0" } }, "request": { - "version": "2.88.0", - "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz", - "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==", + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", "requires": { "aws-sign2": "~0.7.0", "aws4": "^1.8.0", @@ -2044,7 +2095,7 @@ "extend": "~3.0.2", "forever-agent": "~0.6.1", "form-data": "~2.3.2", - "har-validator": "~5.1.0", + "har-validator": "~5.1.3", "http-signature": "~1.2.0", "is-typedarray": "~1.0.0", "isstream": "~0.1.2", @@ -2054,7 +2105,7 @@ "performance-now": "^2.1.0", "qs": "~6.5.2", "safe-buffer": "^5.1.2", - "tough-cookie": "~2.4.3", + "tough-cookie": "~2.5.0", "tunnel-agent": "^0.6.0", "uuid": "^3.3.2" } @@ -2075,6 +2126,7 @@ "version": "1.15.1", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.15.1.tgz", "integrity": "sha512-84oo6ZTtoTUpjgNEr5SJyzQhzL72gaRodsSfyxC/AXRvwu0Yse9H8eF9IpGo7b8YetZhlI6v7ZQ6bKBFV/6S7w==", + "dev": true, "requires": { "path-parse": "^1.0.6" } @@ -2083,11 +2135,24 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/responselike/-/responselike-1.0.2.tgz", "integrity": "sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=", - "dev": true, "requires": { "lowercase-keys": "^1.0.0" } }, + "roarr": { + "version": "2.15.2", + "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.2.tgz", + "integrity": "sha512-jmaDhK9CO4YbQAV8zzCnq9vjAqeO489MS5ehZ+rXmFiPFFE6B+S9KYO6prjmLJ5A0zY3QxVlQdrIya7E/azz/Q==", + "optional": true, + "requires": { + "boolean": "^3.0.0", + "detect-node": "^2.0.4", + "globalthis": "^1.0.1", + "json-stringify-safe": "^5.0.1", + "semver-compare": "^1.0.0", + "sprintf-js": "^1.1.2" + } + }, "safe-buffer": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", @@ -2102,7 +2167,6 @@ "version": "1.6.3", "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.3.tgz", "integrity": "sha512-y/52Mcy7aw3gRm7IrcGDFx/bCk4AhRh2eI9luHOQM86nZsqwiRkkq2GekHXBBD+SmPidc8i2PqtYZl+pWJ8Oeg==", - "dev": true, "requires": { "truncate-utf8-bytes": "^1.0.0" } @@ -2114,17 +2178,40 @@ "dev": true }, "semver": { - "version": "5.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", - "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==" + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.1.3.tgz", + "integrity": "sha512-ekM0zfiA9SCBlsKa2X1hxyxiI4L3B6EbVJkkdgQXnSEEaHlGdvyodMruTiulSRWMMB4NeIuYNMC9rTKTz97GxA==" + }, + "semver-compare": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz", + "integrity": "sha1-De4hahyUGrN+nvsXiPavxf9VN/w=", + "optional": true }, "semver-diff": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-2.1.0.tgz", - "integrity": "sha1-S7uEN8jTfksM8aaP1ybsbWRdbTY=", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/semver-diff/-/semver-diff-3.1.1.tgz", + "integrity": "sha512-GX0Ix/CJcHyB8c4ykpHGIAvLyOwOobtM/8d+TQkAd81/bEjgPHrfba41Vpesr7jX/t8Uh+R3EX9eAS5be+jQYg==", "dev": true, "requires": { - "semver": "^5.0.3" + "semver": "^6.3.0" + }, + "dependencies": { + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + } + } + }, + "serialize-error": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-5.0.0.tgz", + "integrity": "sha512-/VtpuyzYf82mHYTtI4QKtwHa79vAdU5OQpNPAmE/0UDdlGT0ZxHwC+J6gXkw29wwoVI8fMPsfcVHOwXtUQYYQA==", + "optional": true, + "requires": { + "type-fest": "^0.8.0" } }, "set-blocking": { @@ -2133,30 +2220,17 @@ "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", "dev": true }, - "shebang-command": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", - "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", - "dev": true, - "requires": { - "shebang-regex": "^1.0.0" - } - }, - "shebang-regex": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", - "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", - "dev": true - }, "signal-exit": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.3.tgz", - "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==" + "integrity": "sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA==", + "dev": true }, "single-line-log": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/single-line-log/-/single-line-log-1.1.2.tgz", "integrity": "sha1-wvg/Jzo+GhbtsJlWYdoO1e8DM2Q=", + "dev": true, "requires": { "string-width": "^1.0.1" } @@ -2181,6 +2255,7 @@ "version": "3.1.0", "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz", "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==", + "dev": true, "requires": { "spdx-expression-parse": "^3.0.0", "spdx-license-ids": "^3.0.0" @@ -2189,12 +2264,14 @@ "spdx-exceptions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz", - "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==" + "integrity": "sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==", + "dev": true }, "spdx-expression-parse": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", + "dev": true, "requires": { "spdx-exceptions": "^2.1.0", "spdx-license-ids": "^3.0.0" @@ -2203,23 +2280,25 @@ "spdx-license-ids": { "version": "3.0.5", "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz", - "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==" + "integrity": "sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q==", + "dev": true }, "speedometer": { "version": "0.1.4", "resolved": "https://registry.npmjs.org/speedometer/-/speedometer-0.1.4.tgz", - "integrity": "sha1-mHbb0qFp0xFUAtSObqYynIgWpQ0=" + "integrity": "sha1-mHbb0qFp0xFUAtSObqYynIgWpQ0=", + "dev": true }, "sprintf-js": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", - "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=", - "dev": true + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.2.tgz", + "integrity": "sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==", + "optional": true }, "sshpk": { - "version": "1.14.2", - "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.2.tgz", - "integrity": "sha1-xvxhZIo9nE52T9P8306hBeSSupg=", + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz", + "integrity": "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==", "requires": { "asn1": "~0.2.3", "assert-plus": "^1.0.0", @@ -2233,15 +2312,16 @@ } }, "stat-mode": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-0.3.0.tgz", - "integrity": "sha512-QjMLR0A3WwFY2aZdV0okfFEJB5TRjkggXZjxP3A1RsWsNHNu3YPv8btmtc6iCFZ0Rul3FE93OYogvhOUClU+ng==", + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz", + "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==", "dev": true }, "string-width": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "dev": true, "requires": { "code-point-at": "^1.0.0", "is-fullwidth-code-point": "^1.0.0", @@ -2260,6 +2340,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "dev": true, "requires": { "ansi-regex": "^2.0.0" } @@ -2268,20 +2349,16 @@ "version": "2.0.0", "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", + "dev": true, "requires": { "is-utf8": "^0.2.0" } }, - "strip-eof": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", - "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", - "dev": true - }, "strip-indent": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz", "integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=", + "dev": true, "requires": { "get-stdin": "^4.0.1" } @@ -2289,23 +2366,24 @@ "strip-json-comments": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", - "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=" + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", + "dev": true }, "sumchecker": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-2.0.2.tgz", - "integrity": "sha1-D0LBDl0F2l1C7qPlbDOZo31sWz4=", + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz", + "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==", "requires": { - "debug": "^2.2.0" + "debug": "^4.1.0" } }, "supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.1.0.tgz", + "integrity": "sha512-oRSIpR8pxT1Wr2FquTNnGet79b3BWljqOuoW/h4oBhxJ/HUbX5nX6JSruTkvXDCFMwDPvsaTTbvMLKZWSy0R5g==", "dev": true, "requires": { - "has-flag": "^3.0.0" + "has-flag": "^4.0.0" } }, "temp-dir": { @@ -2321,25 +2399,6 @@ "requires": { "async-exit-hook": "^2.0.1", "fs-extra": "^8.1.0" - }, - "dependencies": { - "fs-extra": { - "version": "8.1.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", - "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", - "dev": true, - "requires": { - "graceful-fs": "^4.2.0", - "jsonfile": "^4.0.0", - "universalify": "^0.1.0" - } - }, - "graceful-fs": { - "version": "4.2.3", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.3.tgz", - "integrity": "sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==", - "dev": true - } } }, "temp-write": { @@ -2356,23 +2415,22 @@ } }, "term-size": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/term-size/-/term-size-1.2.0.tgz", - "integrity": "sha1-RYuDiH8oj8Vtb/+/rSYuJmOO+mk=", - "dev": true, - "requires": { - "execa": "^0.7.0" - } + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/term-size/-/term-size-2.2.0.tgz", + "integrity": "sha512-a6sumDlzyHVJWb8+YofY4TW112G6p2FCPEAFk+59gIYHv3XHRhm9ltVQ9kli4hNWeQBwSpe8cRN25x0ROunMOw==", + "dev": true }, "throttleit": { "version": "0.0.2", "resolved": "https://registry.npmjs.org/throttleit/-/throttleit-0.0.2.tgz", - "integrity": "sha1-z+34jmDADdlpe2H90qg0OptoDq8=" + "integrity": "sha1-z+34jmDADdlpe2H90qg0OptoDq8=", + "dev": true }, "through2": { "version": "0.2.3", "resolved": "https://registry.npmjs.org/through2/-/through2-0.2.3.tgz", "integrity": "sha1-6zKE2k6jEbbMis42U3SKUqvyWj8=", + "dev": true, "requires": { "readable-stream": "~1.1.9", "xtend": "~2.1.1" @@ -2381,12 +2439,14 @@ "isarray": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true }, "readable-stream": { "version": "1.1.14", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "dev": true, "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.1", @@ -2397,39 +2457,45 @@ "string_decoder": { "version": "0.10.31", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", - "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true } } }, "to-readable-stream": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/to-readable-stream/-/to-readable-stream-1.0.0.tgz", - "integrity": "sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==", - "dev": true + "integrity": "sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==" }, "tough-cookie": { - "version": "2.4.3", - "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz", - "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==", + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", "requires": { - "psl": "^1.1.24", - "punycode": "^1.4.1" + "psl": "^1.1.28", + "punycode": "^2.1.1" } }, "trim-newlines": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz", - "integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=" + "integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=", + "dev": true }, "truncate-utf8-bytes": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz", "integrity": "sha1-QFkjkJWS1W94pYGENLC3hInKXys=", - "dev": true, "requires": { "utf8-byte-length": "^1.0.1" } }, + "tunnel": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz", + "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==", + "optional": true + }, "tunnel-agent": { "version": "0.6.0", "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", @@ -2441,27 +2507,34 @@ "tweetnacl": { "version": "0.14.5", "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", - "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", - "optional": true + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=" }, "type-fest": { - "version": "0.3.1", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.3.1.tgz", - "integrity": "sha512-cUGJnCdr4STbePCgqNFbpVNCepa+kAVohJs1sLhxzdH+gnEoOd8VhbYa7pD3zZYGiURWM2xzEII3fQcRizDkYQ==", - "dev": true + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz", + "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==" }, "typedarray": { "version": "0.0.6", "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" }, + "typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "dev": true, + "requires": { + "is-typedarray": "^1.0.0" + } + }, "unique-string": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-1.0.0.tgz", - "integrity": "sha1-nhBXzKhRq7kzmPizOuGHuZyuwRo=", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz", + "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==", "dev": true, "requires": { - "crypto-random-string": "^1.0.0" + "crypto-random-string": "^2.0.0" } }, "universalify": { @@ -2470,47 +2543,38 @@ "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==" }, "update-notifier": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-3.0.1.tgz", - "integrity": "sha512-grrmrB6Zb8DUiyDIaeRTBCkgISYUgETNe7NglEbVsrLWXeESnlCSP50WfRSj/GmzMPl6Uchj24S/p80nP/ZQrQ==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/update-notifier/-/update-notifier-4.1.0.tgz", + "integrity": "sha512-w3doE1qtI0/ZmgeoDoARmI5fjDoT93IfKgEGqm26dGUOh8oNpaSTsGNdYRN/SjOuo10jcJGwkEL3mroKzktkew==", "dev": true, "requires": { - "boxen": "^3.0.0", - "chalk": "^2.0.1", - "configstore": "^4.0.0", + "boxen": "^4.2.0", + "chalk": "^3.0.0", + "configstore": "^5.0.1", "has-yarn": "^2.1.0", "import-lazy": "^2.1.0", "is-ci": "^2.0.0", - "is-installed-globally": "^0.1.0", - "is-npm": "^3.0.0", + "is-installed-globally": "^0.3.1", + "is-npm": "^4.0.0", "is-yarn-global": "^0.3.0", "latest-version": "^5.0.0", - "semver-diff": "^2.0.0", - "xdg-basedir": "^3.0.0" + "pupa": "^2.0.1", + "semver-diff": "^3.1.1", + "xdg-basedir": "^4.0.0" } }, "uri-js": { "version": "4.2.2", "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz", "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==", - "dev": true, "requires": { "punycode": "^2.1.0" - }, - "dependencies": { - "punycode": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", - "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", - "dev": true - } } }, "url-parse-lax": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz", "integrity": "sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=", - "dev": true, "requires": { "prepend-http": "^2.0.0" } @@ -2518,8 +2582,7 @@ "utf8-byte-length": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.4.tgz", - "integrity": "sha1-9F8VDExm7uloGGUFq5P8u4rWv2E=", - "dev": true + "integrity": "sha1-9F8VDExm7uloGGUFq5P8u4rWv2E=" }, "util-deprecate": { "version": "1.0.2", @@ -2527,14 +2590,15 @@ "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" }, "uuid": { - "version": "3.3.2", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz", - "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==" + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz", + "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==" }, "validate-npm-package-license": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "dev": true, "requires": { "spdx-correct": "^3.0.0", "spdx-expression-parse": "^3.0.0" @@ -2550,15 +2614,6 @@ "extsprintf": "^1.2.0" } }, - "which": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", - "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", - "dev": true, - "requires": { - "isexe": "^2.0.0" - } - }, "which-module": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz", @@ -2566,43 +2621,50 @@ "dev": true }, "widest-line": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-2.0.1.tgz", - "integrity": "sha512-Ba5m9/Fa4Xt9eb2ELXt77JxVDV8w7qQrH0zS/TWSJdLyAwQjWoOzpzj5lwVftDz6n/EOu3tNACS84v509qwnJA==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/widest-line/-/widest-line-3.1.0.tgz", + "integrity": "sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==", "dev": true, "requires": { - "string-width": "^2.1.1" + "string-width": "^4.0.0" }, "dependencies": { "ansi-regex": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", - "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true }, "string-width": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", - "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", "dev": true, "requires": { - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^4.0.0" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "strip-ansi": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", - "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", "dev": true, "requires": { - "ansi-regex": "^3.0.0" + "ansi-regex": "^5.0.0" } } } @@ -2613,46 +2675,52 @@ "integrity": "sha1-ugZWKbepJRMOFXeRCM9UCZDpjRs=" }, "wrap-ansi": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", - "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz", + "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==", "dev": true, "requires": { - "ansi-styles": "^3.2.0", - "string-width": "^3.0.0", - "strip-ansi": "^5.0.0" + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" }, "dependencies": { "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "dev": true }, "string-width": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", - "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", "dev": true, "requires": { - "emoji-regex": "^7.0.1", - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^5.1.0" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "strip-ansi": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", - "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", "dev": true, "requires": { - "ansi-regex": "^4.1.0" + "ansi-regex": "^5.0.0" } } } @@ -2660,18 +2728,18 @@ "wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=", - "dev": true + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" }, "write-file-atomic": { - "version": "2.4.3", - "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.3.tgz", - "integrity": "sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", "dev": true, "requires": { - "graceful-fs": "^4.1.11", "imurmurhash": "^0.1.4", - "signal-exit": "^3.0.2" + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" } }, "ws": { @@ -2683,21 +2751,9 @@ } }, "xdg-basedir": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-3.0.0.tgz", - "integrity": "sha1-SWsswQnsqNus/i3HK2A8F8WHCtQ=", - "dev": true - }, - "xmlbuilder": { - "version": "9.0.7", - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.7.tgz", - "integrity": "sha1-Ey7mPS7FVlxVfiD0wi35rKaGsQ0=", - "dev": true - }, - "xmldom": { - "version": "0.1.31", - "resolved": "https://registry.npmjs.org/xmldom/-/xmldom-0.1.31.tgz", - "integrity": "sha512-yS2uJflVQs6n+CyjHoaBmVSqIDevTAWrzMmjG1Gc7h1qQ7uVozNhEPJAwZXWyGQ/Gafo3fCwrcaokezLPupVyQ==", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/xdg-basedir/-/xdg-basedir-4.0.0.tgz", + "integrity": "sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==", "dev": true }, "xmlhttprequest": { @@ -2709,8 +2765,17 @@ "version": "2.1.2", "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz", "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=", + "dev": true, "requires": { "object-keys": "~0.4.0" + }, + "dependencies": { + "object-keys": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz", + "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=", + "dev": true + } } }, "y18n": { @@ -2720,76 +2785,90 @@ "dev": true }, "yallist": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", - "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", "dev": true }, "yargs": { - "version": "13.3.2", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz", - "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==", + "version": "15.3.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.3.1.tgz", + "integrity": "sha512-92O1HWEjw27sBfgmXiixJWT5hRBp2eobqXicLtPBIDBhYB+1HpwZlXmbW2luivBJHBzki+7VyCLRtAkScbTBQA==", "dev": true, "requires": { - "cliui": "^5.0.0", - "find-up": "^3.0.0", + "cliui": "^6.0.0", + "decamelize": "^1.2.0", + "find-up": "^4.1.0", "get-caller-file": "^2.0.1", "require-directory": "^2.1.1", "require-main-filename": "^2.0.0", "set-blocking": "^2.0.0", - "string-width": "^3.0.0", + "string-width": "^4.2.0", "which-module": "^2.0.0", "y18n": "^4.0.0", - "yargs-parser": "^13.1.2" + "yargs-parser": "^18.1.1" }, "dependencies": { "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", "dev": true }, "find-up": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", - "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", "dev": true, "requires": { - "locate-path": "^3.0.0" + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" } }, "is-fullwidth-code-point": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", - "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true }, "string-width": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", - "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.0.tgz", + "integrity": "sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg==", "dev": true, "requires": { - "emoji-regex": "^7.0.1", - "is-fullwidth-code-point": "^2.0.0", - "strip-ansi": "^5.1.0" + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" } }, "strip-ansi": { - "version": "5.2.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", - "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", "dev": true, "requires": { - "ansi-regex": "^4.1.0" + "ansi-regex": "^5.0.0" } } } }, "yargs-parser": { - "version": "13.1.2", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz", - "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==", + "version": "18.1.2", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.2.tgz", + "integrity": "sha512-hlIPNR3IzC1YuL1c2UwwDKpXlNFBqD1Fswwh1khz5+d8Cq/8yc/Mn0i+rQXduu8hcrFKvO7Eryk+09NecTQAAQ==", "dev": true, "requires": { "camelcase": "^5.0.0", diff --git a/package.json b/package.json index 7bfbf8b..bbe9066 100644 --- a/package.json +++ b/package.json @@ -6,7 +6,8 @@ "main": "main.js", "scripts": { "start": "electron .", - "dist": "build", + "pack": "electron-builder --dir", + "dist": "electron-builder", "postinstall": "" }, "repository": { @@ -50,22 +51,22 @@ }, "homepage": "https://github.com/BrianPetkovsek/discord-youtube#readme", "dependencies": { + "bad-words": "^1.6.4", "discord-rpc": "^3.0.1", "electron-discord-register": "^1.0.0", "electron-widevinecdm": "file:modules/electron-widevinecdm", - "jquery": "^3.3.1", "moment": "^2.22.2", - "bad-words": "^1.6.4", - "q": "git+https://github.com/kriskowal/q.git", - "request": "^2.88.0", + "q": "file:modules/q-master", + "request": "^2.88.2", "temp-write": "^3.4.0", "xmlhttprequest": "^1.8.0", "youtube-js": "file:modules/youtube-js" }, "devDependencies": { - "electron": "^4.1.4", - "electron-builder": "^20.43.0", - "register-scheme": "0.0.2" + "electron": "^4.2.4", + "electron-builder": "^22.3.2", + "register-scheme": "0.0.2", + "node-fetch": "^2.6.0" }, "os": [ "win32",